blob: 6856c18aa88d8e3de3bdb51798deb5461be21f08 [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 Bonzini737e1502012-12-17 18:19:44 +010027#include "block/block_int.h"
28#include "block/blockjob.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010029#include "qemu/module.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010030#include "qapi/qmp/qjson.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010031#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010032#include "qemu/notify.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010033#include "block/coroutine.h"
Benoît Canetc13163f2014-01-23 21:31:34 +010034#include "block/qapi.h"
Luiz Capitulinob2023812011-09-21 17:16:47 -030035#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010036#include "qemu/timer.h"
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +020037#include "qapi-event.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 */
Kevin Wolf20cca272014-06-04 14:33:27 +0200834 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
Kevin Wolf7b272452012-11-12 17:05:39 +0100835
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);
Kevin Wolf20cca272014-06-04 14:33:27 +0200931 bs->growable = !!(flags & BDRV_O_PROTOCOL);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800932
933 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200934 error_setg(errp,
935 !bs->read_only && bdrv_is_whitelisted(drv, true)
936 ? "Driver '%s' can only be used for read-only devices"
937 : "Driver '%s' is not whitelisted",
938 drv->format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800939 return -ENOTSUP;
940 }
Kevin Wolf57915332010-04-14 15:24:50 +0200941
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000942 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200943 if (flags & BDRV_O_COPY_ON_READ) {
944 if (!bs->read_only) {
945 bdrv_enable_copy_on_read(bs);
946 } else {
947 error_setg(errp, "Can't use copy-on-read on read-only device");
948 return -EINVAL;
949 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000950 }
951
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100952 if (filename != NULL) {
953 pstrcpy(bs->filename, sizeof(bs->filename), filename);
954 } else {
955 bs->filename[0] = '\0';
956 }
Kevin Wolf57915332010-04-14 15:24:50 +0200957
Kevin Wolf57915332010-04-14 15:24:50 +0200958 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500959 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200960
Stefan Hajnoczi03f541b2011-10-27 10:54:28 +0100961 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100962
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200963 /* Open the image, either directly or using a protocol */
964 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100965 assert(file == NULL);
Benoît Canet030be322013-09-24 17:07:04 +0200966 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200967 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +0100968 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200969 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200970 error_setg(errp, "Can't use '%s' as a block driver for the "
971 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200972 ret = -EINVAL;
973 goto free_and_fail;
974 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100975 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200976 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200977 }
978
Kevin Wolf57915332010-04-14 15:24:50 +0200979 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100980 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200981 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +0800982 } else if (bs->filename[0]) {
983 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200984 } else {
985 error_setg_errno(errp, -ret, "Could not open image");
986 }
Kevin Wolf57915332010-04-14 15:24:50 +0200987 goto free_and_fail;
988 }
989
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100990 ret = refresh_total_sectors(bs, bs->total_sectors);
991 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200992 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100993 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200994 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100995
Kevin Wolfd34682c2013-12-11 19:26:16 +0100996 bdrv_refresh_limits(bs);
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100997 assert(bdrv_opt_mem_align(bs) != 0);
Kevin Wolf47ea2de2014-03-05 15:49:55 +0100998 assert((bs->request_alignment != 0) || bs->sg);
Kevin Wolf57915332010-04-14 15:24:50 +0200999 return 0;
1000
1001free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001002 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -05001003 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +02001004 bs->opaque = NULL;
1005 bs->drv = NULL;
1006 return ret;
1007}
1008
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001009static QDict *parse_json_filename(const char *filename, Error **errp)
1010{
1011 QObject *options_obj;
1012 QDict *options;
1013 int ret;
1014
1015 ret = strstart(filename, "json:", &filename);
1016 assert(ret);
1017
1018 options_obj = qobject_from_json(filename);
1019 if (!options_obj) {
1020 error_setg(errp, "Could not parse the JSON options");
1021 return NULL;
1022 }
1023
1024 if (qobject_type(options_obj) != QTYPE_QDICT) {
1025 qobject_decref(options_obj);
1026 error_setg(errp, "Invalid JSON object given");
1027 return NULL;
1028 }
1029
1030 options = qobject_to_qdict(options_obj);
1031 qdict_flatten(options);
1032
1033 return options;
1034}
1035
Kevin Wolf57915332010-04-14 15:24:50 +02001036/*
Kevin Wolff54120f2014-05-26 11:09:59 +02001037 * Fills in default options for opening images and converts the legacy
1038 * filename/flags pair to option QDict entries.
1039 */
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001040static int bdrv_fill_options(QDict **options, const char **pfilename, int flags,
Kevin Wolf17b005f2014-05-27 10:50:29 +02001041 BlockDriver *drv, Error **errp)
Kevin Wolff54120f2014-05-26 11:09:59 +02001042{
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001043 const char *filename = *pfilename;
Kevin Wolff54120f2014-05-26 11:09:59 +02001044 const char *drvname;
Kevin Wolf462f5bc2014-05-26 11:39:55 +02001045 bool protocol = flags & BDRV_O_PROTOCOL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001046 bool parse_filename = false;
1047 Error *local_err = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001048
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001049 /* Parse json: pseudo-protocol */
1050 if (filename && g_str_has_prefix(filename, "json:")) {
1051 QDict *json_options = parse_json_filename(filename, &local_err);
1052 if (local_err) {
1053 error_propagate(errp, local_err);
1054 return -EINVAL;
1055 }
1056
1057 /* Options given in the filename have lower priority than options
1058 * specified directly */
1059 qdict_join(*options, json_options, false);
1060 QDECREF(json_options);
1061 *pfilename = filename = NULL;
1062 }
1063
Kevin Wolff54120f2014-05-26 11:09:59 +02001064 /* Fetch the file name from the options QDict if necessary */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001065 if (protocol && filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001066 if (!qdict_haskey(*options, "filename")) {
1067 qdict_put(*options, "filename", qstring_from_str(filename));
1068 parse_filename = true;
1069 } else {
1070 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1071 "the same time");
1072 return -EINVAL;
1073 }
1074 }
1075
1076 /* Find the right block driver */
1077 filename = qdict_get_try_str(*options, "filename");
1078 drvname = qdict_get_try_str(*options, "driver");
1079
Kevin Wolf17b005f2014-05-27 10:50:29 +02001080 if (drv) {
1081 if (drvname) {
1082 error_setg(errp, "Driver specified twice");
1083 return -EINVAL;
1084 }
1085 drvname = drv->format_name;
1086 qdict_put(*options, "driver", qstring_from_str(drvname));
1087 } else {
1088 if (!drvname && protocol) {
1089 if (filename) {
1090 drv = bdrv_find_protocol(filename, parse_filename);
1091 if (!drv) {
1092 error_setg(errp, "Unknown protocol");
1093 return -EINVAL;
1094 }
1095
1096 drvname = drv->format_name;
1097 qdict_put(*options, "driver", qstring_from_str(drvname));
1098 } else {
1099 error_setg(errp, "Must specify either driver or file");
Kevin Wolff54120f2014-05-26 11:09:59 +02001100 return -EINVAL;
1101 }
Kevin Wolf17b005f2014-05-27 10:50:29 +02001102 } else if (drvname) {
1103 drv = bdrv_find_format(drvname);
1104 if (!drv) {
1105 error_setg(errp, "Unknown driver '%s'", drvname);
1106 return -ENOENT;
1107 }
Kevin Wolff54120f2014-05-26 11:09:59 +02001108 }
1109 }
1110
Kevin Wolf17b005f2014-05-27 10:50:29 +02001111 assert(drv || !protocol);
Kevin Wolff54120f2014-05-26 11:09:59 +02001112
1113 /* Driver-specific filename parsing */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001114 if (drv && drv->bdrv_parse_filename && parse_filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001115 drv->bdrv_parse_filename(filename, *options, &local_err);
1116 if (local_err) {
1117 error_propagate(errp, local_err);
1118 return -EINVAL;
1119 }
1120
1121 if (!drv->bdrv_needs_filename) {
1122 qdict_del(*options, "filename");
1123 }
1124 }
1125
1126 return 0;
1127}
1128
Fam Zheng8d24cce2014-05-23 21:29:45 +08001129void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1130{
1131
Fam Zheng826b6ca2014-05-23 21:29:47 +08001132 if (bs->backing_hd) {
1133 assert(bs->backing_blocker);
1134 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1135 } else if (backing_hd) {
1136 error_setg(&bs->backing_blocker,
1137 "device is used as backing hd of '%s'",
1138 bs->device_name);
1139 }
1140
Fam Zheng8d24cce2014-05-23 21:29:45 +08001141 bs->backing_hd = backing_hd;
1142 if (!backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001143 error_free(bs->backing_blocker);
1144 bs->backing_blocker = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001145 goto out;
1146 }
1147 bs->open_flags &= ~BDRV_O_NO_BACKING;
1148 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1149 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1150 backing_hd->drv ? backing_hd->drv->format_name : "");
Fam Zheng826b6ca2014-05-23 21:29:47 +08001151
1152 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1153 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1154 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
1155 bs->backing_blocker);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001156out:
1157 bdrv_refresh_limits(bs);
1158}
1159
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001160/*
1161 * Opens the backing file for a BlockDriverState if not yet open
1162 *
1163 * options is a QDict of options to pass to the block drivers, or NULL for an
1164 * empty set of options. The reference to the QDict is transferred to this
1165 * function (even on failure), so if the caller intends to reuse the dictionary,
1166 * it needs to use QINCREF() before calling bdrv_file_open.
1167 */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001168int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02001169{
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001170 char *backing_filename = g_malloc0(PATH_MAX);
Kevin Wolf317fc442014-04-25 13:27:34 +02001171 int ret = 0;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001172 BlockDriver *back_drv = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001173 BlockDriverState *backing_hd;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001174 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001175
1176 if (bs->backing_hd != NULL) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001177 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001178 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001179 }
1180
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001181 /* NULL means an empty set of options */
1182 if (options == NULL) {
1183 options = qdict_new();
1184 }
1185
Paolo Bonzini9156df12012-10-18 16:49:17 +02001186 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolf1cb6f502013-04-12 20:27:07 +02001187 if (qdict_haskey(options, "file.filename")) {
1188 backing_filename[0] = '\0';
1189 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001190 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001191 goto free_exit;
Fam Zhengdbecebd2013-09-22 20:05:06 +08001192 } else {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001193 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001194 }
1195
Kevin Wolf8ee79e72014-06-04 15:09:35 +02001196 if (!bs->drv || !bs->drv->supports_backing) {
1197 ret = -EINVAL;
1198 error_setg(errp, "Driver doesn't support backing files");
1199 QDECREF(options);
1200 goto free_exit;
1201 }
1202
Fam Zheng8d24cce2014-05-23 21:29:45 +08001203 backing_hd = bdrv_new("", errp);
1204
Paolo Bonzini9156df12012-10-18 16:49:17 +02001205 if (bs->backing_format[0] != '\0') {
1206 back_drv = bdrv_find_format(bs->backing_format);
1207 }
1208
Max Reitzf67503e2014-02-18 18:33:05 +01001209 assert(bs->backing_hd == NULL);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001210 ret = bdrv_open(&backing_hd,
Max Reitzddf56362014-02-18 18:33:06 +01001211 *backing_filename ? backing_filename : NULL, NULL, options,
Kevin Wolf317fc442014-04-25 13:27:34 +02001212 bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001213 if (ret < 0) {
Fam Zheng8d24cce2014-05-23 21:29:45 +08001214 bdrv_unref(backing_hd);
1215 backing_hd = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001216 bs->open_flags |= BDRV_O_NO_BACKING;
Fam Zhengb04b6b62013-11-08 11:26:49 +08001217 error_setg(errp, "Could not open backing file: %s",
1218 error_get_pretty(local_err));
1219 error_free(local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001220 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001221 }
Fam Zheng8d24cce2014-05-23 21:29:45 +08001222 bdrv_set_backing_hd(bs, backing_hd);
Peter Feinerd80ac652014-01-08 19:43:25 +00001223
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001224free_exit:
1225 g_free(backing_filename);
1226 return ret;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001227}
1228
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001229/*
Max Reitzda557aa2013-12-20 19:28:11 +01001230 * Opens a disk image whose options are given as BlockdevRef in another block
1231 * device's options.
1232 *
Max Reitzda557aa2013-12-20 19:28:11 +01001233 * If allow_none is true, no image will be opened if filename is false and no
1234 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1235 *
1236 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1237 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1238 * itself, all options starting with "${bdref_key}." are considered part of the
1239 * BlockdevRef.
1240 *
1241 * The BlockdevRef will be removed from the options QDict.
Max Reitzf67503e2014-02-18 18:33:05 +01001242 *
1243 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
Max Reitzda557aa2013-12-20 19:28:11 +01001244 */
1245int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1246 QDict *options, const char *bdref_key, int flags,
Max Reitzf7d9fd82014-02-18 18:33:12 +01001247 bool allow_none, Error **errp)
Max Reitzda557aa2013-12-20 19:28:11 +01001248{
1249 QDict *image_options;
1250 int ret;
1251 char *bdref_key_dot;
1252 const char *reference;
1253
Max Reitzf67503e2014-02-18 18:33:05 +01001254 assert(pbs);
1255 assert(*pbs == NULL);
1256
Max Reitzda557aa2013-12-20 19:28:11 +01001257 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1258 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1259 g_free(bdref_key_dot);
1260
1261 reference = qdict_get_try_str(options, bdref_key);
1262 if (!filename && !reference && !qdict_size(image_options)) {
1263 if (allow_none) {
1264 ret = 0;
1265 } else {
1266 error_setg(errp, "A block device must be specified for \"%s\"",
1267 bdref_key);
1268 ret = -EINVAL;
1269 }
Markus Armbrusterb20e61e2014-05-28 11:16:57 +02001270 QDECREF(image_options);
Max Reitzda557aa2013-12-20 19:28:11 +01001271 goto done;
1272 }
1273
Max Reitzf7d9fd82014-02-18 18:33:12 +01001274 ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
Max Reitzda557aa2013-12-20 19:28:11 +01001275
1276done:
1277 qdict_del(options, bdref_key);
1278 return ret;
1279}
1280
Chen Gang6b8aeca2014-06-23 23:28:23 +08001281int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
Kevin Wolfb9988752014-04-03 12:09:34 +02001282{
1283 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001284 char *tmp_filename = g_malloc0(PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001285 int64_t total_size;
1286 BlockDriver *bdrv_qcow2;
Chunyan Liu83d05212014-06-05 17:20:51 +08001287 QemuOpts *opts = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001288 QDict *snapshot_options;
1289 BlockDriverState *bs_snapshot;
1290 Error *local_err;
1291 int ret;
1292
1293 /* if snapshot, we create a temporary backing file and open it
1294 instead of opening 'filename' directly */
1295
1296 /* Get the required size from the image */
Kevin Wolff1877432014-04-04 17:07:19 +02001297 total_size = bdrv_getlength(bs);
1298 if (total_size < 0) {
Chen Gang6b8aeca2014-06-23 23:28:23 +08001299 ret = total_size;
Kevin Wolff1877432014-04-04 17:07:19 +02001300 error_setg_errno(errp, -total_size, "Could not get image size");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001301 goto out;
Kevin Wolff1877432014-04-04 17:07:19 +02001302 }
1303 total_size &= BDRV_SECTOR_MASK;
Kevin Wolfb9988752014-04-03 12:09:34 +02001304
1305 /* Create the temporary image */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001306 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001307 if (ret < 0) {
1308 error_setg_errno(errp, -ret, "Could not get temporary filename");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001309 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001310 }
1311
1312 bdrv_qcow2 = bdrv_find_format("qcow2");
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001313 opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,
1314 &error_abort);
Chunyan Liu83d05212014-06-05 17:20:51 +08001315 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001316 ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08001317 qemu_opts_del(opts);
Kevin Wolfb9988752014-04-03 12:09:34 +02001318 if (ret < 0) {
1319 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1320 "'%s': %s", tmp_filename,
1321 error_get_pretty(local_err));
1322 error_free(local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001323 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001324 }
1325
1326 /* Prepare a new options QDict for the temporary file */
1327 snapshot_options = qdict_new();
1328 qdict_put(snapshot_options, "file.driver",
1329 qstring_from_str("file"));
1330 qdict_put(snapshot_options, "file.filename",
1331 qstring_from_str(tmp_filename));
1332
Kevin Wolf98522f62014-04-17 13:16:01 +02001333 bs_snapshot = bdrv_new("", &error_abort);
Kevin Wolfb9988752014-04-03 12:09:34 +02001334
1335 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001336 flags, bdrv_qcow2, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001337 if (ret < 0) {
1338 error_propagate(errp, local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001339 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001340 }
1341
1342 bdrv_append(bs_snapshot, bs);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001343
1344out:
1345 g_free(tmp_filename);
Chen Gang6b8aeca2014-06-23 23:28:23 +08001346 return ret;
Kevin Wolfb9988752014-04-03 12:09:34 +02001347}
1348
Max Reitzda557aa2013-12-20 19:28:11 +01001349/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001350 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001351 *
1352 * options is a QDict of options to pass to the block drivers, or NULL for an
1353 * empty set of options. The reference to the QDict belongs to the block layer
1354 * after the call (even on failure), so if the caller intends to reuse the
1355 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Max Reitzf67503e2014-02-18 18:33:05 +01001356 *
1357 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1358 * If it is not NULL, the referenced BDS will be reused.
Max Reitzddf56362014-02-18 18:33:06 +01001359 *
1360 * The reference parameter may be used to specify an existing block device which
1361 * should be opened. If specified, neither options nor a filename may be given,
1362 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001363 */
Max Reitzddf56362014-02-18 18:33:06 +01001364int bdrv_open(BlockDriverState **pbs, const char *filename,
1365 const char *reference, QDict *options, int flags,
1366 BlockDriver *drv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001367{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001368 int ret;
Max Reitzf67503e2014-02-18 18:33:05 +01001369 BlockDriverState *file = NULL, *bs;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001370 const char *drvname;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001371 Error *local_err = NULL;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001372 int snapshot_flags = 0;
bellard712e7872005-04-28 21:09:32 +00001373
Max Reitzf67503e2014-02-18 18:33:05 +01001374 assert(pbs);
1375
Max Reitzddf56362014-02-18 18:33:06 +01001376 if (reference) {
1377 bool options_non_empty = options ? qdict_size(options) : false;
1378 QDECREF(options);
1379
1380 if (*pbs) {
1381 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1382 "another block device");
1383 return -EINVAL;
1384 }
1385
1386 if (filename || options_non_empty) {
1387 error_setg(errp, "Cannot reference an existing block device with "
1388 "additional options or a new filename");
1389 return -EINVAL;
1390 }
1391
1392 bs = bdrv_lookup_bs(reference, reference, errp);
1393 if (!bs) {
1394 return -ENODEV;
1395 }
1396 bdrv_ref(bs);
1397 *pbs = bs;
1398 return 0;
1399 }
1400
Max Reitzf67503e2014-02-18 18:33:05 +01001401 if (*pbs) {
1402 bs = *pbs;
1403 } else {
Kevin Wolf98522f62014-04-17 13:16:01 +02001404 bs = bdrv_new("", &error_abort);
Max Reitzf67503e2014-02-18 18:33:05 +01001405 }
1406
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001407 /* NULL means an empty set of options */
1408 if (options == NULL) {
1409 options = qdict_new();
1410 }
1411
Kevin Wolf17b005f2014-05-27 10:50:29 +02001412 ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err);
Kevin Wolf462f5bc2014-05-26 11:39:55 +02001413 if (local_err) {
1414 goto fail;
1415 }
1416
Kevin Wolf76c591b2014-06-04 14:19:44 +02001417 /* Find the right image format driver */
1418 drv = NULL;
1419 drvname = qdict_get_try_str(options, "driver");
1420 if (drvname) {
1421 drv = bdrv_find_format(drvname);
1422 qdict_del(options, "driver");
1423 if (!drv) {
1424 error_setg(errp, "Unknown driver: '%s'", drvname);
1425 ret = -EINVAL;
1426 goto fail;
1427 }
1428 }
1429
1430 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1431 if (drv && !drv->bdrv_file_open) {
1432 /* If the user explicitly wants a format driver here, we'll need to add
1433 * another layer for the protocol in bs->file */
1434 flags &= ~BDRV_O_PROTOCOL;
1435 }
1436
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001437 bs->options = options;
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001438 options = qdict_clone_shallow(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001439
Kevin Wolff4788ad2014-06-03 16:44:19 +02001440 /* Open image file without format layer */
1441 if ((flags & BDRV_O_PROTOCOL) == 0) {
1442 if (flags & BDRV_O_RDWR) {
1443 flags |= BDRV_O_ALLOW_RDWR;
1444 }
1445 if (flags & BDRV_O_SNAPSHOT) {
1446 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1447 flags = bdrv_backing_flags(flags);
1448 }
1449
1450 assert(file == NULL);
1451 ret = bdrv_open_image(&file, filename, options, "file",
1452 bdrv_inherited_flags(flags),
1453 true, &local_err);
1454 if (ret < 0) {
Max Reitz5469a2a2014-02-18 18:33:10 +01001455 goto fail;
1456 }
1457 }
1458
Kevin Wolf76c591b2014-06-04 14:19:44 +02001459 /* Image format probing */
1460 if (!drv && file) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02001461 ret = find_image_format(file, filename, &drv, &local_err);
1462 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001463 goto fail;
Max Reitz2a05cbe2013-12-20 19:28:10 +01001464 }
Kevin Wolf76c591b2014-06-04 14:19:44 +02001465 } else if (!drv) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02001466 error_setg(errp, "Must specify either driver or file");
1467 ret = -EINVAL;
Kevin Wolf8bfea152014-04-11 19:16:36 +02001468 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001469 }
1470
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001471 /* Open the image */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001472 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001473 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001474 goto fail;
Christoph Hellwig69873072010-01-20 18:13:25 +01001475 }
1476
Max Reitz2a05cbe2013-12-20 19:28:10 +01001477 if (file && (bs->file != file)) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001478 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001479 file = NULL;
1480 }
1481
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001482 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001483 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001484 QDict *backing_options;
1485
Benoît Canet5726d872013-09-25 13:30:01 +02001486 qdict_extract_subqdict(options, &backing_options, "backing.");
Max Reitz34b5d2c2013-09-05 14:45:29 +02001487 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001488 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001489 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001490 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001491 }
1492
Kevin Wolfb9988752014-04-03 12:09:34 +02001493 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1494 * temporary snapshot afterwards. */
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001495 if (snapshot_flags) {
Chen Gang6b8aeca2014-06-23 23:28:23 +08001496 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001497 if (local_err) {
Kevin Wolfb9988752014-04-03 12:09:34 +02001498 goto close_and_fail;
1499 }
1500 }
1501
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001502 /* Check if any unknown options were used */
Max Reitz5acd9d82014-02-18 18:33:11 +01001503 if (options && (qdict_size(options) != 0)) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001504 const QDictEntry *entry = qdict_first(options);
Max Reitz5acd9d82014-02-18 18:33:11 +01001505 if (flags & BDRV_O_PROTOCOL) {
1506 error_setg(errp, "Block protocol '%s' doesn't support the option "
1507 "'%s'", drv->format_name, entry->key);
1508 } else {
1509 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1510 "support the option '%s'", drv->format_name,
1511 bs->device_name, entry->key);
1512 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001513
1514 ret = -EINVAL;
1515 goto close_and_fail;
1516 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001517
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001518 if (!bdrv_key_required(bs)) {
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001519 bdrv_dev_change_media_cb(bs, true);
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001520 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1521 && !runstate_check(RUN_STATE_INMIGRATE)
1522 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1523 error_setg(errp,
1524 "Guest must be stopped for opening of encrypted image");
1525 ret = -EBUSY;
1526 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001527 }
1528
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001529 QDECREF(options);
Max Reitzf67503e2014-02-18 18:33:05 +01001530 *pbs = bs;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001531 return 0;
1532
Kevin Wolf8bfea152014-04-11 19:16:36 +02001533fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001534 if (file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001535 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001536 }
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001537 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001538 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001539 bs->options = NULL;
Max Reitzf67503e2014-02-18 18:33:05 +01001540 if (!*pbs) {
1541 /* If *pbs is NULL, a new BDS has been created in this function and
1542 needs to be freed now. Otherwise, it does not need to be closed,
1543 since it has not really been opened yet. */
1544 bdrv_unref(bs);
1545 }
Markus Armbruster84d18f02014-01-30 15:07:28 +01001546 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001547 error_propagate(errp, local_err);
1548 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001549 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001550
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001551close_and_fail:
Max Reitzf67503e2014-02-18 18:33:05 +01001552 /* See fail path, but now the BDS has to be always closed */
1553 if (*pbs) {
1554 bdrv_close(bs);
1555 } else {
1556 bdrv_unref(bs);
1557 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001558 QDECREF(options);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001559 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001560 error_propagate(errp, local_err);
1561 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001562 return ret;
1563}
1564
Jeff Codye971aa12012-09-20 15:13:19 -04001565typedef struct BlockReopenQueueEntry {
1566 bool prepared;
1567 BDRVReopenState state;
1568 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1569} BlockReopenQueueEntry;
1570
1571/*
1572 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1573 * reopen of multiple devices.
1574 *
1575 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1576 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1577 * be created and initialized. This newly created BlockReopenQueue should be
1578 * passed back in for subsequent calls that are intended to be of the same
1579 * atomic 'set'.
1580 *
1581 * bs is the BlockDriverState to add to the reopen queue.
1582 *
1583 * flags contains the open flags for the associated bs
1584 *
1585 * returns a pointer to bs_queue, which is either the newly allocated
1586 * bs_queue, or the existing bs_queue being used.
1587 *
1588 */
1589BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1590 BlockDriverState *bs, int flags)
1591{
1592 assert(bs != NULL);
1593
1594 BlockReopenQueueEntry *bs_entry;
1595 if (bs_queue == NULL) {
1596 bs_queue = g_new0(BlockReopenQueue, 1);
1597 QSIMPLEQ_INIT(bs_queue);
1598 }
1599
Kevin Wolff1f25a22014-04-25 19:04:55 +02001600 /* bdrv_open() masks this flag out */
1601 flags &= ~BDRV_O_PROTOCOL;
1602
Jeff Codye971aa12012-09-20 15:13:19 -04001603 if (bs->file) {
Kevin Wolff1f25a22014-04-25 19:04:55 +02001604 bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
Jeff Codye971aa12012-09-20 15:13:19 -04001605 }
1606
1607 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1608 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1609
1610 bs_entry->state.bs = bs;
1611 bs_entry->state.flags = flags;
1612
1613 return bs_queue;
1614}
1615
1616/*
1617 * Reopen multiple BlockDriverStates atomically & transactionally.
1618 *
1619 * The queue passed in (bs_queue) must have been built up previous
1620 * via bdrv_reopen_queue().
1621 *
1622 * Reopens all BDS specified in the queue, with the appropriate
1623 * flags. All devices are prepared for reopen, and failure of any
1624 * device will cause all device changes to be abandonded, and intermediate
1625 * data cleaned up.
1626 *
1627 * If all devices prepare successfully, then the changes are committed
1628 * to all devices.
1629 *
1630 */
1631int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1632{
1633 int ret = -1;
1634 BlockReopenQueueEntry *bs_entry, *next;
1635 Error *local_err = NULL;
1636
1637 assert(bs_queue != NULL);
1638
1639 bdrv_drain_all();
1640
1641 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1642 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1643 error_propagate(errp, local_err);
1644 goto cleanup;
1645 }
1646 bs_entry->prepared = true;
1647 }
1648
1649 /* If we reach this point, we have success and just need to apply the
1650 * changes
1651 */
1652 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1653 bdrv_reopen_commit(&bs_entry->state);
1654 }
1655
1656 ret = 0;
1657
1658cleanup:
1659 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1660 if (ret && bs_entry->prepared) {
1661 bdrv_reopen_abort(&bs_entry->state);
1662 }
1663 g_free(bs_entry);
1664 }
1665 g_free(bs_queue);
1666 return ret;
1667}
1668
1669
1670/* Reopen a single BlockDriverState with the specified flags. */
1671int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1672{
1673 int ret = -1;
1674 Error *local_err = NULL;
1675 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1676
1677 ret = bdrv_reopen_multiple(queue, &local_err);
1678 if (local_err != NULL) {
1679 error_propagate(errp, local_err);
1680 }
1681 return ret;
1682}
1683
1684
1685/*
1686 * Prepares a BlockDriverState for reopen. All changes are staged in the
1687 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1688 * the block driver layer .bdrv_reopen_prepare()
1689 *
1690 * bs is the BlockDriverState to reopen
1691 * flags are the new open flags
1692 * queue is the reopen queue
1693 *
1694 * Returns 0 on success, non-zero on error. On error errp will be set
1695 * as well.
1696 *
1697 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1698 * It is the responsibility of the caller to then call the abort() or
1699 * commit() for any other BDS that have been left in a prepare() state
1700 *
1701 */
1702int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1703 Error **errp)
1704{
1705 int ret = -1;
1706 Error *local_err = NULL;
1707 BlockDriver *drv;
1708
1709 assert(reopen_state != NULL);
1710 assert(reopen_state->bs->drv != NULL);
1711 drv = reopen_state->bs->drv;
1712
1713 /* if we are to stay read-only, do not allow permission change
1714 * to r/w */
1715 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1716 reopen_state->flags & BDRV_O_RDWR) {
1717 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1718 reopen_state->bs->device_name);
1719 goto error;
1720 }
1721
1722
1723 ret = bdrv_flush(reopen_state->bs);
1724 if (ret) {
1725 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1726 strerror(-ret));
1727 goto error;
1728 }
1729
1730 if (drv->bdrv_reopen_prepare) {
1731 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1732 if (ret) {
1733 if (local_err != NULL) {
1734 error_propagate(errp, local_err);
1735 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04001736 error_setg(errp, "failed while preparing to reopen image '%s'",
1737 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04001738 }
1739 goto error;
1740 }
1741 } else {
1742 /* It is currently mandatory to have a bdrv_reopen_prepare()
1743 * handler for each supported drv. */
1744 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1745 drv->format_name, reopen_state->bs->device_name,
1746 "reopening of file");
1747 ret = -1;
1748 goto error;
1749 }
1750
1751 ret = 0;
1752
1753error:
1754 return ret;
1755}
1756
1757/*
1758 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1759 * makes them final by swapping the staging BlockDriverState contents into
1760 * the active BlockDriverState contents.
1761 */
1762void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1763{
1764 BlockDriver *drv;
1765
1766 assert(reopen_state != NULL);
1767 drv = reopen_state->bs->drv;
1768 assert(drv != NULL);
1769
1770 /* If there are any driver level actions to take */
1771 if (drv->bdrv_reopen_commit) {
1772 drv->bdrv_reopen_commit(reopen_state);
1773 }
1774
1775 /* set BDS specific flags now */
1776 reopen_state->bs->open_flags = reopen_state->flags;
1777 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1778 BDRV_O_CACHE_WB);
1779 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf355ef4a2013-12-11 20:14:09 +01001780
1781 bdrv_refresh_limits(reopen_state->bs);
Jeff Codye971aa12012-09-20 15:13:19 -04001782}
1783
1784/*
1785 * Abort the reopen, and delete and free the staged changes in
1786 * reopen_state
1787 */
1788void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1789{
1790 BlockDriver *drv;
1791
1792 assert(reopen_state != NULL);
1793 drv = reopen_state->bs->drv;
1794 assert(drv != NULL);
1795
1796 if (drv->bdrv_reopen_abort) {
1797 drv->bdrv_reopen_abort(reopen_state);
1798 }
1799}
1800
1801
bellardfc01f7e2003-06-30 10:03:06 +00001802void bdrv_close(BlockDriverState *bs)
1803{
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001804 if (bs->job) {
1805 block_job_cancel_sync(bs->job);
1806 }
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02001807 bdrv_drain_all(); /* complete I/O */
1808 bdrv_flush(bs);
1809 bdrv_drain_all(); /* in case flush left pending I/O */
Paolo Bonzinid7d512f2012-08-23 11:20:36 +02001810 notifier_list_notify(&bs->close_notifiers, bs);
Kevin Wolf7094f122012-04-11 11:06:37 +02001811
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001812 if (bs->drv) {
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001813 if (bs->backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001814 BlockDriverState *backing_hd = bs->backing_hd;
1815 bdrv_set_backing_hd(bs, NULL);
1816 bdrv_unref(backing_hd);
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001817 }
bellardea2384d2004-08-01 21:59:26 +00001818 bs->drv->bdrv_close(bs);
Anthony Liguori7267c092011-08-20 22:09:37 -05001819 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00001820 bs->opaque = NULL;
1821 bs->drv = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001822 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02001823 bs->backing_file[0] = '\0';
1824 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02001825 bs->total_sectors = 0;
1826 bs->encrypted = 0;
1827 bs->valid_key = 0;
1828 bs->sg = 0;
1829 bs->growable = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08001830 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001831 QDECREF(bs->options);
1832 bs->options = NULL;
bellardb3380822004-03-14 21:38:54 +00001833
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001834 if (bs->file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001835 bdrv_unref(bs->file);
Paolo Bonzini0ac93772012-05-08 16:51:44 +02001836 bs->file = NULL;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001837 }
bellardb3380822004-03-14 21:38:54 +00001838 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001839
Pavel Hrdina9ca11152012-08-09 12:44:48 +02001840 bdrv_dev_change_media_cb(bs, false);
1841
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001842 /*throttling disk I/O limits*/
1843 if (bs->io_limits_enabled) {
1844 bdrv_io_limits_disable(bs);
1845 }
bellardb3380822004-03-14 21:38:54 +00001846}
1847
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001848void bdrv_close_all(void)
1849{
1850 BlockDriverState *bs;
1851
Benoît Canetdc364f42014-01-23 21:31:32 +01001852 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02001853 AioContext *aio_context = bdrv_get_aio_context(bs);
1854
1855 aio_context_acquire(aio_context);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001856 bdrv_close(bs);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02001857 aio_context_release(aio_context);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001858 }
1859}
1860
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001861/* Check if any requests are in-flight (including throttled requests) */
1862static bool bdrv_requests_pending(BlockDriverState *bs)
1863{
1864 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1865 return true;
1866 }
Benoît Canetcc0681c2013-09-02 14:14:39 +02001867 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1868 return true;
1869 }
1870 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001871 return true;
1872 }
1873 if (bs->file && bdrv_requests_pending(bs->file)) {
1874 return true;
1875 }
1876 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1877 return true;
1878 }
1879 return false;
1880}
1881
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001882/*
1883 * Wait for pending requests to complete across all BlockDriverStates
1884 *
1885 * This function does not flush data to disk, use bdrv_flush_all() for that
1886 * after calling this function.
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001887 *
1888 * Note that completion of an asynchronous I/O operation can trigger any
1889 * number of other I/O operations on other devices---for example a coroutine
1890 * can be arbitrarily complex and a constant flow of I/O can come until the
1891 * coroutine is complete. Because of this, it is not possible to have a
1892 * function to drain a single device's I/O queue.
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001893 */
1894void bdrv_drain_all(void)
1895{
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001896 /* Always run first iteration so any pending completion BHs run */
1897 bool busy = true;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001898 BlockDriverState *bs;
1899
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001900 while (busy) {
Stefan Hajnoczi9b536ad2014-05-08 16:34:36 +02001901 busy = false;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001902
Stefan Hajnoczi9b536ad2014-05-08 16:34:36 +02001903 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1904 AioContext *aio_context = bdrv_get_aio_context(bs);
1905 bool bs_busy;
1906
1907 aio_context_acquire(aio_context);
1908 bdrv_start_throttled_reqs(bs);
1909 bs_busy = bdrv_requests_pending(bs);
1910 bs_busy |= aio_poll(aio_context, bs_busy);
1911 aio_context_release(aio_context);
1912
1913 busy |= bs_busy;
1914 }
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001915 }
1916}
1917
Benoît Canetdc364f42014-01-23 21:31:32 +01001918/* make a BlockDriverState anonymous by removing from bdrv_state and
1919 * graph_bdrv_state list.
Ryan Harperd22b2f42011-03-29 20:51:47 -05001920 Also, NULL terminate the device_name to prevent double remove */
1921void bdrv_make_anon(BlockDriverState *bs)
1922{
1923 if (bs->device_name[0] != '\0') {
Benoît Canetdc364f42014-01-23 21:31:32 +01001924 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
Ryan Harperd22b2f42011-03-29 20:51:47 -05001925 }
1926 bs->device_name[0] = '\0';
Benoît Canetdc364f42014-01-23 21:31:32 +01001927 if (bs->node_name[0] != '\0') {
1928 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1929 }
1930 bs->node_name[0] = '\0';
Ryan Harperd22b2f42011-03-29 20:51:47 -05001931}
1932
Paolo Bonzinie023b2e2012-05-08 16:51:41 +02001933static void bdrv_rebind(BlockDriverState *bs)
1934{
1935 if (bs->drv && bs->drv->bdrv_rebind) {
1936 bs->drv->bdrv_rebind(bs);
1937 }
1938}
1939
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001940static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1941 BlockDriverState *bs_src)
1942{
1943 /* move some fields that need to stay attached to the device */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001944
1945 /* dev info */
1946 bs_dest->dev_ops = bs_src->dev_ops;
1947 bs_dest->dev_opaque = bs_src->dev_opaque;
1948 bs_dest->dev = bs_src->dev;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01001949 bs_dest->guest_block_size = bs_src->guest_block_size;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001950 bs_dest->copy_on_read = bs_src->copy_on_read;
1951
1952 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1953
Benoît Canetcc0681c2013-09-02 14:14:39 +02001954 /* i/o throttled req */
1955 memcpy(&bs_dest->throttle_state,
1956 &bs_src->throttle_state,
1957 sizeof(ThrottleState));
1958 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1959 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001960 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1961
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001962 /* r/w error */
1963 bs_dest->on_read_error = bs_src->on_read_error;
1964 bs_dest->on_write_error = bs_src->on_write_error;
1965
1966 /* i/o status */
1967 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1968 bs_dest->iostatus = bs_src->iostatus;
1969
1970 /* dirty bitmap */
Fam Zhenge4654d22013-11-13 18:29:43 +08001971 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001972
Fam Zheng9fcb0252013-08-23 09:14:46 +08001973 /* reference count */
1974 bs_dest->refcnt = bs_src->refcnt;
1975
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001976 /* job */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001977 bs_dest->job = bs_src->job;
1978
1979 /* keep the same entry in bdrv_states */
1980 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1981 bs_src->device_name);
Benoît Canetdc364f42014-01-23 21:31:32 +01001982 bs_dest->device_list = bs_src->device_list;
Fam Zhengfbe40ff2014-05-23 21:29:42 +08001983 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
1984 sizeof(bs_dest->op_blockers));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001985}
1986
1987/*
1988 * Swap bs contents for two image chains while they are live,
1989 * while keeping required fields on the BlockDriverState that is
1990 * actually attached to a device.
1991 *
1992 * This will modify the BlockDriverState fields, and swap contents
1993 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1994 *
1995 * bs_new is required to be anonymous.
1996 *
1997 * This function does not create any image files.
1998 */
1999void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2000{
2001 BlockDriverState tmp;
2002
Benoît Canet90ce8a02014-03-05 23:48:29 +01002003 /* The code needs to swap the node_name but simply swapping node_list won't
2004 * work so first remove the nodes from the graph list, do the swap then
2005 * insert them back if needed.
2006 */
2007 if (bs_new->node_name[0] != '\0') {
2008 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2009 }
2010 if (bs_old->node_name[0] != '\0') {
2011 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2012 }
2013
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002014 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2015 assert(bs_new->device_name[0] == '\0');
Fam Zhenge4654d22013-11-13 18:29:43 +08002016 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002017 assert(bs_new->job == NULL);
2018 assert(bs_new->dev == NULL);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002019 assert(bs_new->io_limits_enabled == false);
Benoît Canetcc0681c2013-09-02 14:14:39 +02002020 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002021
2022 tmp = *bs_new;
2023 *bs_new = *bs_old;
2024 *bs_old = tmp;
2025
2026 /* there are some fields that should not be swapped, move them back */
2027 bdrv_move_feature_fields(&tmp, bs_old);
2028 bdrv_move_feature_fields(bs_old, bs_new);
2029 bdrv_move_feature_fields(bs_new, &tmp);
2030
2031 /* bs_new shouldn't be in bdrv_states even after the swap! */
2032 assert(bs_new->device_name[0] == '\0');
2033
2034 /* Check a few fields that should remain attached to the device */
2035 assert(bs_new->dev == NULL);
2036 assert(bs_new->job == NULL);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002037 assert(bs_new->io_limits_enabled == false);
Benoît Canetcc0681c2013-09-02 14:14:39 +02002038 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002039
Benoît Canet90ce8a02014-03-05 23:48:29 +01002040 /* insert the nodes back into the graph node list if needed */
2041 if (bs_new->node_name[0] != '\0') {
2042 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2043 }
2044 if (bs_old->node_name[0] != '\0') {
2045 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2046 }
2047
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002048 bdrv_rebind(bs_new);
2049 bdrv_rebind(bs_old);
2050}
2051
Jeff Cody8802d1f2012-02-28 15:54:06 -05002052/*
2053 * Add new bs contents at the top of an image chain while the chain is
2054 * live, while keeping required fields on the top layer.
2055 *
2056 * This will modify the BlockDriverState fields, and swap contents
2057 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2058 *
Jeff Codyf6801b82012-03-27 16:30:19 -04002059 * bs_new is required to be anonymous.
2060 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05002061 * This function does not create any image files.
2062 */
2063void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2064{
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002065 bdrv_swap(bs_new, bs_top);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002066
2067 /* The contents of 'tmp' will become bs_top, as we are
2068 * swapping bs_new and bs_top contents. */
Fam Zheng8d24cce2014-05-23 21:29:45 +08002069 bdrv_set_backing_hd(bs_top, bs_new);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002070}
2071
Fam Zheng4f6fd342013-08-23 09:14:47 +08002072static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00002073{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002074 assert(!bs->dev);
Paolo Bonzini3e914652012-03-30 13:17:11 +02002075 assert(!bs->job);
Fam Zheng3718d8a2014-05-23 21:29:43 +08002076 assert(bdrv_op_blocker_is_empty(bs));
Fam Zheng4f6fd342013-08-23 09:14:47 +08002077 assert(!bs->refcnt);
Fam Zhenge4654d22013-11-13 18:29:43 +08002078 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Markus Armbruster18846de2010-06-29 16:58:30 +02002079
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02002080 bdrv_close(bs);
2081
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002082 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05002083 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00002084
Anthony Liguori7267c092011-08-20 22:09:37 -05002085 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00002086}
2087
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002088int bdrv_attach_dev(BlockDriverState *bs, void *dev)
2089/* TODO change to DeviceState *dev when all users are qdevified */
Markus Armbruster18846de2010-06-29 16:58:30 +02002090{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002091 if (bs->dev) {
Markus Armbruster18846de2010-06-29 16:58:30 +02002092 return -EBUSY;
2093 }
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002094 bs->dev = dev;
Luiz Capitulino28a72822011-09-26 17:43:50 -03002095 bdrv_iostatus_reset(bs);
Markus Armbruster18846de2010-06-29 16:58:30 +02002096 return 0;
2097}
2098
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002099/* TODO qdevified devices don't use this, remove when devices are qdevified */
2100void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
Markus Armbruster18846de2010-06-29 16:58:30 +02002101{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002102 if (bdrv_attach_dev(bs, dev) < 0) {
2103 abort();
2104 }
2105}
2106
2107void bdrv_detach_dev(BlockDriverState *bs, void *dev)
2108/* TODO change to DeviceState *dev when all users are qdevified */
2109{
2110 assert(bs->dev == dev);
2111 bs->dev = NULL;
Markus Armbruster0e49de52011-08-03 15:07:41 +02002112 bs->dev_ops = NULL;
2113 bs->dev_opaque = NULL;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01002114 bs->guest_block_size = 512;
Markus Armbruster18846de2010-06-29 16:58:30 +02002115}
2116
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002117/* TODO change to return DeviceState * when all users are qdevified */
2118void *bdrv_get_attached_dev(BlockDriverState *bs)
Markus Armbruster18846de2010-06-29 16:58:30 +02002119{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002120 return bs->dev;
Markus Armbruster18846de2010-06-29 16:58:30 +02002121}
2122
Markus Armbruster0e49de52011-08-03 15:07:41 +02002123void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
2124 void *opaque)
2125{
2126 bs->dev_ops = ops;
2127 bs->dev_opaque = opaque;
2128}
2129
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002130static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
Markus Armbruster0e49de52011-08-03 15:07:41 +02002131{
Markus Armbruster145feb12011-08-03 15:07:42 +02002132 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002133 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002134 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002135 if (tray_was_closed) {
2136 /* tray open */
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +02002137 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2138 true, &error_abort);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002139 }
2140 if (load) {
2141 /* tray close */
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +02002142 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2143 false, &error_abort);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002144 }
Markus Armbruster145feb12011-08-03 15:07:42 +02002145 }
2146}
2147
Markus Armbruster2c6942f2011-09-06 18:58:51 +02002148bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2149{
2150 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2151}
2152
Paolo Bonzini025ccaa2011-11-07 17:50:13 +01002153void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2154{
2155 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2156 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2157 }
2158}
2159
Markus Armbrustere4def802011-09-06 18:58:53 +02002160bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2161{
2162 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2163 return bs->dev_ops->is_tray_open(bs->dev_opaque);
2164 }
2165 return false;
2166}
2167
Markus Armbruster145feb12011-08-03 15:07:42 +02002168static void bdrv_dev_resize_cb(BlockDriverState *bs)
2169{
2170 if (bs->dev_ops && bs->dev_ops->resize_cb) {
2171 bs->dev_ops->resize_cb(bs->dev_opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +02002172 }
2173}
2174
Markus Armbrusterf1076392011-09-06 18:58:46 +02002175bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2176{
2177 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2178 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2179 }
2180 return false;
2181}
2182
aliguorie97fc192009-04-21 23:11:50 +00002183/*
2184 * Run consistency checks on an image
2185 *
Kevin Wolfe076f332010-06-29 11:43:13 +02002186 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02002187 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02002188 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00002189 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02002190int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00002191{
2192 if (bs->drv->bdrv_check == NULL) {
2193 return -ENOTSUP;
2194 }
2195
Kevin Wolfe076f332010-06-29 11:43:13 +02002196 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02002197 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00002198}
2199
Kevin Wolf8a426612010-07-16 17:17:01 +02002200#define COMMIT_BUF_SECTORS 2048
2201
bellard33e39632003-07-06 17:15:21 +00002202/* commit COW file into the raw image */
2203int bdrv_commit(BlockDriverState *bs)
2204{
bellard19cb3732006-08-19 11:45:59 +00002205 BlockDriver *drv = bs->drv;
Jeff Cody72706ea2014-01-24 09:02:35 -05002206 int64_t sector, total_sectors, length, backing_length;
Kevin Wolf8a426612010-07-16 17:17:01 +02002207 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04002208 int ret = 0;
Jeff Cody72706ea2014-01-24 09:02:35 -05002209 uint8_t *buf = NULL;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02002210 char filename[PATH_MAX];
bellard33e39632003-07-06 17:15:21 +00002211
bellard19cb3732006-08-19 11:45:59 +00002212 if (!drv)
2213 return -ENOMEDIUM;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002214
2215 if (!bs->backing_hd) {
2216 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00002217 }
2218
Fam Zheng3718d8a2014-05-23 21:29:43 +08002219 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2220 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00002221 return -EBUSY;
2222 }
2223
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002224 ro = bs->backing_hd->read_only;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02002225 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2226 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002227 open_flags = bs->backing_hd->open_flags;
2228
2229 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002230 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2231 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002232 }
bellard33e39632003-07-06 17:15:21 +00002233 }
bellardea2384d2004-08-01 21:59:26 +00002234
Jeff Cody72706ea2014-01-24 09:02:35 -05002235 length = bdrv_getlength(bs);
2236 if (length < 0) {
2237 ret = length;
2238 goto ro_cleanup;
2239 }
2240
2241 backing_length = bdrv_getlength(bs->backing_hd);
2242 if (backing_length < 0) {
2243 ret = backing_length;
2244 goto ro_cleanup;
2245 }
2246
2247 /* If our top snapshot is larger than the backing file image,
2248 * grow the backing file image if possible. If not possible,
2249 * we must return an error */
2250 if (length > backing_length) {
2251 ret = bdrv_truncate(bs->backing_hd, length);
2252 if (ret < 0) {
2253 goto ro_cleanup;
2254 }
2255 }
2256
2257 total_sectors = length >> BDRV_SECTOR_BITS;
Anthony Liguori7267c092011-08-20 22:09:37 -05002258 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
bellardea2384d2004-08-01 21:59:26 +00002259
Kevin Wolf8a426612010-07-16 17:17:01 +02002260 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02002261 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2262 if (ret < 0) {
2263 goto ro_cleanup;
2264 }
2265 if (ret) {
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002266 ret = bdrv_read(bs, sector, buf, n);
2267 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002268 goto ro_cleanup;
2269 }
2270
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002271 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2272 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002273 goto ro_cleanup;
2274 }
bellardea2384d2004-08-01 21:59:26 +00002275 }
2276 }
bellard95389c82005-12-18 18:28:15 +00002277
Christoph Hellwig1d449522010-01-17 12:32:30 +01002278 if (drv->bdrv_make_empty) {
2279 ret = drv->bdrv_make_empty(bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002280 if (ret < 0) {
2281 goto ro_cleanup;
2282 }
Christoph Hellwig1d449522010-01-17 12:32:30 +01002283 bdrv_flush(bs);
2284 }
bellard95389c82005-12-18 18:28:15 +00002285
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002286 /*
2287 * Make sure all data we wrote to the backing device is actually
2288 * stable on disk.
2289 */
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002290 if (bs->backing_hd) {
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002291 bdrv_flush(bs->backing_hd);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002292 }
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002293
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002294 ret = 0;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002295ro_cleanup:
Anthony Liguori7267c092011-08-20 22:09:37 -05002296 g_free(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002297
2298 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002299 /* ignoring error return here */
2300 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002301 }
2302
Christoph Hellwig1d449522010-01-17 12:32:30 +01002303 return ret;
bellard33e39632003-07-06 17:15:21 +00002304}
2305
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002306int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002307{
2308 BlockDriverState *bs;
2309
Benoît Canetdc364f42014-01-23 21:31:32 +01002310 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002311 AioContext *aio_context = bdrv_get_aio_context(bs);
2312
2313 aio_context_acquire(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002314 if (bs->drv && bs->backing_hd) {
2315 int ret = bdrv_commit(bs);
2316 if (ret < 0) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002317 aio_context_release(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002318 return ret;
2319 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002320 }
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002321 aio_context_release(aio_context);
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002322 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002323 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002324}
2325
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002326/**
2327 * Remove an active request from the tracked requests list
2328 *
2329 * This function should be called when a tracked request is completing.
2330 */
2331static void tracked_request_end(BdrvTrackedRequest *req)
2332{
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002333 if (req->serialising) {
2334 req->bs->serialising_in_flight--;
2335 }
2336
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002337 QLIST_REMOVE(req, list);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002338 qemu_co_queue_restart_all(&req->wait_queue);
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002339}
2340
2341/**
2342 * Add an active request to the tracked requests list
2343 */
2344static void tracked_request_begin(BdrvTrackedRequest *req,
2345 BlockDriverState *bs,
Kevin Wolf793ed472013-12-03 15:31:25 +01002346 int64_t offset,
2347 unsigned int bytes, bool is_write)
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002348{
2349 *req = (BdrvTrackedRequest){
2350 .bs = bs,
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002351 .offset = offset,
2352 .bytes = bytes,
2353 .is_write = is_write,
2354 .co = qemu_coroutine_self(),
2355 .serialising = false,
Kevin Wolf73271452013-12-04 17:08:50 +01002356 .overlap_offset = offset,
2357 .overlap_bytes = bytes,
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002358 };
2359
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002360 qemu_co_queue_init(&req->wait_queue);
2361
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002362 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2363}
2364
Kevin Wolfe96126f2014-02-08 10:42:18 +01002365static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002366{
Kevin Wolf73271452013-12-04 17:08:50 +01002367 int64_t overlap_offset = req->offset & ~(align - 1);
Kevin Wolfe96126f2014-02-08 10:42:18 +01002368 unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2369 - overlap_offset;
Kevin Wolf73271452013-12-04 17:08:50 +01002370
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002371 if (!req->serialising) {
2372 req->bs->serialising_in_flight++;
2373 req->serialising = true;
2374 }
Kevin Wolf73271452013-12-04 17:08:50 +01002375
2376 req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2377 req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002378}
2379
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002380/**
2381 * Round a region to cluster boundaries
2382 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002383void bdrv_round_to_clusters(BlockDriverState *bs,
2384 int64_t sector_num, int nb_sectors,
2385 int64_t *cluster_sector_num,
2386 int *cluster_nb_sectors)
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002387{
2388 BlockDriverInfo bdi;
2389
2390 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2391 *cluster_sector_num = sector_num;
2392 *cluster_nb_sectors = nb_sectors;
2393 } else {
2394 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2395 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2396 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2397 nb_sectors, c);
2398 }
2399}
2400
Kevin Wolf73271452013-12-04 17:08:50 +01002401static int bdrv_get_cluster_size(BlockDriverState *bs)
Kevin Wolf793ed472013-12-03 15:31:25 +01002402{
2403 BlockDriverInfo bdi;
Kevin Wolf73271452013-12-04 17:08:50 +01002404 int ret;
Kevin Wolf793ed472013-12-03 15:31:25 +01002405
Kevin Wolf73271452013-12-04 17:08:50 +01002406 ret = bdrv_get_info(bs, &bdi);
2407 if (ret < 0 || bdi.cluster_size == 0) {
2408 return bs->request_alignment;
Kevin Wolf793ed472013-12-03 15:31:25 +01002409 } else {
Kevin Wolf73271452013-12-04 17:08:50 +01002410 return bdi.cluster_size;
Kevin Wolf793ed472013-12-03 15:31:25 +01002411 }
2412}
2413
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002414static bool tracked_request_overlaps(BdrvTrackedRequest *req,
Kevin Wolf793ed472013-12-03 15:31:25 +01002415 int64_t offset, unsigned int bytes)
2416{
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002417 /* aaaa bbbb */
Kevin Wolf73271452013-12-04 17:08:50 +01002418 if (offset >= req->overlap_offset + req->overlap_bytes) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002419 return false;
2420 }
2421 /* bbbb aaaa */
Kevin Wolf73271452013-12-04 17:08:50 +01002422 if (req->overlap_offset >= offset + bytes) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002423 return false;
2424 }
2425 return true;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002426}
2427
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002428static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002429{
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002430 BlockDriverState *bs = self->bs;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002431 BdrvTrackedRequest *req;
2432 bool retry;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002433 bool waited = false;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002434
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002435 if (!bs->serialising_in_flight) {
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002436 return false;
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002437 }
2438
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002439 do {
2440 retry = false;
2441 QLIST_FOREACH(req, &bs->tracked_requests, list) {
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002442 if (req == self || (!req->serialising && !self->serialising)) {
Kevin Wolf65afd212013-12-03 14:55:55 +01002443 continue;
2444 }
Kevin Wolf73271452013-12-04 17:08:50 +01002445 if (tracked_request_overlaps(req, self->overlap_offset,
2446 self->overlap_bytes))
2447 {
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00002448 /* Hitting this means there was a reentrant request, for
2449 * example, a block driver issuing nested requests. This must
2450 * never happen since it means deadlock.
2451 */
2452 assert(qemu_coroutine_self() != req->co);
2453
Kevin Wolf64604402013-12-13 13:04:35 +01002454 /* If the request is already (indirectly) waiting for us, or
2455 * will wait for us as soon as it wakes up, then just go on
2456 * (instead of producing a deadlock in the former case). */
2457 if (!req->waiting_for) {
2458 self->waiting_for = req;
2459 qemu_co_queue_wait(&req->wait_queue);
2460 self->waiting_for = NULL;
2461 retry = true;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002462 waited = true;
Kevin Wolf64604402013-12-13 13:04:35 +01002463 break;
2464 }
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002465 }
2466 }
2467 } while (retry);
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002468
2469 return waited;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002470}
2471
Kevin Wolf756e6732010-01-12 12:55:17 +01002472/*
2473 * Return values:
2474 * 0 - success
2475 * -EINVAL - backing format specified, but no file
2476 * -ENOSPC - can't update the backing file because no space is left in the
2477 * image file header
2478 * -ENOTSUP - format driver doesn't support changing the backing file
2479 */
2480int bdrv_change_backing_file(BlockDriverState *bs,
2481 const char *backing_file, const char *backing_fmt)
2482{
2483 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002484 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002485
Paolo Bonzini5f377792012-04-12 14:01:01 +02002486 /* Backing file format doesn't make sense without a backing file */
2487 if (backing_fmt && !backing_file) {
2488 return -EINVAL;
2489 }
2490
Kevin Wolf756e6732010-01-12 12:55:17 +01002491 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002492 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002493 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002494 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002495 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002496
2497 if (ret == 0) {
2498 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2499 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2500 }
2501 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002502}
2503
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002504/*
2505 * Finds the image layer in the chain that has 'bs' as its backing file.
2506 *
2507 * active is the current topmost image.
2508 *
2509 * Returns NULL if bs is not found in active's image chain,
2510 * or if active == bs.
2511 */
2512BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2513 BlockDriverState *bs)
2514{
2515 BlockDriverState *overlay = NULL;
2516 BlockDriverState *intermediate;
2517
2518 assert(active != NULL);
2519 assert(bs != NULL);
2520
2521 /* if bs is the same as active, then by definition it has no overlay
2522 */
2523 if (active == bs) {
2524 return NULL;
2525 }
2526
2527 intermediate = active;
2528 while (intermediate->backing_hd) {
2529 if (intermediate->backing_hd == bs) {
2530 overlay = intermediate;
2531 break;
2532 }
2533 intermediate = intermediate->backing_hd;
2534 }
2535
2536 return overlay;
2537}
2538
2539typedef struct BlkIntermediateStates {
2540 BlockDriverState *bs;
2541 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2542} BlkIntermediateStates;
2543
2544
2545/*
2546 * Drops images above 'base' up to and including 'top', and sets the image
2547 * above 'top' to have base as its backing file.
2548 *
2549 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2550 * information in 'bs' can be properly updated.
2551 *
2552 * E.g., this will convert the following chain:
2553 * bottom <- base <- intermediate <- top <- active
2554 *
2555 * to
2556 *
2557 * bottom <- base <- active
2558 *
2559 * It is allowed for bottom==base, in which case it converts:
2560 *
2561 * base <- intermediate <- top <- active
2562 *
2563 * to
2564 *
2565 * base <- active
2566 *
2567 * Error conditions:
2568 * if active == top, that is considered an error
2569 *
2570 */
2571int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2572 BlockDriverState *base)
2573{
2574 BlockDriverState *intermediate;
2575 BlockDriverState *base_bs = NULL;
2576 BlockDriverState *new_top_bs = NULL;
2577 BlkIntermediateStates *intermediate_state, *next;
2578 int ret = -EIO;
2579
2580 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2581 QSIMPLEQ_INIT(&states_to_delete);
2582
2583 if (!top->drv || !base->drv) {
2584 goto exit;
2585 }
2586
2587 new_top_bs = bdrv_find_overlay(active, top);
2588
2589 if (new_top_bs == NULL) {
2590 /* we could not find the image above 'top', this is an error */
2591 goto exit;
2592 }
2593
2594 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2595 * to do, no intermediate images */
2596 if (new_top_bs->backing_hd == base) {
2597 ret = 0;
2598 goto exit;
2599 }
2600
2601 intermediate = top;
2602
2603 /* now we will go down through the list, and add each BDS we find
2604 * into our deletion queue, until we hit the 'base'
2605 */
2606 while (intermediate) {
2607 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2608 intermediate_state->bs = intermediate;
2609 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2610
2611 if (intermediate->backing_hd == base) {
2612 base_bs = intermediate->backing_hd;
2613 break;
2614 }
2615 intermediate = intermediate->backing_hd;
2616 }
2617 if (base_bs == NULL) {
2618 /* something went wrong, we did not end at the base. safely
2619 * unravel everything, and exit with error */
2620 goto exit;
2621 }
2622
2623 /* success - we can delete the intermediate states, and link top->base */
2624 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2625 base_bs->drv ? base_bs->drv->format_name : "");
2626 if (ret) {
2627 goto exit;
2628 }
Fam Zheng920beae2014-05-23 21:29:46 +08002629 bdrv_set_backing_hd(new_top_bs, base_bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002630
2631 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2632 /* so that bdrv_close() does not recursively close the chain */
Fam Zheng920beae2014-05-23 21:29:46 +08002633 bdrv_set_backing_hd(intermediate_state->bs, NULL);
Fam Zheng4f6fd342013-08-23 09:14:47 +08002634 bdrv_unref(intermediate_state->bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002635 }
2636 ret = 0;
2637
2638exit:
2639 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2640 g_free(intermediate_state);
2641 }
2642 return ret;
2643}
2644
2645
aliguori71d07702009-03-03 17:37:16 +00002646static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2647 size_t size)
2648{
2649 int64_t len;
2650
Kevin Wolf1dd3a442014-04-14 14:48:16 +02002651 if (size > INT_MAX) {
2652 return -EIO;
2653 }
2654
aliguori71d07702009-03-03 17:37:16 +00002655 if (!bdrv_is_inserted(bs))
2656 return -ENOMEDIUM;
2657
2658 if (bs->growable)
2659 return 0;
2660
2661 len = bdrv_getlength(bs);
2662
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02002663 if (offset < 0)
2664 return -EIO;
2665
2666 if ((offset > len) || (len - offset < size))
aliguori71d07702009-03-03 17:37:16 +00002667 return -EIO;
2668
2669 return 0;
2670}
2671
2672static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2673 int nb_sectors)
2674{
Kevin Wolf54db38a2014-04-14 14:47:14 +02002675 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
Kevin Wolf8f4754e2014-03-26 13:06:02 +01002676 return -EIO;
2677 }
2678
Jes Sorenseneb5a3162010-05-27 16:20:31 +02002679 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2680 nb_sectors * BDRV_SECTOR_SIZE);
aliguori71d07702009-03-03 17:37:16 +00002681}
2682
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002683typedef struct RwCo {
2684 BlockDriverState *bs;
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002685 int64_t offset;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002686 QEMUIOVector *qiov;
2687 bool is_write;
2688 int ret;
Peter Lieven4105eaa2013-07-11 14:16:22 +02002689 BdrvRequestFlags flags;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002690} RwCo;
2691
2692static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2693{
2694 RwCo *rwco = opaque;
2695
2696 if (!rwco->is_write) {
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002697 rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2698 rwco->qiov->size, rwco->qiov,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002699 rwco->flags);
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002700 } else {
2701 rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2702 rwco->qiov->size, rwco->qiov,
2703 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002704 }
2705}
2706
2707/*
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002708 * Process a vectored synchronous request using coroutines
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002709 */
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002710static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2711 QEMUIOVector *qiov, bool is_write,
2712 BdrvRequestFlags flags)
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002713{
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002714 Coroutine *co;
2715 RwCo rwco = {
2716 .bs = bs,
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002717 .offset = offset,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002718 .qiov = qiov,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002719 .is_write = is_write,
2720 .ret = NOT_DONE,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002721 .flags = flags,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002722 };
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002723
Zhi Yong Wu498e3862012-04-02 18:59:34 +08002724 /**
2725 * In sync call context, when the vcpu is blocked, this throttling timer
2726 * will not fire; so the I/O throttling function has to be disabled here
2727 * if it has been enabled.
2728 */
2729 if (bs->io_limits_enabled) {
2730 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2731 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2732 bdrv_io_limits_disable(bs);
2733 }
2734
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002735 if (qemu_in_coroutine()) {
2736 /* Fast-path if already in coroutine context */
2737 bdrv_rw_co_entry(&rwco);
2738 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02002739 AioContext *aio_context = bdrv_get_aio_context(bs);
2740
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002741 co = qemu_coroutine_create(bdrv_rw_co_entry);
2742 qemu_coroutine_enter(co, &rwco);
2743 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02002744 aio_poll(aio_context, true);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002745 }
2746 }
2747 return rwco.ret;
2748}
2749
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002750/*
2751 * Process a synchronous request using coroutines
2752 */
2753static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002754 int nb_sectors, bool is_write, BdrvRequestFlags flags)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002755{
2756 QEMUIOVector qiov;
2757 struct iovec iov = {
2758 .iov_base = (void *)buf,
2759 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2760 };
2761
Kevin Wolfda15ee52014-04-14 15:39:36 +02002762 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2763 return -EINVAL;
2764 }
2765
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002766 qemu_iovec_init_external(&qiov, &iov, 1);
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002767 return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2768 &qiov, is_write, flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002769}
2770
bellard19cb3732006-08-19 11:45:59 +00002771/* return < 0 if error. See bdrv_write() for the return codes */
ths5fafdf22007-09-16 21:08:06 +00002772int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002773 uint8_t *buf, int nb_sectors)
2774{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002775 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
bellardfc01f7e2003-06-30 10:03:06 +00002776}
2777
Markus Armbruster07d27a42012-06-29 17:34:29 +02002778/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2779int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2780 uint8_t *buf, int nb_sectors)
2781{
2782 bool enabled;
2783 int ret;
2784
2785 enabled = bs->io_limits_enabled;
2786 bs->io_limits_enabled = false;
Peter Lieven4e7395e2013-07-18 10:37:32 +02002787 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
Markus Armbruster07d27a42012-06-29 17:34:29 +02002788 bs->io_limits_enabled = enabled;
2789 return ret;
2790}
2791
ths5fafdf22007-09-16 21:08:06 +00002792/* Return < 0 if error. Important errors are:
bellard19cb3732006-08-19 11:45:59 +00002793 -EIO generic I/O error (may happen for all errors)
2794 -ENOMEDIUM No media inserted.
2795 -EINVAL Invalid sector number or nb_sectors
2796 -EACCES Trying to write a read-only device
2797*/
ths5fafdf22007-09-16 21:08:06 +00002798int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002799 const uint8_t *buf, int nb_sectors)
2800{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002801 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
bellard83f64092006-08-01 16:21:11 +00002802}
2803
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002804int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2805 int nb_sectors, BdrvRequestFlags flags)
Peter Lieven4105eaa2013-07-11 14:16:22 +02002806{
2807 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002808 BDRV_REQ_ZERO_WRITE | flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002809}
2810
Peter Lievend75cbb52013-10-24 12:07:03 +02002811/*
2812 * Completely zero out a block device with the help of bdrv_write_zeroes.
2813 * The operation is sped up by checking the block status and only writing
2814 * zeroes to the device if they currently do not return zeroes. Optional
2815 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2816 *
2817 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2818 */
2819int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2820{
Kevin Wolf9ce10c02014-04-14 17:03:34 +02002821 int64_t target_size;
Peter Lievend75cbb52013-10-24 12:07:03 +02002822 int64_t ret, nb_sectors, sector_num = 0;
2823 int n;
2824
Kevin Wolf9ce10c02014-04-14 17:03:34 +02002825 target_size = bdrv_getlength(bs);
2826 if (target_size < 0) {
2827 return target_size;
2828 }
2829 target_size /= BDRV_SECTOR_SIZE;
2830
Peter Lievend75cbb52013-10-24 12:07:03 +02002831 for (;;) {
2832 nb_sectors = target_size - sector_num;
2833 if (nb_sectors <= 0) {
2834 return 0;
2835 }
2836 if (nb_sectors > INT_MAX) {
2837 nb_sectors = INT_MAX;
2838 }
2839 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
Peter Lieven3d94ce62013-12-12 13:57:05 +01002840 if (ret < 0) {
2841 error_report("error getting block status at sector %" PRId64 ": %s",
2842 sector_num, strerror(-ret));
2843 return ret;
2844 }
Peter Lievend75cbb52013-10-24 12:07:03 +02002845 if (ret & BDRV_BLOCK_ZERO) {
2846 sector_num += n;
2847 continue;
2848 }
2849 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2850 if (ret < 0) {
2851 error_report("error writing zeroes at sector %" PRId64 ": %s",
2852 sector_num, strerror(-ret));
2853 return ret;
2854 }
2855 sector_num += n;
2856 }
2857}
2858
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002859int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
bellard83f64092006-08-01 16:21:11 +00002860{
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002861 QEMUIOVector qiov;
2862 struct iovec iov = {
2863 .iov_base = (void *)buf,
2864 .iov_len = bytes,
2865 };
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002866 int ret;
bellard83f64092006-08-01 16:21:11 +00002867
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002868 if (bytes < 0) {
2869 return -EINVAL;
bellard83f64092006-08-01 16:21:11 +00002870 }
2871
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002872 qemu_iovec_init_external(&qiov, &iov, 1);
2873 ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2874 if (ret < 0) {
2875 return ret;
bellard83f64092006-08-01 16:21:11 +00002876 }
2877
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002878 return bytes;
bellard83f64092006-08-01 16:21:11 +00002879}
2880
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002881int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
bellard83f64092006-08-01 16:21:11 +00002882{
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002883 int ret;
bellard83f64092006-08-01 16:21:11 +00002884
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002885 ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2886 if (ret < 0) {
2887 return ret;
bellard83f64092006-08-01 16:21:11 +00002888 }
2889
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002890 return qiov->size;
2891}
2892
2893int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002894 const void *buf, int bytes)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002895{
2896 QEMUIOVector qiov;
2897 struct iovec iov = {
2898 .iov_base = (void *) buf,
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002899 .iov_len = bytes,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002900 };
2901
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002902 if (bytes < 0) {
2903 return -EINVAL;
2904 }
2905
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002906 qemu_iovec_init_external(&qiov, &iov, 1);
2907 return bdrv_pwritev(bs, offset, &qiov);
bellard83f64092006-08-01 16:21:11 +00002908}
bellard83f64092006-08-01 16:21:11 +00002909
Kevin Wolff08145f2010-06-16 16:38:15 +02002910/*
2911 * Writes to the file and ensures that no writes are reordered across this
2912 * request (acts as a barrier)
2913 *
2914 * Returns 0 on success, -errno in error cases.
2915 */
2916int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2917 const void *buf, int count)
2918{
2919 int ret;
2920
2921 ret = bdrv_pwrite(bs, offset, buf, count);
2922 if (ret < 0) {
2923 return ret;
2924 }
2925
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002926 /* No flush needed for cache modes that already do it */
2927 if (bs->enable_write_cache) {
Kevin Wolff08145f2010-06-16 16:38:15 +02002928 bdrv_flush(bs);
2929 }
2930
2931 return 0;
2932}
2933
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002934static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002935 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2936{
2937 /* Perform I/O through a temporary buffer so that users who scribble over
2938 * their read buffer while the operation is in progress do not end up
2939 * modifying the image file. This is critical for zero-copy guest I/O
2940 * where anything might happen inside guest memory.
2941 */
2942 void *bounce_buffer;
2943
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002944 BlockDriver *drv = bs->drv;
Stefan Hajnocziab185922011-11-17 13:40:31 +00002945 struct iovec iov;
2946 QEMUIOVector bounce_qiov;
2947 int64_t cluster_sector_num;
2948 int cluster_nb_sectors;
2949 size_t skip_bytes;
2950 int ret;
2951
2952 /* Cover entire cluster so no additional backing file I/O is required when
2953 * allocating cluster in the image file.
2954 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002955 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2956 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002957
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002958 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2959 cluster_sector_num, cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002960
2961 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2962 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2963 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2964
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002965 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2966 &bounce_qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002967 if (ret < 0) {
2968 goto err;
2969 }
2970
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002971 if (drv->bdrv_co_write_zeroes &&
2972 buffer_is_zero(bounce_buffer, iov.iov_len)) {
Kevin Wolf621f0582012-03-20 15:12:58 +01002973 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002974 cluster_nb_sectors, 0);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002975 } else {
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002976 /* This does not change the data on the disk, it is not necessary
2977 * to flush even in cache=writethrough mode.
2978 */
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002979 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002980 &bounce_qiov);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002981 }
2982
Stefan Hajnocziab185922011-11-17 13:40:31 +00002983 if (ret < 0) {
2984 /* It might be okay to ignore write errors for guest requests. If this
2985 * is a deliberate copy-on-read then we don't want to ignore the error.
2986 * Simply report it in all cases.
2987 */
2988 goto err;
2989 }
2990
2991 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
Michael Tokarev03396142012-06-07 20:17:55 +04002992 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2993 nb_sectors * BDRV_SECTOR_SIZE);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002994
2995err:
2996 qemu_vfree(bounce_buffer);
2997 return ret;
2998}
2999
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003000/*
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003001 * Forwards an already correctly aligned request to the BlockDriver. This
3002 * handles copy on read and zeroing after EOF; any other features must be
3003 * implemented by the caller.
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003004 */
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003005static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01003006 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
Kevin Wolfec746e12013-12-04 12:13:10 +01003007 int64_t align, QEMUIOVector *qiov, int flags)
Kevin Wolfda1fa912011-07-14 17:27:13 +02003008{
3009 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00003010 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003011
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003012 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3013 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003014
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003015 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3016 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3017
3018 /* Handle Copy on Read and associated serialisation */
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003019 if (flags & BDRV_REQ_COPY_ON_READ) {
Kevin Wolf73271452013-12-04 17:08:50 +01003020 /* If we touch the same cluster it counts as an overlap. This
3021 * guarantees that allocating writes will be serialized and not race
3022 * with each other for the same cluster. For example, in copy-on-read
3023 * it ensures that the CoR read and write operations are atomic and
3024 * guest writes cannot interleave between them. */
3025 mark_request_serialising(req, bdrv_get_cluster_size(bs));
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003026 }
3027
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01003028 wait_serialising_requests(req);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00003029
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003030 if (flags & BDRV_REQ_COPY_ON_READ) {
Stefan Hajnocziab185922011-11-17 13:40:31 +00003031 int pnum;
3032
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003033 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003034 if (ret < 0) {
3035 goto out;
3036 }
3037
3038 if (!ret || pnum != nb_sectors) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003039 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003040 goto out;
3041 }
3042 }
3043
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003044 /* Forward the request to the BlockDriver */
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08003045 if (!(bs->zero_beyond_eof && bs->growable)) {
3046 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3047 } else {
3048 /* Read zeros after EOF of growable BDSes */
3049 int64_t len, total_sectors, max_nb_sectors;
3050
3051 len = bdrv_getlength(bs);
3052 if (len < 0) {
3053 ret = len;
3054 goto out;
3055 }
3056
Fam Zhengd055a1f2013-09-26 19:55:33 +08003057 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
Kevin Wolf5f5bcd82014-02-07 16:00:09 +01003058 max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3059 align >> BDRV_SECTOR_BITS);
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08003060 if (max_nb_sectors > 0) {
3061 ret = drv->bdrv_co_readv(bs, sector_num,
3062 MIN(nb_sectors, max_nb_sectors), qiov);
3063 } else {
3064 ret = 0;
3065 }
3066
3067 /* Reading beyond end of file is supposed to produce zeroes */
3068 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3069 uint64_t offset = MAX(0, total_sectors - sector_num);
3070 uint64_t bytes = (sector_num + nb_sectors - offset) *
3071 BDRV_SECTOR_SIZE;
3072 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3073 }
3074 }
Stefan Hajnocziab185922011-11-17 13:40:31 +00003075
3076out:
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00003077 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003078}
3079
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003080/*
3081 * Handle a read request in coroutine context
3082 */
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003083static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3084 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003085 BdrvRequestFlags flags)
3086{
3087 BlockDriver *drv = bs->drv;
Kevin Wolf65afd212013-12-03 14:55:55 +01003088 BdrvTrackedRequest req;
3089
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003090 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3091 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3092 uint8_t *head_buf = NULL;
3093 uint8_t *tail_buf = NULL;
3094 QEMUIOVector local_qiov;
3095 bool use_local_qiov = false;
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003096 int ret;
3097
3098 if (!drv) {
3099 return -ENOMEDIUM;
3100 }
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003101 if (bdrv_check_byte_request(bs, offset, bytes)) {
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003102 return -EIO;
3103 }
3104
3105 if (bs->copy_on_read) {
3106 flags |= BDRV_REQ_COPY_ON_READ;
3107 }
3108
3109 /* throttling disk I/O */
3110 if (bs->io_limits_enabled) {
Kevin Wolfd5103582014-01-16 13:29:10 +01003111 bdrv_io_limits_intercept(bs, bytes, false);
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003112 }
3113
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003114 /* Align read if necessary by padding qiov */
3115 if (offset & (align - 1)) {
3116 head_buf = qemu_blockalign(bs, align);
3117 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3118 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3119 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3120 use_local_qiov = true;
3121
3122 bytes += offset & (align - 1);
3123 offset = offset & ~(align - 1);
3124 }
3125
3126 if ((offset + bytes) & (align - 1)) {
3127 if (!use_local_qiov) {
3128 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3129 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3130 use_local_qiov = true;
3131 }
3132 tail_buf = qemu_blockalign(bs, align);
3133 qemu_iovec_add(&local_qiov, tail_buf,
3134 align - ((offset + bytes) & (align - 1)));
3135
3136 bytes = ROUND_UP(bytes, align);
3137 }
3138
Kevin Wolf65afd212013-12-03 14:55:55 +01003139 tracked_request_begin(&req, bs, offset, bytes, false);
Kevin Wolfec746e12013-12-04 12:13:10 +01003140 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003141 use_local_qiov ? &local_qiov : qiov,
3142 flags);
Kevin Wolf65afd212013-12-03 14:55:55 +01003143 tracked_request_end(&req);
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003144
3145 if (use_local_qiov) {
3146 qemu_iovec_destroy(&local_qiov);
3147 qemu_vfree(head_buf);
3148 qemu_vfree(tail_buf);
3149 }
3150
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003151 return ret;
3152}
3153
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003154static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3155 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3156 BdrvRequestFlags flags)
3157{
3158 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3159 return -EINVAL;
3160 }
3161
3162 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3163 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3164}
3165
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003166int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
Kevin Wolfda1fa912011-07-14 17:27:13 +02003167 int nb_sectors, QEMUIOVector *qiov)
3168{
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003169 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02003170
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003171 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3172}
3173
3174int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3175 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3176{
3177 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3178
3179 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3180 BDRV_REQ_COPY_ON_READ);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003181}
3182
Peter Lievenc31cb702013-10-24 12:06:58 +02003183/* if no limit is specified in the BlockLimits use a default
3184 * of 32768 512-byte sectors (16 MiB) per request.
3185 */
3186#define MAX_WRITE_ZEROES_DEFAULT 32768
3187
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003188static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003189 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003190{
3191 BlockDriver *drv = bs->drv;
3192 QEMUIOVector qiov;
Peter Lievenc31cb702013-10-24 12:06:58 +02003193 struct iovec iov = {0};
3194 int ret = 0;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003195
Peter Lievenc31cb702013-10-24 12:06:58 +02003196 int max_write_zeroes = bs->bl.max_write_zeroes ?
3197 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
Kevin Wolf621f0582012-03-20 15:12:58 +01003198
Peter Lievenc31cb702013-10-24 12:06:58 +02003199 while (nb_sectors > 0 && !ret) {
3200 int num = nb_sectors;
3201
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003202 /* Align request. Block drivers can expect the "bulk" of the request
3203 * to be aligned.
3204 */
3205 if (bs->bl.write_zeroes_alignment
3206 && num > bs->bl.write_zeroes_alignment) {
3207 if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3208 /* Make a small request up to the first aligned sector. */
Peter Lievenc31cb702013-10-24 12:06:58 +02003209 num = bs->bl.write_zeroes_alignment;
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003210 num -= sector_num % bs->bl.write_zeroes_alignment;
3211 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3212 /* Shorten the request to the last aligned sector. num cannot
3213 * underflow because num > bs->bl.write_zeroes_alignment.
3214 */
3215 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
Peter Lievenc31cb702013-10-24 12:06:58 +02003216 }
Kevin Wolf621f0582012-03-20 15:12:58 +01003217 }
Peter Lievenc31cb702013-10-24 12:06:58 +02003218
3219 /* limit request size */
3220 if (num > max_write_zeroes) {
3221 num = max_write_zeroes;
3222 }
3223
3224 ret = -ENOTSUP;
3225 /* First try the efficient write zeroes operation */
3226 if (drv->bdrv_co_write_zeroes) {
3227 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3228 }
3229
3230 if (ret == -ENOTSUP) {
3231 /* Fall back to bounce buffer if write zeroes is unsupported */
3232 iov.iov_len = num * BDRV_SECTOR_SIZE;
3233 if (iov.iov_base == NULL) {
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003234 iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE);
3235 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
Peter Lievenc31cb702013-10-24 12:06:58 +02003236 }
3237 qemu_iovec_init_external(&qiov, &iov, 1);
3238
3239 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003240
3241 /* Keep bounce buffer around if it is big enough for all
3242 * all future requests.
3243 */
3244 if (num < max_write_zeroes) {
3245 qemu_vfree(iov.iov_base);
3246 iov.iov_base = NULL;
3247 }
Peter Lievenc31cb702013-10-24 12:06:58 +02003248 }
3249
3250 sector_num += num;
3251 nb_sectors -= num;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003252 }
3253
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003254 qemu_vfree(iov.iov_base);
3255 return ret;
3256}
3257
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003258/*
Kevin Wolfb404f722013-12-03 14:02:23 +01003259 * Forwards an already correctly aligned write request to the BlockDriver.
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003260 */
Kevin Wolfb404f722013-12-03 14:02:23 +01003261static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01003262 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3263 QEMUIOVector *qiov, int flags)
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003264{
3265 BlockDriver *drv = bs->drv;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003266 bool waited;
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003267 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003268
Kevin Wolfb404f722013-12-03 14:02:23 +01003269 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3270 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003271
Kevin Wolfb404f722013-12-03 14:02:23 +01003272 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3273 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
Benoît Canetcc0681c2013-09-02 14:14:39 +02003274
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003275 waited = wait_serialising_requests(req);
3276 assert(!waited || !req->serialising);
Kevin Wolfaf91f9a2014-02-07 15:35:56 +01003277 assert(req->overlap_offset <= offset);
3278 assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
Kevin Wolf244eade2013-12-03 14:30:44 +01003279
Kevin Wolf65afd212013-12-03 14:55:55 +01003280 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003281
Peter Lieven465bee12014-05-18 00:58:19 +02003282 if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3283 !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3284 qemu_iovec_is_zero(qiov)) {
3285 flags |= BDRV_REQ_ZERO_WRITE;
3286 if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3287 flags |= BDRV_REQ_MAY_UNMAP;
3288 }
3289 }
3290
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003291 if (ret < 0) {
3292 /* Do nothing, write notifier decided to fail this request */
3293 } else if (flags & BDRV_REQ_ZERO_WRITE) {
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003294 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003295 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003296 } else {
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003297 BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003298 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3299 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003300 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003301
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02003302 if (ret == 0 && !bs->enable_write_cache) {
3303 ret = bdrv_co_flush(bs);
3304 }
3305
Fam Zhenge4654d22013-11-13 18:29:43 +08003306 bdrv_set_dirty(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02003307
3308 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3309 bs->wr_highest_sector = sector_num + nb_sectors - 1;
3310 }
Paolo Bonzinidf2a6f22013-09-04 19:00:21 +02003311 if (bs->growable && ret >= 0) {
3312 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3313 }
Kevin Wolfda1fa912011-07-14 17:27:13 +02003314
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003315 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003316}
3317
Kevin Wolfb404f722013-12-03 14:02:23 +01003318/*
3319 * Handle a write request in coroutine context
3320 */
Kevin Wolf66015532013-12-03 14:40:18 +01003321static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3322 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Kevin Wolfb404f722013-12-03 14:02:23 +01003323 BdrvRequestFlags flags)
3324{
Kevin Wolf65afd212013-12-03 14:55:55 +01003325 BdrvTrackedRequest req;
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003326 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3327 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3328 uint8_t *head_buf = NULL;
3329 uint8_t *tail_buf = NULL;
3330 QEMUIOVector local_qiov;
3331 bool use_local_qiov = false;
Kevin Wolfb404f722013-12-03 14:02:23 +01003332 int ret;
3333
3334 if (!bs->drv) {
3335 return -ENOMEDIUM;
3336 }
3337 if (bs->read_only) {
3338 return -EACCES;
3339 }
Kevin Wolf66015532013-12-03 14:40:18 +01003340 if (bdrv_check_byte_request(bs, offset, bytes)) {
Kevin Wolfb404f722013-12-03 14:02:23 +01003341 return -EIO;
3342 }
3343
Kevin Wolfb404f722013-12-03 14:02:23 +01003344 /* throttling disk I/O */
3345 if (bs->io_limits_enabled) {
Kevin Wolfd5103582014-01-16 13:29:10 +01003346 bdrv_io_limits_intercept(bs, bytes, true);
Kevin Wolfb404f722013-12-03 14:02:23 +01003347 }
3348
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003349 /*
3350 * Align write if necessary by performing a read-modify-write cycle.
3351 * Pad qiov with the read parts and be sure to have a tracked request not
3352 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3353 */
Kevin Wolf65afd212013-12-03 14:55:55 +01003354 tracked_request_begin(&req, bs, offset, bytes, true);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003355
3356 if (offset & (align - 1)) {
3357 QEMUIOVector head_qiov;
3358 struct iovec head_iov;
3359
3360 mark_request_serialising(&req, align);
3361 wait_serialising_requests(&req);
3362
3363 head_buf = qemu_blockalign(bs, align);
3364 head_iov = (struct iovec) {
3365 .iov_base = head_buf,
3366 .iov_len = align,
3367 };
3368 qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3369
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003370 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003371 ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3372 align, &head_qiov, 0);
3373 if (ret < 0) {
3374 goto fail;
3375 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003376 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003377
3378 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3379 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3380 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3381 use_local_qiov = true;
3382
3383 bytes += offset & (align - 1);
3384 offset = offset & ~(align - 1);
3385 }
3386
3387 if ((offset + bytes) & (align - 1)) {
3388 QEMUIOVector tail_qiov;
3389 struct iovec tail_iov;
3390 size_t tail_bytes;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003391 bool waited;
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003392
3393 mark_request_serialising(&req, align);
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003394 waited = wait_serialising_requests(&req);
3395 assert(!waited || !use_local_qiov);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003396
3397 tail_buf = qemu_blockalign(bs, align);
3398 tail_iov = (struct iovec) {
3399 .iov_base = tail_buf,
3400 .iov_len = align,
3401 };
3402 qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3403
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003404 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003405 ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3406 align, &tail_qiov, 0);
3407 if (ret < 0) {
3408 goto fail;
3409 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003410 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003411
3412 if (!use_local_qiov) {
3413 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3414 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3415 use_local_qiov = true;
3416 }
3417
3418 tail_bytes = (offset + bytes) & (align - 1);
3419 qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3420
3421 bytes = ROUND_UP(bytes, align);
3422 }
3423
3424 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3425 use_local_qiov ? &local_qiov : qiov,
3426 flags);
3427
3428fail:
Kevin Wolf65afd212013-12-03 14:55:55 +01003429 tracked_request_end(&req);
Kevin Wolfb404f722013-12-03 14:02:23 +01003430
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003431 if (use_local_qiov) {
3432 qemu_iovec_destroy(&local_qiov);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003433 }
Kevin Wolf99c4a852014-02-07 15:29:00 +01003434 qemu_vfree(head_buf);
3435 qemu_vfree(tail_buf);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003436
Kevin Wolfb404f722013-12-03 14:02:23 +01003437 return ret;
3438}
3439
Kevin Wolf66015532013-12-03 14:40:18 +01003440static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3441 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3442 BdrvRequestFlags flags)
3443{
3444 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3445 return -EINVAL;
3446 }
3447
3448 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3449 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3450}
3451
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003452int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3453 int nb_sectors, QEMUIOVector *qiov)
3454{
3455 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3456
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003457 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3458}
3459
3460int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003461 int64_t sector_num, int nb_sectors,
3462 BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003463{
Paolo Bonzini94d6ff22013-11-22 13:39:45 +01003464 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003465
Peter Lievend32f35c2013-10-24 12:06:52 +02003466 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3467 flags &= ~BDRV_REQ_MAY_UNMAP;
3468 }
3469
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003470 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003471 BDRV_REQ_ZERO_WRITE | flags);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003472}
3473
bellard83f64092006-08-01 16:21:11 +00003474/**
bellard83f64092006-08-01 16:21:11 +00003475 * Truncate file to 'offset' bytes (needed only for file protocols)
3476 */
3477int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3478{
3479 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003480 int ret;
bellard83f64092006-08-01 16:21:11 +00003481 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003482 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00003483 if (!drv->bdrv_truncate)
3484 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02003485 if (bs->read_only)
3486 return -EACCES;
Jeff Cody9c75e162014-06-25 16:55:30 -04003487
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003488 ret = drv->bdrv_truncate(bs, offset);
3489 if (ret == 0) {
3490 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
Markus Armbruster145feb12011-08-03 15:07:42 +02003491 bdrv_dev_resize_cb(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003492 }
3493 return ret;
bellard83f64092006-08-01 16:21:11 +00003494}
3495
3496/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08003497 * Length of a allocated file in bytes. Sparse files are counted by actual
3498 * allocated space. Return < 0 if error or unknown.
3499 */
3500int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3501{
3502 BlockDriver *drv = bs->drv;
3503 if (!drv) {
3504 return -ENOMEDIUM;
3505 }
3506 if (drv->bdrv_get_allocated_file_size) {
3507 return drv->bdrv_get_allocated_file_size(bs);
3508 }
3509 if (bs->file) {
3510 return bdrv_get_allocated_file_size(bs->file);
3511 }
3512 return -ENOTSUP;
3513}
3514
3515/**
bellard83f64092006-08-01 16:21:11 +00003516 * Length of a file in bytes. Return < 0 if error or unknown.
3517 */
3518int64_t bdrv_getlength(BlockDriverState *bs)
3519{
3520 BlockDriver *drv = bs->drv;
3521 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003522 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003523
Kevin Wolfb94a2612013-10-29 12:18:58 +01003524 if (drv->has_variable_length) {
3525 int ret = refresh_total_sectors(bs, bs->total_sectors);
3526 if (ret < 0) {
3527 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01003528 }
bellard83f64092006-08-01 16:21:11 +00003529 }
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01003530 return bs->total_sectors * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00003531}
3532
bellard19cb3732006-08-19 11:45:59 +00003533/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00003534void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00003535{
bellard19cb3732006-08-19 11:45:59 +00003536 int64_t length;
3537 length = bdrv_getlength(bs);
3538 if (length < 0)
3539 length = 0;
3540 else
Jan Kiszka6ea44302009-11-30 18:21:19 +01003541 length = length >> BDRV_SECTOR_BITS;
bellard19cb3732006-08-19 11:45:59 +00003542 *nb_sectors_ptr = length;
bellardfc01f7e2003-06-30 10:03:06 +00003543}
bellardcf989512004-02-16 21:56:36 +00003544
Paolo Bonziniff06f5f2012-09-28 17:22:54 +02003545void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3546 BlockdevOnError on_write_error)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02003547{
3548 bs->on_read_error = on_read_error;
3549 bs->on_write_error = on_write_error;
3550}
3551
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +02003552BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02003553{
3554 return is_read ? bs->on_read_error : bs->on_write_error;
3555}
3556
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003557BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3558{
3559 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3560
3561 switch (on_err) {
3562 case BLOCKDEV_ON_ERROR_ENOSPC:
Wenchao Xiaa5895692014-06-18 08:43:30 +02003563 return (error == ENOSPC) ?
3564 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003565 case BLOCKDEV_ON_ERROR_STOP:
Wenchao Xiaa5895692014-06-18 08:43:30 +02003566 return BLOCK_ERROR_ACTION_STOP;
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003567 case BLOCKDEV_ON_ERROR_REPORT:
Wenchao Xiaa5895692014-06-18 08:43:30 +02003568 return BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003569 case BLOCKDEV_ON_ERROR_IGNORE:
Wenchao Xiaa5895692014-06-18 08:43:30 +02003570 return BLOCK_ERROR_ACTION_IGNORE;
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003571 default:
3572 abort();
3573 }
3574}
3575
3576/* This is done by device models because, while the block layer knows
3577 * about the error, it does not know whether an operation comes from
3578 * the device or the block layer (from a job, for example).
3579 */
3580void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3581 bool is_read, int error)
3582{
3583 assert(error >= 0);
Paolo Bonzini2bd3bce2014-06-05 14:53:59 +02003584
Wenchao Xiaa5895692014-06-18 08:43:30 +02003585 if (action == BLOCK_ERROR_ACTION_STOP) {
Paolo Bonzini2bd3bce2014-06-05 14:53:59 +02003586 /* First set the iostatus, so that "info block" returns an iostatus
3587 * that matches the events raised so far (an additional error iostatus
3588 * is fine, but not a lost one).
3589 */
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003590 bdrv_iostatus_set_err(bs, error);
Paolo Bonzini2bd3bce2014-06-05 14:53:59 +02003591
3592 /* Then raise the request to stop the VM and the event.
3593 * qemu_system_vmstop_request_prepare has two effects. First,
3594 * it ensures that the STOP event always comes after the
3595 * BLOCK_IO_ERROR event. Second, it ensures that even if management
3596 * can observe the STOP event and do a "cont" before the STOP
3597 * event is issued, the VM will not stop. In this case, vm_start()
3598 * also ensures that the STOP/RESUME pair of events is emitted.
3599 */
3600 qemu_system_vmstop_request_prepare();
Wenchao Xia5a2d2cb2014-06-18 08:43:45 +02003601 qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3602 is_read ? IO_OPERATION_TYPE_READ :
3603 IO_OPERATION_TYPE_WRITE,
3604 action, &error_abort);
Paolo Bonzini2bd3bce2014-06-05 14:53:59 +02003605 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
3606 } else {
Wenchao Xia5a2d2cb2014-06-18 08:43:45 +02003607 qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3608 is_read ? IO_OPERATION_TYPE_READ :
3609 IO_OPERATION_TYPE_WRITE,
3610 action, &error_abort);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003611 }
3612}
3613
bellardb3380822004-03-14 21:38:54 +00003614int bdrv_is_read_only(BlockDriverState *bs)
3615{
3616 return bs->read_only;
3617}
3618
ths985a03b2007-12-24 16:10:43 +00003619int bdrv_is_sg(BlockDriverState *bs)
3620{
3621 return bs->sg;
3622}
3623
Christoph Hellwige900a7b2009-09-04 19:01:15 +02003624int bdrv_enable_write_cache(BlockDriverState *bs)
3625{
3626 return bs->enable_write_cache;
3627}
3628
Paolo Bonzini425b0142012-06-06 00:04:52 +02003629void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3630{
3631 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04003632
3633 /* so a reopen() will preserve wce */
3634 if (wce) {
3635 bs->open_flags |= BDRV_O_CACHE_WB;
3636 } else {
3637 bs->open_flags &= ~BDRV_O_CACHE_WB;
3638 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02003639}
3640
bellardea2384d2004-08-01 21:59:26 +00003641int bdrv_is_encrypted(BlockDriverState *bs)
3642{
3643 if (bs->backing_hd && bs->backing_hd->encrypted)
3644 return 1;
3645 return bs->encrypted;
3646}
3647
aliguoric0f4ce72009-03-05 23:01:01 +00003648int bdrv_key_required(BlockDriverState *bs)
3649{
3650 BlockDriverState *backing_hd = bs->backing_hd;
3651
3652 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3653 return 1;
3654 return (bs->encrypted && !bs->valid_key);
3655}
3656
bellardea2384d2004-08-01 21:59:26 +00003657int bdrv_set_key(BlockDriverState *bs, const char *key)
3658{
3659 int ret;
3660 if (bs->backing_hd && bs->backing_hd->encrypted) {
3661 ret = bdrv_set_key(bs->backing_hd, key);
3662 if (ret < 0)
3663 return ret;
3664 if (!bs->encrypted)
3665 return 0;
3666 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02003667 if (!bs->encrypted) {
3668 return -EINVAL;
3669 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3670 return -ENOMEDIUM;
3671 }
aliguoric0f4ce72009-03-05 23:01:01 +00003672 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00003673 if (ret < 0) {
3674 bs->valid_key = 0;
3675 } else if (!bs->valid_key) {
3676 bs->valid_key = 1;
3677 /* call the change callback now, we skipped it on open */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02003678 bdrv_dev_change_media_cb(bs, true);
aliguoribb5fc202009-03-05 23:01:15 +00003679 }
aliguoric0f4ce72009-03-05 23:01:01 +00003680 return ret;
bellardea2384d2004-08-01 21:59:26 +00003681}
3682
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003683const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00003684{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003685 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00003686}
3687
ths5fafdf22007-09-16 21:08:06 +00003688void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00003689 void *opaque)
3690{
3691 BlockDriver *drv;
Jeff Codye855e4f2014-04-28 18:29:54 -04003692 int count = 0;
3693 const char **formats = NULL;
bellardea2384d2004-08-01 21:59:26 +00003694
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01003695 QLIST_FOREACH(drv, &bdrv_drivers, list) {
Jeff Codye855e4f2014-04-28 18:29:54 -04003696 if (drv->format_name) {
3697 bool found = false;
3698 int i = count;
3699 while (formats && i && !found) {
3700 found = !strcmp(formats[--i], drv->format_name);
3701 }
3702
3703 if (!found) {
3704 formats = g_realloc(formats, (count + 1) * sizeof(char *));
3705 formats[count++] = drv->format_name;
3706 it(opaque, drv->format_name);
3707 }
3708 }
bellardea2384d2004-08-01 21:59:26 +00003709 }
Jeff Codye855e4f2014-04-28 18:29:54 -04003710 g_free(formats);
bellardea2384d2004-08-01 21:59:26 +00003711}
3712
Benoît Canetdc364f42014-01-23 21:31:32 +01003713/* This function is to find block backend bs */
bellardb3380822004-03-14 21:38:54 +00003714BlockDriverState *bdrv_find(const char *name)
3715{
3716 BlockDriverState *bs;
3717
Benoît Canetdc364f42014-01-23 21:31:32 +01003718 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003719 if (!strcmp(name, bs->device_name)) {
bellardb3380822004-03-14 21:38:54 +00003720 return bs;
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003721 }
bellardb3380822004-03-14 21:38:54 +00003722 }
3723 return NULL;
3724}
3725
Benoît Canetdc364f42014-01-23 21:31:32 +01003726/* This function is to find a node in the bs graph */
3727BlockDriverState *bdrv_find_node(const char *node_name)
3728{
3729 BlockDriverState *bs;
3730
3731 assert(node_name);
3732
3733 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3734 if (!strcmp(node_name, bs->node_name)) {
3735 return bs;
3736 }
3737 }
3738 return NULL;
3739}
3740
Benoît Canetc13163f2014-01-23 21:31:34 +01003741/* Put this QMP function here so it can access the static graph_bdrv_states. */
3742BlockDeviceInfoList *bdrv_named_nodes_list(void)
3743{
3744 BlockDeviceInfoList *list, *entry;
3745 BlockDriverState *bs;
3746
3747 list = NULL;
3748 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3749 entry = g_malloc0(sizeof(*entry));
3750 entry->value = bdrv_block_device_info(bs);
3751 entry->next = list;
3752 list = entry;
3753 }
3754
3755 return list;
3756}
3757
Benoît Canet12d3ba82014-01-23 21:31:35 +01003758BlockDriverState *bdrv_lookup_bs(const char *device,
3759 const char *node_name,
3760 Error **errp)
3761{
3762 BlockDriverState *bs = NULL;
3763
Benoît Canet12d3ba82014-01-23 21:31:35 +01003764 if (device) {
3765 bs = bdrv_find(device);
3766
Benoît Canetdd67fa52014-02-12 17:15:06 +01003767 if (bs) {
3768 return bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01003769 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01003770 }
3771
Benoît Canetdd67fa52014-02-12 17:15:06 +01003772 if (node_name) {
3773 bs = bdrv_find_node(node_name);
Benoît Canet12d3ba82014-01-23 21:31:35 +01003774
Benoît Canetdd67fa52014-02-12 17:15:06 +01003775 if (bs) {
3776 return bs;
3777 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01003778 }
3779
Benoît Canetdd67fa52014-02-12 17:15:06 +01003780 error_setg(errp, "Cannot find device=%s nor node_name=%s",
3781 device ? device : "",
3782 node_name ? node_name : "");
3783 return NULL;
Benoît Canet12d3ba82014-01-23 21:31:35 +01003784}
3785
Markus Armbruster2f399b02010-06-02 18:55:20 +02003786BlockDriverState *bdrv_next(BlockDriverState *bs)
3787{
3788 if (!bs) {
3789 return QTAILQ_FIRST(&bdrv_states);
3790 }
Benoît Canetdc364f42014-01-23 21:31:32 +01003791 return QTAILQ_NEXT(bs, device_list);
Markus Armbruster2f399b02010-06-02 18:55:20 +02003792}
3793
aliguori51de9762009-03-05 23:00:43 +00003794void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
bellard81d09122004-07-14 17:21:37 +00003795{
3796 BlockDriverState *bs;
3797
Benoît Canetdc364f42014-01-23 21:31:32 +01003798 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
aliguori51de9762009-03-05 23:00:43 +00003799 it(opaque, bs);
bellard81d09122004-07-14 17:21:37 +00003800 }
3801}
3802
bellardea2384d2004-08-01 21:59:26 +00003803const char *bdrv_get_device_name(BlockDriverState *bs)
3804{
3805 return bs->device_name;
3806}
3807
Markus Armbrusterc8433282012-06-05 16:49:24 +02003808int bdrv_get_flags(BlockDriverState *bs)
3809{
3810 return bs->open_flags;
3811}
3812
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003813int bdrv_flush_all(void)
aliguoric6ca28d2008-10-06 13:55:43 +00003814{
3815 BlockDriverState *bs;
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003816 int result = 0;
aliguoric6ca28d2008-10-06 13:55:43 +00003817
Benoît Canetdc364f42014-01-23 21:31:32 +01003818 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003819 AioContext *aio_context = bdrv_get_aio_context(bs);
3820 int ret;
3821
3822 aio_context_acquire(aio_context);
3823 ret = bdrv_flush(bs);
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003824 if (ret < 0 && !result) {
3825 result = ret;
3826 }
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003827 aio_context_release(aio_context);
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003828 }
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003829
3830 return result;
aliguoric6ca28d2008-10-06 13:55:43 +00003831}
3832
Peter Lieven3ac21622013-06-28 12:47:42 +02003833int bdrv_has_zero_init_1(BlockDriverState *bs)
3834{
3835 return 1;
3836}
3837
Kevin Wolff2feebb2010-04-14 17:30:35 +02003838int bdrv_has_zero_init(BlockDriverState *bs)
3839{
3840 assert(bs->drv);
3841
Paolo Bonzini11212d82013-09-04 19:00:27 +02003842 /* If BS is a copy on write image, it is initialized to
3843 the contents of the base image, which may not be zeroes. */
3844 if (bs->backing_hd) {
3845 return 0;
3846 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02003847 if (bs->drv->bdrv_has_zero_init) {
3848 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02003849 }
3850
Peter Lieven3ac21622013-06-28 12:47:42 +02003851 /* safe default */
3852 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02003853}
3854
Peter Lieven4ce78692013-10-24 12:06:54 +02003855bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3856{
3857 BlockDriverInfo bdi;
3858
3859 if (bs->backing_hd) {
3860 return false;
3861 }
3862
3863 if (bdrv_get_info(bs, &bdi) == 0) {
3864 return bdi.unallocated_blocks_are_zero;
3865 }
3866
3867 return false;
3868}
3869
3870bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3871{
3872 BlockDriverInfo bdi;
3873
3874 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3875 return false;
3876 }
3877
3878 if (bdrv_get_info(bs, &bdi) == 0) {
3879 return bdi.can_write_zeroes_with_unmap;
3880 }
3881
3882 return false;
3883}
3884
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003885typedef struct BdrvCoGetBlockStatusData {
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003886 BlockDriverState *bs;
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +01003887 BlockDriverState *base;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003888 int64_t sector_num;
3889 int nb_sectors;
3890 int *pnum;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003891 int64_t ret;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003892 bool done;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003893} BdrvCoGetBlockStatusData;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003894
thsf58c7b32008-06-05 21:53:49 +00003895/*
3896 * Returns true iff the specified sector is present in the disk image. Drivers
3897 * not implementing the functionality are assumed to not support backing files,
3898 * hence all their sectors are reported as allocated.
3899 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003900 * If 'sector_num' is beyond the end of the disk image the return value is 0
3901 * and 'pnum' is set to 0.
3902 *
thsf58c7b32008-06-05 21:53:49 +00003903 * 'pnum' is set to the number of sectors (including and immediately following
3904 * the specified sector) that are known to be in the same
3905 * allocated/unallocated state.
3906 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003907 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3908 * beyond the end of the disk image it will be clamped.
thsf58c7b32008-06-05 21:53:49 +00003909 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003910static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3911 int64_t sector_num,
3912 int nb_sectors, int *pnum)
thsf58c7b32008-06-05 21:53:49 +00003913{
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003914 int64_t length;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003915 int64_t n;
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003916 int64_t ret, ret2;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003917
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003918 length = bdrv_getlength(bs);
3919 if (length < 0) {
3920 return length;
3921 }
3922
3923 if (sector_num >= (length >> BDRV_SECTOR_BITS)) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003924 *pnum = 0;
3925 return 0;
3926 }
3927
3928 n = bs->total_sectors - sector_num;
3929 if (n < nb_sectors) {
3930 nb_sectors = n;
3931 }
3932
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003933 if (!bs->drv->bdrv_co_get_block_status) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003934 *pnum = nb_sectors;
Kevin Wolfe88ae222014-05-06 15:25:36 +02003935 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
Paolo Bonzini918e92d2013-09-04 19:00:37 +02003936 if (bs->drv->protocol_name) {
3937 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
3938 }
3939 return ret;
thsf58c7b32008-06-05 21:53:49 +00003940 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003941
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003942 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
3943 if (ret < 0) {
Peter Lieven3e0a2332013-09-24 15:35:08 +02003944 *pnum = 0;
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003945 return ret;
3946 }
3947
Peter Lieven92bc50a2013-10-08 14:43:14 +02003948 if (ret & BDRV_BLOCK_RAW) {
3949 assert(ret & BDRV_BLOCK_OFFSET_VALID);
3950 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3951 *pnum, pnum);
3952 }
3953
Kevin Wolfe88ae222014-05-06 15:25:36 +02003954 if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
3955 ret |= BDRV_BLOCK_ALLOCATED;
3956 }
3957
Peter Lievenc3d86882013-10-24 12:07:04 +02003958 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
3959 if (bdrv_unallocated_blocks_are_zero(bs)) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003960 ret |= BDRV_BLOCK_ZERO;
Peter Lieven1f9db222013-09-24 15:35:09 +02003961 } else if (bs->backing_hd) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003962 BlockDriverState *bs2 = bs->backing_hd;
3963 int64_t length2 = bdrv_getlength(bs2);
3964 if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {
3965 ret |= BDRV_BLOCK_ZERO;
3966 }
3967 }
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003968 }
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003969
3970 if (bs->file &&
3971 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
3972 (ret & BDRV_BLOCK_OFFSET_VALID)) {
3973 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3974 *pnum, pnum);
3975 if (ret2 >= 0) {
3976 /* Ignore errors. This is just providing extra information, it
3977 * is useful but not necessary.
3978 */
3979 ret |= (ret2 & BDRV_BLOCK_ZERO);
3980 }
3981 }
3982
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003983 return ret;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003984}
3985
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003986/* Coroutine wrapper for bdrv_get_block_status() */
3987static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003988{
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003989 BdrvCoGetBlockStatusData *data = opaque;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003990 BlockDriverState *bs = data->bs;
3991
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003992 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
3993 data->pnum);
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003994 data->done = true;
3995}
3996
3997/*
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003998 * Synchronous wrapper around bdrv_co_get_block_status().
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003999 *
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004000 * See bdrv_co_get_block_status() for details.
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004001 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004002int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
4003 int nb_sectors, int *pnum)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004004{
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004005 Coroutine *co;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004006 BdrvCoGetBlockStatusData data = {
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004007 .bs = bs,
4008 .sector_num = sector_num,
4009 .nb_sectors = nb_sectors,
4010 .pnum = pnum,
4011 .done = false,
4012 };
4013
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004014 if (qemu_in_coroutine()) {
4015 /* Fast-path if already in coroutine context */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004016 bdrv_get_block_status_co_entry(&data);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004017 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004018 AioContext *aio_context = bdrv_get_aio_context(bs);
4019
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004020 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004021 qemu_coroutine_enter(co, &data);
4022 while (!data.done) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004023 aio_poll(aio_context, true);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004024 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004025 }
4026 return data.ret;
thsf58c7b32008-06-05 21:53:49 +00004027}
4028
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004029int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
4030 int nb_sectors, int *pnum)
4031{
Paolo Bonzini4333bb72013-09-04 19:00:29 +02004032 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
4033 if (ret < 0) {
4034 return ret;
4035 }
Kevin Wolfe88ae222014-05-06 15:25:36 +02004036 return (ret & BDRV_BLOCK_ALLOCATED);
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004037}
4038
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004039/*
4040 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4041 *
4042 * Return true if the given sector is allocated in any image between
4043 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4044 * sector is allocated in any image of the chain. Return false otherwise.
4045 *
4046 * 'pnum' is set to the number of sectors (including and immediately following
4047 * the specified sector) that are known to be in the same
4048 * allocated/unallocated state.
4049 *
4050 */
Paolo Bonzini4f578632013-09-04 19:00:24 +02004051int bdrv_is_allocated_above(BlockDriverState *top,
4052 BlockDriverState *base,
4053 int64_t sector_num,
4054 int nb_sectors, int *pnum)
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004055{
4056 BlockDriverState *intermediate;
4057 int ret, n = nb_sectors;
4058
4059 intermediate = top;
4060 while (intermediate && intermediate != base) {
4061 int pnum_inter;
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004062 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
4063 &pnum_inter);
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004064 if (ret < 0) {
4065 return ret;
4066 } else if (ret) {
4067 *pnum = pnum_inter;
4068 return 1;
4069 }
4070
4071 /*
4072 * [sector_num, nb_sectors] is unallocated on top but intermediate
4073 * might have
4074 *
4075 * [sector_num+x, nr_sectors] allocated.
4076 */
Vishvananda Ishaya63ba17d2013-01-24 10:02:08 -08004077 if (n > pnum_inter &&
4078 (intermediate == top ||
4079 sector_num + pnum_inter < intermediate->total_sectors)) {
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004080 n = pnum_inter;
4081 }
4082
4083 intermediate = intermediate->backing_hd;
4084 }
4085
4086 *pnum = n;
4087 return 0;
4088}
4089
aliguori045df332009-03-05 23:00:48 +00004090const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4091{
4092 if (bs->backing_hd && bs->backing_hd->encrypted)
4093 return bs->backing_file;
4094 else if (bs->encrypted)
4095 return bs->filename;
4096 else
4097 return NULL;
4098}
4099
ths5fafdf22007-09-16 21:08:06 +00004100void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00004101 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00004102{
Kevin Wolf3574c602011-10-26 11:02:11 +02004103 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00004104}
4105
ths5fafdf22007-09-16 21:08:06 +00004106int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellardfaea38e2006-08-05 21:31:00 +00004107 const uint8_t *buf, int nb_sectors)
4108{
4109 BlockDriver *drv = bs->drv;
4110 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00004111 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00004112 if (!drv->bdrv_write_compressed)
4113 return -ENOTSUP;
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02004114 if (bdrv_check_request(bs, sector_num, nb_sectors))
4115 return -EIO;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004116
Fam Zhenge4654d22013-11-13 18:29:43 +08004117 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004118
bellardfaea38e2006-08-05 21:31:00 +00004119 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4120}
ths3b46e622007-09-17 08:09:54 +00004121
bellardfaea38e2006-08-05 21:31:00 +00004122int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4123{
4124 BlockDriver *drv = bs->drv;
4125 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00004126 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00004127 if (!drv->bdrv_get_info)
4128 return -ENOTSUP;
4129 memset(bdi, 0, sizeof(*bdi));
4130 return drv->bdrv_get_info(bs, bdi);
4131}
4132
Max Reitzeae041f2013-10-09 10:46:16 +02004133ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4134{
4135 BlockDriver *drv = bs->drv;
4136 if (drv && drv->bdrv_get_specific_info) {
4137 return drv->bdrv_get_specific_info(bs);
4138 }
4139 return NULL;
4140}
4141
Christoph Hellwig45566e92009-07-10 23:11:57 +02004142int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4143 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00004144{
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004145 QEMUIOVector qiov;
4146 struct iovec iov = {
4147 .iov_base = (void *) buf,
4148 .iov_len = size,
4149 };
4150
4151 qemu_iovec_init_external(&qiov, &iov, 1);
4152 return bdrv_writev_vmstate(bs, &qiov, pos);
4153}
4154
4155int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4156{
aliguori178e08a2009-04-05 19:10:55 +00004157 BlockDriver *drv = bs->drv;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004158
4159 if (!drv) {
aliguori178e08a2009-04-05 19:10:55 +00004160 return -ENOMEDIUM;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004161 } else if (drv->bdrv_save_vmstate) {
4162 return drv->bdrv_save_vmstate(bs, qiov, pos);
4163 } else if (bs->file) {
4164 return bdrv_writev_vmstate(bs->file, qiov, pos);
4165 }
4166
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09004167 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00004168}
4169
Christoph Hellwig45566e92009-07-10 23:11:57 +02004170int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4171 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00004172{
4173 BlockDriver *drv = bs->drv;
4174 if (!drv)
4175 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09004176 if (drv->bdrv_load_vmstate)
4177 return drv->bdrv_load_vmstate(bs, buf, pos, size);
4178 if (bs->file)
4179 return bdrv_load_vmstate(bs->file, buf, pos, size);
4180 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00004181}
4182
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004183void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4184{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004185 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004186 return;
4187 }
4188
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004189 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01004190}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004191
Kevin Wolf41c695c2012-12-06 14:32:58 +01004192int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4193 const char *tag)
4194{
4195 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4196 bs = bs->file;
4197 }
4198
4199 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4200 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4201 }
4202
4203 return -ENOTSUP;
4204}
4205
Fam Zheng4cc70e92013-11-20 10:01:54 +08004206int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4207{
4208 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4209 bs = bs->file;
4210 }
4211
4212 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4213 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4214 }
4215
4216 return -ENOTSUP;
4217}
4218
Kevin Wolf41c695c2012-12-06 14:32:58 +01004219int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4220{
Max Reitz938789e2014-03-10 23:44:08 +01004221 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
Kevin Wolf41c695c2012-12-06 14:32:58 +01004222 bs = bs->file;
4223 }
4224
4225 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4226 return bs->drv->bdrv_debug_resume(bs, tag);
4227 }
4228
4229 return -ENOTSUP;
4230}
4231
4232bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4233{
4234 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4235 bs = bs->file;
4236 }
4237
4238 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4239 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4240 }
4241
4242 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004243}
4244
Blue Swirl199630b2010-07-25 20:49:34 +00004245int bdrv_is_snapshot(BlockDriverState *bs)
4246{
4247 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4248}
4249
Jeff Codyb1b1d782012-10-16 15:49:09 -04004250/* backing_file can either be relative, or absolute, or a protocol. If it is
4251 * relative, it must be relative to the chain. So, passing in bs->filename
4252 * from a BDS as backing_file should not be done, as that may be relative to
4253 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004254BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4255 const char *backing_file)
4256{
Jeff Codyb1b1d782012-10-16 15:49:09 -04004257 char *filename_full = NULL;
4258 char *backing_file_full = NULL;
4259 char *filename_tmp = NULL;
4260 int is_protocol = 0;
4261 BlockDriverState *curr_bs = NULL;
4262 BlockDriverState *retval = NULL;
4263
4264 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004265 return NULL;
4266 }
4267
Jeff Codyb1b1d782012-10-16 15:49:09 -04004268 filename_full = g_malloc(PATH_MAX);
4269 backing_file_full = g_malloc(PATH_MAX);
4270 filename_tmp = g_malloc(PATH_MAX);
4271
4272 is_protocol = path_has_protocol(backing_file);
4273
4274 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4275
4276 /* If either of the filename paths is actually a protocol, then
4277 * compare unmodified paths; otherwise make paths relative */
4278 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4279 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4280 retval = curr_bs->backing_hd;
4281 break;
4282 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004283 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04004284 /* If not an absolute filename path, make it relative to the current
4285 * image's filename path */
4286 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4287 backing_file);
4288
4289 /* We are going to compare absolute pathnames */
4290 if (!realpath(filename_tmp, filename_full)) {
4291 continue;
4292 }
4293
4294 /* We need to make sure the backing filename we are comparing against
4295 * is relative to the current image filename (or absolute) */
4296 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4297 curr_bs->backing_file);
4298
4299 if (!realpath(filename_tmp, backing_file_full)) {
4300 continue;
4301 }
4302
4303 if (strcmp(backing_file_full, filename_full) == 0) {
4304 retval = curr_bs->backing_hd;
4305 break;
4306 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004307 }
4308 }
4309
Jeff Codyb1b1d782012-10-16 15:49:09 -04004310 g_free(filename_full);
4311 g_free(backing_file_full);
4312 g_free(filename_tmp);
4313 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004314}
4315
Benoît Canetf198fd12012-08-02 10:22:47 +02004316int bdrv_get_backing_file_depth(BlockDriverState *bs)
4317{
4318 if (!bs->drv) {
4319 return 0;
4320 }
4321
4322 if (!bs->backing_hd) {
4323 return 0;
4324 }
4325
4326 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4327}
4328
Jeff Cody79fac562012-09-27 13:29:15 -04004329BlockDriverState *bdrv_find_base(BlockDriverState *bs)
4330{
4331 BlockDriverState *curr_bs = NULL;
4332
4333 if (!bs) {
4334 return NULL;
4335 }
4336
4337 curr_bs = bs;
4338
4339 while (curr_bs->backing_hd) {
4340 curr_bs = curr_bs->backing_hd;
4341 }
4342 return curr_bs;
4343}
4344
bellard83f64092006-08-01 16:21:11 +00004345/**************************************************************/
4346/* async I/Os */
4347
aliguori3b69e4b2009-01-22 16:59:24 +00004348BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
aliguorif141eaf2009-04-07 18:43:24 +00004349 QEMUIOVector *qiov, int nb_sectors,
aliguori3b69e4b2009-01-22 16:59:24 +00004350 BlockDriverCompletionFunc *cb, void *opaque)
4351{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01004352 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4353
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004354 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004355 cb, opaque, false);
bellard83f64092006-08-01 16:21:11 +00004356}
4357
aliguorif141eaf2009-04-07 18:43:24 +00004358BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4359 QEMUIOVector *qiov, int nb_sectors,
4360 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00004361{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01004362 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4363
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004364 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004365 cb, opaque, true);
bellard83f64092006-08-01 16:21:11 +00004366}
4367
Paolo Bonzinid5ef94d2013-11-22 13:39:46 +01004368BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4369 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4370 BlockDriverCompletionFunc *cb, void *opaque)
4371{
4372 trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4373
4374 return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4375 BDRV_REQ_ZERO_WRITE | flags,
4376 cb, opaque, true);
4377}
4378
Kevin Wolf40b4f532009-09-09 17:53:37 +02004379
4380typedef struct MultiwriteCB {
4381 int error;
4382 int num_requests;
4383 int num_callbacks;
4384 struct {
4385 BlockDriverCompletionFunc *cb;
4386 void *opaque;
4387 QEMUIOVector *free_qiov;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004388 } callbacks[];
4389} MultiwriteCB;
4390
4391static void multiwrite_user_cb(MultiwriteCB *mcb)
4392{
4393 int i;
4394
4395 for (i = 0; i < mcb->num_callbacks; i++) {
4396 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
Stefan Hajnoczi1e1ea482010-04-21 20:35:45 +01004397 if (mcb->callbacks[i].free_qiov) {
4398 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4399 }
Anthony Liguori7267c092011-08-20 22:09:37 -05004400 g_free(mcb->callbacks[i].free_qiov);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004401 }
4402}
4403
4404static void multiwrite_cb(void *opaque, int ret)
4405{
4406 MultiwriteCB *mcb = opaque;
4407
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01004408 trace_multiwrite_cb(mcb, ret);
4409
Kevin Wolfcb6d3ca2010-04-01 22:48:44 +02004410 if (ret < 0 && !mcb->error) {
Kevin Wolf40b4f532009-09-09 17:53:37 +02004411 mcb->error = ret;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004412 }
4413
4414 mcb->num_requests--;
4415 if (mcb->num_requests == 0) {
Kevin Wolfde189a12010-07-01 16:08:51 +02004416 multiwrite_user_cb(mcb);
Anthony Liguori7267c092011-08-20 22:09:37 -05004417 g_free(mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004418 }
4419}
4420
4421static int multiwrite_req_compare(const void *a, const void *b)
4422{
Christoph Hellwig77be4362010-05-19 20:53:10 +02004423 const BlockRequest *req1 = a, *req2 = b;
4424
4425 /*
4426 * Note that we can't simply subtract req2->sector from req1->sector
4427 * here as that could overflow the return value.
4428 */
4429 if (req1->sector > req2->sector) {
4430 return 1;
4431 } else if (req1->sector < req2->sector) {
4432 return -1;
4433 } else {
4434 return 0;
4435 }
Kevin Wolf40b4f532009-09-09 17:53:37 +02004436}
4437
4438/*
4439 * Takes a bunch of requests and tries to merge them. Returns the number of
4440 * requests that remain after merging.
4441 */
4442static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4443 int num_reqs, MultiwriteCB *mcb)
4444{
4445 int i, outidx;
4446
4447 // Sort requests by start sector
4448 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4449
4450 // Check if adjacent requests touch the same clusters. If so, combine them,
4451 // filling up gaps with zero sectors.
4452 outidx = 0;
4453 for (i = 1; i < num_reqs; i++) {
4454 int merge = 0;
4455 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4456
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01004457 // Handle exactly sequential writes and overlapping writes.
Kevin Wolf40b4f532009-09-09 17:53:37 +02004458 if (reqs[i].sector <= oldreq_last) {
4459 merge = 1;
4460 }
4461
Christoph Hellwige2a305f2010-01-26 14:49:08 +01004462 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4463 merge = 0;
4464 }
4465
Kevin Wolf40b4f532009-09-09 17:53:37 +02004466 if (merge) {
4467 size_t size;
Anthony Liguori7267c092011-08-20 22:09:37 -05004468 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
Kevin Wolf40b4f532009-09-09 17:53:37 +02004469 qemu_iovec_init(qiov,
4470 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4471
4472 // Add the first request to the merged one. If the requests are
4473 // overlapping, drop the last sectors of the first request.
4474 size = (reqs[i].sector - reqs[outidx].sector) << 9;
Michael Tokarev1b093c42012-03-12 21:28:06 +04004475 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004476
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01004477 // We should need to add any zeros between the two requests
4478 assert (reqs[i].sector <= oldreq_last);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004479
4480 // Add the second request
Michael Tokarev1b093c42012-03-12 21:28:06 +04004481 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004482
Kevin Wolfcbf1dff2010-05-21 11:09:42 +02004483 reqs[outidx].nb_sectors = qiov->size >> 9;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004484 reqs[outidx].qiov = qiov;
4485
4486 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4487 } else {
4488 outidx++;
4489 reqs[outidx].sector = reqs[i].sector;
4490 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4491 reqs[outidx].qiov = reqs[i].qiov;
4492 }
4493 }
4494
4495 return outidx + 1;
4496}
4497
4498/*
4499 * Submit multiple AIO write requests at once.
4500 *
4501 * On success, the function returns 0 and all requests in the reqs array have
4502 * been submitted. In error case this function returns -1, and any of the
4503 * requests may or may not be submitted yet. In particular, this means that the
4504 * callback will be called for some of the requests, for others it won't. The
4505 * caller must check the error field of the BlockRequest to wait for the right
4506 * callbacks (if error != 0, no callback will be called).
4507 *
4508 * The implementation may modify the contents of the reqs array, e.g. to merge
4509 * requests. However, the fields opaque and error are left unmodified as they
4510 * are used to signal failure for a single request to the caller.
4511 */
4512int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4513{
Kevin Wolf40b4f532009-09-09 17:53:37 +02004514 MultiwriteCB *mcb;
4515 int i;
4516
Ryan Harper301db7c2011-03-07 10:01:04 -06004517 /* don't submit writes if we don't have a medium */
4518 if (bs->drv == NULL) {
4519 for (i = 0; i < num_reqs; i++) {
4520 reqs[i].error = -ENOMEDIUM;
4521 }
4522 return -1;
4523 }
4524
Kevin Wolf40b4f532009-09-09 17:53:37 +02004525 if (num_reqs == 0) {
4526 return 0;
4527 }
4528
4529 // Create MultiwriteCB structure
Anthony Liguori7267c092011-08-20 22:09:37 -05004530 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
Kevin Wolf40b4f532009-09-09 17:53:37 +02004531 mcb->num_requests = 0;
4532 mcb->num_callbacks = num_reqs;
4533
4534 for (i = 0; i < num_reqs; i++) {
4535 mcb->callbacks[i].cb = reqs[i].cb;
4536 mcb->callbacks[i].opaque = reqs[i].opaque;
4537 }
4538
4539 // Check for mergable requests
4540 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4541
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01004542 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4543
Paolo Bonzinidf9309f2011-11-14 17:50:50 +01004544 /* Run the aio requests. */
4545 mcb->num_requests = num_reqs;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004546 for (i = 0; i < num_reqs; i++) {
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004547 bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4548 reqs[i].nb_sectors, reqs[i].flags,
4549 multiwrite_cb, mcb,
4550 true);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004551 }
4552
4553 return 0;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004554}
4555
bellard83f64092006-08-01 16:21:11 +00004556void bdrv_aio_cancel(BlockDriverAIOCB *acb)
pbrookce1a14d2006-08-07 02:38:06 +00004557{
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004558 acb->aiocb_info->cancel(acb);
bellard83f64092006-08-01 16:21:11 +00004559}
4560
4561/**************************************************************/
4562/* async block device emulation */
4563
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004564typedef struct BlockDriverAIOCBSync {
4565 BlockDriverAIOCB common;
4566 QEMUBH *bh;
4567 int ret;
4568 /* vector translation state */
4569 QEMUIOVector *qiov;
4570 uint8_t *bounce;
4571 int is_write;
4572} BlockDriverAIOCBSync;
4573
4574static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4575{
Kevin Wolfb666d232010-05-05 11:44:39 +02004576 BlockDriverAIOCBSync *acb =
4577 container_of(blockacb, BlockDriverAIOCBSync, common);
Dor Laor6a7ad292009-06-01 12:07:23 +03004578 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03004579 acb->bh = NULL;
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004580 qemu_aio_release(acb);
4581}
4582
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004583static const AIOCBInfo bdrv_em_aiocb_info = {
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004584 .aiocb_size = sizeof(BlockDriverAIOCBSync),
4585 .cancel = bdrv_aio_cancel_em,
4586};
4587
bellard83f64092006-08-01 16:21:11 +00004588static void bdrv_aio_bh_cb(void *opaque)
bellardbeac80c2006-06-26 20:08:57 +00004589{
pbrookce1a14d2006-08-07 02:38:06 +00004590 BlockDriverAIOCBSync *acb = opaque;
aliguorif141eaf2009-04-07 18:43:24 +00004591
aliguorif141eaf2009-04-07 18:43:24 +00004592 if (!acb->is_write)
Michael Tokarev03396142012-06-07 20:17:55 +04004593 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
aliguoriceb42de2009-04-07 18:43:28 +00004594 qemu_vfree(acb->bounce);
pbrookce1a14d2006-08-07 02:38:06 +00004595 acb->common.cb(acb->common.opaque, acb->ret);
Dor Laor6a7ad292009-06-01 12:07:23 +03004596 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03004597 acb->bh = NULL;
pbrookce1a14d2006-08-07 02:38:06 +00004598 qemu_aio_release(acb);
bellardbeac80c2006-06-26 20:08:57 +00004599}
bellardbeac80c2006-06-26 20:08:57 +00004600
aliguorif141eaf2009-04-07 18:43:24 +00004601static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4602 int64_t sector_num,
4603 QEMUIOVector *qiov,
4604 int nb_sectors,
4605 BlockDriverCompletionFunc *cb,
4606 void *opaque,
4607 int is_write)
4608
bellardea2384d2004-08-01 21:59:26 +00004609{
pbrookce1a14d2006-08-07 02:38:06 +00004610 BlockDriverAIOCBSync *acb;
pbrookce1a14d2006-08-07 02:38:06 +00004611
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004612 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
aliguorif141eaf2009-04-07 18:43:24 +00004613 acb->is_write = is_write;
4614 acb->qiov = qiov;
aliguorie268ca52009-04-22 20:20:00 +00004615 acb->bounce = qemu_blockalign(bs, qiov->size);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004616 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
aliguorif141eaf2009-04-07 18:43:24 +00004617
4618 if (is_write) {
Michael Tokarevd5e6b162012-06-07 20:21:06 +04004619 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01004620 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00004621 } else {
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01004622 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00004623 }
4624
pbrookce1a14d2006-08-07 02:38:06 +00004625 qemu_bh_schedule(acb->bh);
aliguorif141eaf2009-04-07 18:43:24 +00004626
pbrookce1a14d2006-08-07 02:38:06 +00004627 return &acb->common;
pbrook7a6cba62006-06-04 11:39:07 +00004628}
4629
aliguorif141eaf2009-04-07 18:43:24 +00004630static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4631 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +00004632 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00004633{
aliguorif141eaf2009-04-07 18:43:24 +00004634 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
bellard83f64092006-08-01 16:21:11 +00004635}
4636
aliguorif141eaf2009-04-07 18:43:24 +00004637static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4638 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4639 BlockDriverCompletionFunc *cb, void *opaque)
4640{
4641 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4642}
4643
Kevin Wolf68485422011-06-30 10:05:46 +02004644
4645typedef struct BlockDriverAIOCBCoroutine {
4646 BlockDriverAIOCB common;
4647 BlockRequest req;
4648 bool is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004649 bool *done;
Kevin Wolf68485422011-06-30 10:05:46 +02004650 QEMUBH* bh;
4651} BlockDriverAIOCBCoroutine;
4652
4653static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4654{
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004655 AioContext *aio_context = bdrv_get_aio_context(blockacb->bs);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004656 BlockDriverAIOCBCoroutine *acb =
4657 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4658 bool done = false;
4659
4660 acb->done = &done;
4661 while (!done) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004662 aio_poll(aio_context, true);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004663 }
Kevin Wolf68485422011-06-30 10:05:46 +02004664}
4665
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004666static const AIOCBInfo bdrv_em_co_aiocb_info = {
Kevin Wolf68485422011-06-30 10:05:46 +02004667 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
4668 .cancel = bdrv_aio_co_cancel_em,
4669};
4670
Paolo Bonzini35246a62011-10-14 10:41:29 +02004671static void bdrv_co_em_bh(void *opaque)
Kevin Wolf68485422011-06-30 10:05:46 +02004672{
4673 BlockDriverAIOCBCoroutine *acb = opaque;
4674
4675 acb->common.cb(acb->common.opaque, acb->req.error);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004676
4677 if (acb->done) {
4678 *acb->done = true;
4679 }
4680
Kevin Wolf68485422011-06-30 10:05:46 +02004681 qemu_bh_delete(acb->bh);
4682 qemu_aio_release(acb);
4683}
4684
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004685/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4686static void coroutine_fn bdrv_co_do_rw(void *opaque)
4687{
4688 BlockDriverAIOCBCoroutine *acb = opaque;
4689 BlockDriverState *bs = acb->common.bs;
4690
4691 if (!acb->is_write) {
4692 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004693 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004694 } else {
4695 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004696 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004697 }
4698
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004699 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004700 qemu_bh_schedule(acb->bh);
4701}
4702
Kevin Wolf68485422011-06-30 10:05:46 +02004703static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4704 int64_t sector_num,
4705 QEMUIOVector *qiov,
4706 int nb_sectors,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004707 BdrvRequestFlags flags,
Kevin Wolf68485422011-06-30 10:05:46 +02004708 BlockDriverCompletionFunc *cb,
4709 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004710 bool is_write)
Kevin Wolf68485422011-06-30 10:05:46 +02004711{
4712 Coroutine *co;
4713 BlockDriverAIOCBCoroutine *acb;
4714
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004715 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolf68485422011-06-30 10:05:46 +02004716 acb->req.sector = sector_num;
4717 acb->req.nb_sectors = nb_sectors;
4718 acb->req.qiov = qiov;
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004719 acb->req.flags = flags;
Kevin Wolf68485422011-06-30 10:05:46 +02004720 acb->is_write = is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004721 acb->done = NULL;
Kevin Wolf68485422011-06-30 10:05:46 +02004722
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004723 co = qemu_coroutine_create(bdrv_co_do_rw);
Kevin Wolf68485422011-06-30 10:05:46 +02004724 qemu_coroutine_enter(co, acb);
4725
4726 return &acb->common;
4727}
4728
Paolo Bonzini07f07612011-10-17 12:32:12 +02004729static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004730{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004731 BlockDriverAIOCBCoroutine *acb = opaque;
4732 BlockDriverState *bs = acb->common.bs;
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004733
Paolo Bonzini07f07612011-10-17 12:32:12 +02004734 acb->req.error = bdrv_co_flush(bs);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004735 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004736 qemu_bh_schedule(acb->bh);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004737}
4738
Paolo Bonzini07f07612011-10-17 12:32:12 +02004739BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Alexander Graf016f5cf2010-05-26 17:51:49 +02004740 BlockDriverCompletionFunc *cb, void *opaque)
4741{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004742 trace_bdrv_aio_flush(bs, opaque);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004743
Paolo Bonzini07f07612011-10-17 12:32:12 +02004744 Coroutine *co;
4745 BlockDriverAIOCBCoroutine *acb;
Alexander Graf016f5cf2010-05-26 17:51:49 +02004746
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004747 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004748 acb->done = NULL;
4749
Paolo Bonzini07f07612011-10-17 12:32:12 +02004750 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4751 qemu_coroutine_enter(co, acb);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004752
Alexander Graf016f5cf2010-05-26 17:51:49 +02004753 return &acb->common;
4754}
4755
Paolo Bonzini4265d622011-10-17 12:32:14 +02004756static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4757{
4758 BlockDriverAIOCBCoroutine *acb = opaque;
4759 BlockDriverState *bs = acb->common.bs;
4760
4761 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004762 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Paolo Bonzini4265d622011-10-17 12:32:14 +02004763 qemu_bh_schedule(acb->bh);
4764}
4765
4766BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4767 int64_t sector_num, int nb_sectors,
4768 BlockDriverCompletionFunc *cb, void *opaque)
4769{
4770 Coroutine *co;
4771 BlockDriverAIOCBCoroutine *acb;
4772
4773 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4774
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004775 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +02004776 acb->req.sector = sector_num;
4777 acb->req.nb_sectors = nb_sectors;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004778 acb->done = NULL;
Paolo Bonzini4265d622011-10-17 12:32:14 +02004779 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4780 qemu_coroutine_enter(co, acb);
4781
4782 return &acb->common;
4783}
4784
bellardea2384d2004-08-01 21:59:26 +00004785void bdrv_init(void)
4786{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05004787 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00004788}
pbrookce1a14d2006-08-07 02:38:06 +00004789
Markus Armbrustereb852012009-10-27 18:41:44 +01004790void bdrv_init_with_whitelist(void)
4791{
4792 use_bdrv_whitelist = 1;
4793 bdrv_init();
4794}
4795
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004796void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004797 BlockDriverCompletionFunc *cb, void *opaque)
aliguori6bbff9a2009-03-20 18:25:59 +00004798{
pbrookce1a14d2006-08-07 02:38:06 +00004799 BlockDriverAIOCB *acb;
4800
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004801 acb = g_slice_alloc(aiocb_info->aiocb_size);
4802 acb->aiocb_info = aiocb_info;
pbrookce1a14d2006-08-07 02:38:06 +00004803 acb->bs = bs;
4804 acb->cb = cb;
4805 acb->opaque = opaque;
4806 return acb;
4807}
4808
4809void qemu_aio_release(void *p)
4810{
Stefan Hajnoczid37c9752012-10-31 16:34:36 +01004811 BlockDriverAIOCB *acb = p;
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004812 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
pbrookce1a14d2006-08-07 02:38:06 +00004813}
bellard19cb3732006-08-19 11:45:59 +00004814
4815/**************************************************************/
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004816/* Coroutine block device emulation */
4817
4818typedef struct CoroutineIOCompletion {
4819 Coroutine *coroutine;
4820 int ret;
4821} CoroutineIOCompletion;
4822
4823static void bdrv_co_io_em_complete(void *opaque, int ret)
4824{
4825 CoroutineIOCompletion *co = opaque;
4826
4827 co->ret = ret;
4828 qemu_coroutine_enter(co->coroutine, NULL);
4829}
4830
4831static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4832 int nb_sectors, QEMUIOVector *iov,
4833 bool is_write)
4834{
4835 CoroutineIOCompletion co = {
4836 .coroutine = qemu_coroutine_self(),
4837 };
4838 BlockDriverAIOCB *acb;
4839
4840 if (is_write) {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004841 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4842 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004843 } else {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004844 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4845 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004846 }
4847
Stefan Hajnoczi59370aa2011-09-30 17:34:58 +01004848 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004849 if (!acb) {
4850 return -EIO;
4851 }
4852 qemu_coroutine_yield();
4853
4854 return co.ret;
4855}
4856
4857static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4858 int64_t sector_num, int nb_sectors,
4859 QEMUIOVector *iov)
4860{
4861 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4862}
4863
4864static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4865 int64_t sector_num, int nb_sectors,
4866 QEMUIOVector *iov)
4867{
4868 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4869}
4870
Paolo Bonzini07f07612011-10-17 12:32:12 +02004871static void coroutine_fn bdrv_flush_co_entry(void *opaque)
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004872{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004873 RwCo *rwco = opaque;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004874
Paolo Bonzini07f07612011-10-17 12:32:12 +02004875 rwco->ret = bdrv_co_flush(rwco->bs);
4876}
4877
4878int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4879{
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004880 int ret;
4881
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004882 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Paolo Bonzini07f07612011-10-17 12:32:12 +02004883 return 0;
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004884 }
4885
Kevin Wolfca716362011-11-10 18:13:59 +01004886 /* Write back cached data to the OS even with cache=unsafe */
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004887 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004888 if (bs->drv->bdrv_co_flush_to_os) {
4889 ret = bs->drv->bdrv_co_flush_to_os(bs);
4890 if (ret < 0) {
4891 return ret;
4892 }
4893 }
4894
Kevin Wolfca716362011-11-10 18:13:59 +01004895 /* But don't actually force it to the disk with cache=unsafe */
4896 if (bs->open_flags & BDRV_O_NO_FLUSH) {
Kevin Wolfd4c82322012-08-15 12:52:45 +02004897 goto flush_parent;
Kevin Wolfca716362011-11-10 18:13:59 +01004898 }
4899
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004900 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004901 if (bs->drv->bdrv_co_flush_to_disk) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004902 ret = bs->drv->bdrv_co_flush_to_disk(bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004903 } else if (bs->drv->bdrv_aio_flush) {
4904 BlockDriverAIOCB *acb;
4905 CoroutineIOCompletion co = {
4906 .coroutine = qemu_coroutine_self(),
4907 };
4908
4909 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4910 if (acb == NULL) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004911 ret = -EIO;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004912 } else {
4913 qemu_coroutine_yield();
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004914 ret = co.ret;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004915 }
Paolo Bonzini07f07612011-10-17 12:32:12 +02004916 } else {
4917 /*
4918 * Some block drivers always operate in either writethrough or unsafe
4919 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4920 * know how the server works (because the behaviour is hardcoded or
4921 * depends on server-side configuration), so we can't ensure that
4922 * everything is safe on disk. Returning an error doesn't work because
4923 * that would break guests even if the server operates in writethrough
4924 * mode.
4925 *
4926 * Let's hope the user knows what he's doing.
4927 */
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004928 ret = 0;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004929 }
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004930 if (ret < 0) {
4931 return ret;
4932 }
4933
4934 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4935 * in the case of cache=unsafe, so there are no useless flushes.
4936 */
Kevin Wolfd4c82322012-08-15 12:52:45 +02004937flush_parent:
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004938 return bdrv_co_flush(bs->file);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004939}
4940
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004941void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06004942{
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004943 Error *local_err = NULL;
4944 int ret;
4945
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004946 if (!bs->drv) {
4947 return;
Anthony Liguori0f154232011-11-14 15:09:45 -06004948 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004949
4950 if (bs->drv->bdrv_invalidate_cache) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004951 bs->drv->bdrv_invalidate_cache(bs, &local_err);
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004952 } else if (bs->file) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004953 bdrv_invalidate_cache(bs->file, &local_err);
4954 }
4955 if (local_err) {
4956 error_propagate(errp, local_err);
4957 return;
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004958 }
4959
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004960 ret = refresh_total_sectors(bs, bs->total_sectors);
4961 if (ret < 0) {
4962 error_setg_errno(errp, -ret, "Could not refresh total sector count");
4963 return;
4964 }
Anthony Liguori0f154232011-11-14 15:09:45 -06004965}
4966
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004967void bdrv_invalidate_cache_all(Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06004968{
4969 BlockDriverState *bs;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004970 Error *local_err = NULL;
Anthony Liguori0f154232011-11-14 15:09:45 -06004971
Benoît Canetdc364f42014-01-23 21:31:32 +01004972 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02004973 AioContext *aio_context = bdrv_get_aio_context(bs);
4974
4975 aio_context_acquire(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004976 bdrv_invalidate_cache(bs, &local_err);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02004977 aio_context_release(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004978 if (local_err) {
4979 error_propagate(errp, local_err);
4980 return;
4981 }
Anthony Liguori0f154232011-11-14 15:09:45 -06004982 }
4983}
4984
Benoît Canet07789262012-03-23 08:36:49 +01004985void bdrv_clear_incoming_migration_all(void)
4986{
4987 BlockDriverState *bs;
4988
Benoît Canetdc364f42014-01-23 21:31:32 +01004989 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02004990 AioContext *aio_context = bdrv_get_aio_context(bs);
4991
4992 aio_context_acquire(aio_context);
Benoît Canet07789262012-03-23 08:36:49 +01004993 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02004994 aio_context_release(aio_context);
Benoît Canet07789262012-03-23 08:36:49 +01004995 }
4996}
4997
Paolo Bonzini07f07612011-10-17 12:32:12 +02004998int bdrv_flush(BlockDriverState *bs)
4999{
5000 Coroutine *co;
5001 RwCo rwco = {
5002 .bs = bs,
5003 .ret = NOT_DONE,
5004 };
5005
5006 if (qemu_in_coroutine()) {
5007 /* Fast-path if already in coroutine context */
5008 bdrv_flush_co_entry(&rwco);
5009 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005010 AioContext *aio_context = bdrv_get_aio_context(bs);
5011
Paolo Bonzini07f07612011-10-17 12:32:12 +02005012 co = qemu_coroutine_create(bdrv_flush_co_entry);
5013 qemu_coroutine_enter(co, &rwco);
5014 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005015 aio_poll(aio_context, true);
Paolo Bonzini07f07612011-10-17 12:32:12 +02005016 }
5017 }
5018
5019 return rwco.ret;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02005020}
5021
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005022typedef struct DiscardCo {
5023 BlockDriverState *bs;
5024 int64_t sector_num;
5025 int nb_sectors;
5026 int ret;
5027} DiscardCo;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005028static void coroutine_fn bdrv_discard_co_entry(void *opaque)
5029{
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005030 DiscardCo *rwco = opaque;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005031
5032 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
5033}
5034
Peter Lieven6f14da52013-10-24 12:06:59 +02005035/* if no limit is specified in the BlockLimits use a default
5036 * of 32768 512-byte sectors (16 MiB) per request.
5037 */
5038#define MAX_DISCARD_DEFAULT 32768
5039
Paolo Bonzini4265d622011-10-17 12:32:14 +02005040int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
5041 int nb_sectors)
5042{
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005043 int max_discard;
5044
Paolo Bonzini4265d622011-10-17 12:32:14 +02005045 if (!bs->drv) {
5046 return -ENOMEDIUM;
5047 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
5048 return -EIO;
5049 } else if (bs->read_only) {
5050 return -EROFS;
Paolo Bonzinidf702c92013-01-14 16:26:58 +01005051 }
5052
Fam Zhenge4654d22013-11-13 18:29:43 +08005053 bdrv_reset_dirty(bs, sector_num, nb_sectors);
Paolo Bonzinidf702c92013-01-14 16:26:58 +01005054
Paolo Bonzini9e8f1832013-02-08 14:06:11 +01005055 /* Do nothing if disabled. */
5056 if (!(bs->open_flags & BDRV_O_UNMAP)) {
5057 return 0;
5058 }
5059
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005060 if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
Paolo Bonzini4265d622011-10-17 12:32:14 +02005061 return 0;
5062 }
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005063
5064 max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT;
5065 while (nb_sectors > 0) {
5066 int ret;
5067 int num = nb_sectors;
5068
5069 /* align request */
5070 if (bs->bl.discard_alignment &&
5071 num >= bs->bl.discard_alignment &&
5072 sector_num % bs->bl.discard_alignment) {
5073 if (num > bs->bl.discard_alignment) {
5074 num = bs->bl.discard_alignment;
5075 }
5076 num -= sector_num % bs->bl.discard_alignment;
5077 }
5078
5079 /* limit request size */
5080 if (num > max_discard) {
5081 num = max_discard;
5082 }
5083
5084 if (bs->drv->bdrv_co_discard) {
5085 ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5086 } else {
5087 BlockDriverAIOCB *acb;
5088 CoroutineIOCompletion co = {
5089 .coroutine = qemu_coroutine_self(),
5090 };
5091
5092 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5093 bdrv_co_io_em_complete, &co);
5094 if (acb == NULL) {
5095 return -EIO;
5096 } else {
5097 qemu_coroutine_yield();
5098 ret = co.ret;
5099 }
5100 }
Paolo Bonzini7ce21012013-11-22 13:39:47 +01005101 if (ret && ret != -ENOTSUP) {
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005102 return ret;
5103 }
5104
5105 sector_num += num;
5106 nb_sectors -= num;
5107 }
5108 return 0;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005109}
5110
5111int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5112{
5113 Coroutine *co;
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005114 DiscardCo rwco = {
Paolo Bonzini4265d622011-10-17 12:32:14 +02005115 .bs = bs,
5116 .sector_num = sector_num,
5117 .nb_sectors = nb_sectors,
5118 .ret = NOT_DONE,
5119 };
5120
5121 if (qemu_in_coroutine()) {
5122 /* Fast-path if already in coroutine context */
5123 bdrv_discard_co_entry(&rwco);
5124 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005125 AioContext *aio_context = bdrv_get_aio_context(bs);
5126
Paolo Bonzini4265d622011-10-17 12:32:14 +02005127 co = qemu_coroutine_create(bdrv_discard_co_entry);
5128 qemu_coroutine_enter(co, &rwco);
5129 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005130 aio_poll(aio_context, true);
Paolo Bonzini4265d622011-10-17 12:32:14 +02005131 }
5132 }
5133
5134 return rwco.ret;
5135}
5136
Kevin Wolff9f05dc2011-07-15 13:50:26 +02005137/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00005138/* removable device support */
5139
5140/**
5141 * Return TRUE if the media is present
5142 */
5143int bdrv_is_inserted(BlockDriverState *bs)
5144{
5145 BlockDriver *drv = bs->drv;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02005146
bellard19cb3732006-08-19 11:45:59 +00005147 if (!drv)
5148 return 0;
5149 if (!drv->bdrv_is_inserted)
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02005150 return 1;
5151 return drv->bdrv_is_inserted(bs);
bellard19cb3732006-08-19 11:45:59 +00005152}
5153
5154/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02005155 * Return whether the media changed since the last call to this
5156 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00005157 */
5158int bdrv_media_changed(BlockDriverState *bs)
5159{
5160 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00005161
Markus Armbruster8e49ca42011-08-03 15:08:08 +02005162 if (drv && drv->bdrv_media_changed) {
5163 return drv->bdrv_media_changed(bs);
5164 }
5165 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00005166}
5167
5168/**
5169 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5170 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02005171void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00005172{
5173 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00005174
Markus Armbruster822e1cd2011-07-20 18:23:42 +02005175 if (drv && drv->bdrv_eject) {
5176 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00005177 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02005178
5179 if (bs->device_name[0] != '\0') {
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +02005180 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
5181 eject_flag, &error_abort);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02005182 }
bellard19cb3732006-08-19 11:45:59 +00005183}
5184
bellard19cb3732006-08-19 11:45:59 +00005185/**
5186 * Lock or unlock the media (if it is locked, the user won't be able
5187 * to eject it manually).
5188 */
Markus Armbruster025e8492011-09-06 18:58:47 +02005189void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00005190{
5191 BlockDriver *drv = bs->drv;
5192
Markus Armbruster025e8492011-09-06 18:58:47 +02005193 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01005194
Markus Armbruster025e8492011-09-06 18:58:47 +02005195 if (drv && drv->bdrv_lock_medium) {
5196 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00005197 }
5198}
ths985a03b2007-12-24 16:10:43 +00005199
5200/* needed for generic scsi interface */
5201
5202int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5203{
5204 BlockDriver *drv = bs->drv;
5205
5206 if (drv && drv->bdrv_ioctl)
5207 return drv->bdrv_ioctl(bs, req, buf);
5208 return -ENOTSUP;
5209}
aliguori7d780662009-03-12 19:57:08 +00005210
aliguori221f7152009-03-28 17:28:41 +00005211BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5212 unsigned long int req, void *buf,
5213 BlockDriverCompletionFunc *cb, void *opaque)
aliguori7d780662009-03-12 19:57:08 +00005214{
aliguori221f7152009-03-28 17:28:41 +00005215 BlockDriver *drv = bs->drv;
aliguori7d780662009-03-12 19:57:08 +00005216
aliguori221f7152009-03-28 17:28:41 +00005217 if (drv && drv->bdrv_aio_ioctl)
5218 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5219 return NULL;
aliguori7d780662009-03-12 19:57:08 +00005220}
aliguorie268ca52009-04-22 20:20:00 +00005221
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01005222void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
Markus Armbruster7b6f9302011-09-06 18:58:56 +02005223{
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01005224 bs->guest_block_size = align;
Markus Armbruster7b6f9302011-09-06 18:58:56 +02005225}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005226
aliguorie268ca52009-04-22 20:20:00 +00005227void *qemu_blockalign(BlockDriverState *bs, size_t size)
5228{
Kevin Wolf339064d2013-11-28 10:23:32 +01005229 return qemu_memalign(bdrv_opt_mem_align(bs), size);
aliguorie268ca52009-04-22 20:20:00 +00005230}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005231
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005232/*
5233 * Check if all memory in this vector is sector aligned.
5234 */
5235bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5236{
5237 int i;
Kevin Wolf339064d2013-11-28 10:23:32 +01005238 size_t alignment = bdrv_opt_mem_align(bs);
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005239
5240 for (i = 0; i < qiov->niov; i++) {
Kevin Wolf339064d2013-11-28 10:23:32 +01005241 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005242 return false;
5243 }
Kevin Wolf339064d2013-11-28 10:23:32 +01005244 if (qiov->iov[i].iov_len % alignment) {
Kevin Wolf1ff735b2013-12-05 13:01:46 +01005245 return false;
5246 }
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005247 }
5248
5249 return true;
5250}
5251
Fam Zhengb8afb522014-04-16 09:34:30 +08005252BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5253 Error **errp)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005254{
5255 int64_t bitmap_size;
Fam Zhenge4654d22013-11-13 18:29:43 +08005256 BdrvDirtyBitmap *bitmap;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01005257
Paolo Bonzini50717e92013-01-21 17:09:45 +01005258 assert((granularity & (granularity - 1)) == 0);
5259
Fam Zhenge4654d22013-11-13 18:29:43 +08005260 granularity >>= BDRV_SECTOR_BITS;
5261 assert(granularity);
Fam Zhengb8afb522014-04-16 09:34:30 +08005262 bitmap_size = bdrv_getlength(bs);
5263 if (bitmap_size < 0) {
5264 error_setg_errno(errp, -bitmap_size, "could not get length of device");
5265 errno = -bitmap_size;
5266 return NULL;
5267 }
5268 bitmap_size >>= BDRV_SECTOR_BITS;
Fam Zhenge4654d22013-11-13 18:29:43 +08005269 bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
5270 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5271 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5272 return bitmap;
5273}
5274
5275void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5276{
5277 BdrvDirtyBitmap *bm, *next;
5278 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5279 if (bm == bitmap) {
5280 QLIST_REMOVE(bitmap, list);
5281 hbitmap_free(bitmap->bitmap);
5282 g_free(bitmap);
5283 return;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01005284 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005285 }
5286}
5287
Fam Zheng21b56832013-11-13 18:29:44 +08005288BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5289{
5290 BdrvDirtyBitmap *bm;
5291 BlockDirtyInfoList *list = NULL;
5292 BlockDirtyInfoList **plist = &list;
5293
5294 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5295 BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
5296 BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
5297 info->count = bdrv_get_dirty_count(bs, bm);
5298 info->granularity =
5299 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5300 entry->value = info;
5301 *plist = entry;
5302 plist = &entry->next;
5303 }
5304
5305 return list;
5306}
5307
Fam Zhenge4654d22013-11-13 18:29:43 +08005308int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005309{
Fam Zhenge4654d22013-11-13 18:29:43 +08005310 if (bitmap) {
5311 return hbitmap_get(bitmap->bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005312 } else {
5313 return 0;
5314 }
5315}
5316
Fam Zhenge4654d22013-11-13 18:29:43 +08005317void bdrv_dirty_iter_init(BlockDriverState *bs,
5318 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02005319{
Fam Zhenge4654d22013-11-13 18:29:43 +08005320 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02005321}
5322
5323void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5324 int nr_sectors)
5325{
Fam Zhenge4654d22013-11-13 18:29:43 +08005326 BdrvDirtyBitmap *bitmap;
5327 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5328 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01005329 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02005330}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005331
Fam Zhenge4654d22013-11-13 18:29:43 +08005332void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5333{
5334 BdrvDirtyBitmap *bitmap;
5335 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5336 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5337 }
5338}
5339
5340int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5341{
5342 return hbitmap_count(bitmap->bitmap);
5343}
5344
Fam Zheng9fcb0252013-08-23 09:14:46 +08005345/* Get a reference to bs */
5346void bdrv_ref(BlockDriverState *bs)
5347{
5348 bs->refcnt++;
5349}
5350
5351/* Release a previously grabbed reference to bs.
5352 * If after releasing, reference count is zero, the BlockDriverState is
5353 * deleted. */
5354void bdrv_unref(BlockDriverState *bs)
5355{
5356 assert(bs->refcnt > 0);
5357 if (--bs->refcnt == 0) {
5358 bdrv_delete(bs);
5359 }
5360}
5361
Fam Zhengfbe40ff2014-05-23 21:29:42 +08005362struct BdrvOpBlocker {
5363 Error *reason;
5364 QLIST_ENTRY(BdrvOpBlocker) list;
5365};
5366
5367bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5368{
5369 BdrvOpBlocker *blocker;
5370 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5371 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5372 blocker = QLIST_FIRST(&bs->op_blockers[op]);
5373 if (errp) {
5374 error_setg(errp, "Device '%s' is busy: %s",
5375 bs->device_name, error_get_pretty(blocker->reason));
5376 }
5377 return true;
5378 }
5379 return false;
5380}
5381
5382void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5383{
5384 BdrvOpBlocker *blocker;
5385 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5386
5387 blocker = g_malloc0(sizeof(BdrvOpBlocker));
5388 blocker->reason = reason;
5389 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5390}
5391
5392void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5393{
5394 BdrvOpBlocker *blocker, *next;
5395 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5396 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5397 if (blocker->reason == reason) {
5398 QLIST_REMOVE(blocker, list);
5399 g_free(blocker);
5400 }
5401 }
5402}
5403
5404void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5405{
5406 int i;
5407 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5408 bdrv_op_block(bs, i, reason);
5409 }
5410}
5411
5412void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5413{
5414 int i;
5415 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5416 bdrv_op_unblock(bs, i, reason);
5417 }
5418}
5419
5420bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5421{
5422 int i;
5423
5424 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5425 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5426 return false;
5427 }
5428 }
5429 return true;
5430}
5431
Luiz Capitulino28a72822011-09-26 17:43:50 -03005432void bdrv_iostatus_enable(BlockDriverState *bs)
5433{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005434 bs->iostatus_enabled = true;
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005435 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005436}
5437
5438/* The I/O status is only enabled if the drive explicitly
5439 * enables it _and_ the VM is configured to stop on errors */
5440bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5441{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005442 return (bs->iostatus_enabled &&
Paolo Bonzini92aa5c62012-09-28 17:22:55 +02005443 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5444 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
5445 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
Luiz Capitulino28a72822011-09-26 17:43:50 -03005446}
5447
5448void bdrv_iostatus_disable(BlockDriverState *bs)
5449{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005450 bs->iostatus_enabled = false;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005451}
5452
5453void bdrv_iostatus_reset(BlockDriverState *bs)
5454{
5455 if (bdrv_iostatus_is_enabled(bs)) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005456 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Paolo Bonzini3bd293c2012-10-18 16:49:27 +02005457 if (bs->job) {
5458 block_job_iostatus_reset(bs->job);
5459 }
Luiz Capitulino28a72822011-09-26 17:43:50 -03005460 }
5461}
5462
Luiz Capitulino28a72822011-09-26 17:43:50 -03005463void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5464{
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02005465 assert(bdrv_iostatus_is_enabled(bs));
5466 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005467 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5468 BLOCK_DEVICE_IO_STATUS_FAILED;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005469 }
5470}
5471
Christoph Hellwiga597e792011-08-25 08:26:01 +02005472void
5473bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5474 enum BlockAcctType type)
5475{
5476 assert(type < BDRV_MAX_IOTYPE);
5477
5478 cookie->bytes = bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02005479 cookie->start_time_ns = get_clock();
Christoph Hellwiga597e792011-08-25 08:26:01 +02005480 cookie->type = type;
5481}
5482
5483void
5484bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5485{
5486 assert(cookie->type < BDRV_MAX_IOTYPE);
5487
5488 bs->nr_bytes[cookie->type] += cookie->bytes;
5489 bs->nr_ops[cookie->type]++;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02005490 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +02005491}
5492
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005493void bdrv_img_create(const char *filename, const char *fmt,
5494 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005495 char *options, uint64_t img_size, int flags,
5496 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005497{
Chunyan Liu83d05212014-06-05 17:20:51 +08005498 QemuOptsList *create_opts = NULL;
5499 QemuOpts *opts = NULL;
5500 const char *backing_fmt, *backing_file;
5501 int64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005502 BlockDriver *drv, *proto_drv;
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00005503 BlockDriver *backing_drv = NULL;
Max Reitzcc84d902013-09-06 17:14:26 +02005504 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005505 int ret = 0;
5506
5507 /* Find driver and parse its options */
5508 drv = bdrv_find_format(fmt);
5509 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005510 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005511 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005512 }
5513
Kevin Wolf98289622013-07-10 15:47:39 +02005514 proto_drv = bdrv_find_protocol(filename, true);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005515 if (!proto_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005516 error_setg(errp, "Unknown protocol '%s'", filename);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005517 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005518 }
5519
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005520 create_opts = qemu_opts_append(create_opts, drv->create_opts);
5521 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005522
5523 /* Create parameter list with default values */
Chunyan Liu83d05212014-06-05 17:20:51 +08005524 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5525 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005526
5527 /* Parse -o options */
5528 if (options) {
Chunyan Liu83d05212014-06-05 17:20:51 +08005529 if (qemu_opts_do_parse(opts, options, NULL) != 0) {
5530 error_setg(errp, "Invalid options for file format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005531 goto out;
5532 }
5533 }
5534
5535 if (base_filename) {
Chunyan Liu83d05212014-06-05 17:20:51 +08005536 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005537 error_setg(errp, "Backing file not supported for file format '%s'",
5538 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005539 goto out;
5540 }
5541 }
5542
5543 if (base_fmt) {
Chunyan Liu83d05212014-06-05 17:20:51 +08005544 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005545 error_setg(errp, "Backing file format not supported for file "
5546 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005547 goto out;
5548 }
5549 }
5550
Chunyan Liu83d05212014-06-05 17:20:51 +08005551 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5552 if (backing_file) {
5553 if (!strcmp(filename, backing_file)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005554 error_setg(errp, "Error: Trying to create an image with the "
5555 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01005556 goto out;
5557 }
5558 }
5559
Chunyan Liu83d05212014-06-05 17:20:51 +08005560 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5561 if (backing_fmt) {
5562 backing_drv = bdrv_find_format(backing_fmt);
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00005563 if (!backing_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005564 error_setg(errp, "Unknown backing file format '%s'",
Chunyan Liu83d05212014-06-05 17:20:51 +08005565 backing_fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005566 goto out;
5567 }
5568 }
5569
5570 // The size for the image must always be specified, with one exception:
5571 // If we are using a backing file, we can obtain the size from there
Chunyan Liu83d05212014-06-05 17:20:51 +08005572 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5573 if (size == -1) {
5574 if (backing_file) {
Max Reitz66f6b812013-12-03 14:57:52 +01005575 BlockDriverState *bs;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005576 uint64_t size;
Paolo Bonzini63090da2012-04-12 14:01:03 +02005577 int back_flags;
5578
5579 /* backing files always opened read-only */
5580 back_flags =
5581 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005582
Max Reitzf67503e2014-02-18 18:33:05 +01005583 bs = NULL;
Chunyan Liu83d05212014-06-05 17:20:51 +08005584 ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
Max Reitzcc84d902013-09-06 17:14:26 +02005585 backing_drv, &local_err);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005586 if (ret < 0) {
Max Reitzcc84d902013-09-06 17:14:26 +02005587 error_setg_errno(errp, -ret, "Could not open '%s': %s",
Chunyan Liu83d05212014-06-05 17:20:51 +08005588 backing_file,
Max Reitzcc84d902013-09-06 17:14:26 +02005589 error_get_pretty(local_err));
5590 error_free(local_err);
5591 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005592 goto out;
5593 }
5594 bdrv_get_geometry(bs, &size);
5595 size *= 512;
5596
Chunyan Liu83d05212014-06-05 17:20:51 +08005597 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);
Max Reitz66f6b812013-12-03 14:57:52 +01005598
5599 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005600 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005601 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005602 goto out;
5603 }
5604 }
5605
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005606 if (!quiet) {
5607 printf("Formatting '%s', fmt=%s ", filename, fmt);
Chunyan Liu83d05212014-06-05 17:20:51 +08005608 qemu_opts_print(opts);
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005609 puts("");
5610 }
Chunyan Liu83d05212014-06-05 17:20:51 +08005611
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005612 ret = bdrv_create(drv, filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08005613
Max Reitzcc84d902013-09-06 17:14:26 +02005614 if (ret == -EFBIG) {
5615 /* This is generally a better message than whatever the driver would
5616 * deliver (especially because of the cluster_size_hint), since that
5617 * is most probably not much different from "image too large". */
5618 const char *cluster_size_hint = "";
Chunyan Liu83d05212014-06-05 17:20:51 +08005619 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
Max Reitzcc84d902013-09-06 17:14:26 +02005620 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005621 }
Max Reitzcc84d902013-09-06 17:14:26 +02005622 error_setg(errp, "The image size is too large for file format '%s'"
5623 "%s", fmt, cluster_size_hint);
5624 error_free(local_err);
5625 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005626 }
5627
5628out:
Chunyan Liu83d05212014-06-05 17:20:51 +08005629 qemu_opts_del(opts);
5630 qemu_opts_free(create_opts);
Markus Armbruster84d18f02014-01-30 15:07:28 +01005631 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +02005632 error_propagate(errp, local_err);
5633 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005634}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01005635
5636AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5637{
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02005638 return bs->aio_context;
5639}
5640
5641void bdrv_detach_aio_context(BlockDriverState *bs)
5642{
5643 if (!bs->drv) {
5644 return;
5645 }
5646
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02005647 if (bs->io_limits_enabled) {
5648 throttle_detach_aio_context(&bs->throttle_state);
5649 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02005650 if (bs->drv->bdrv_detach_aio_context) {
5651 bs->drv->bdrv_detach_aio_context(bs);
5652 }
5653 if (bs->file) {
5654 bdrv_detach_aio_context(bs->file);
5655 }
5656 if (bs->backing_hd) {
5657 bdrv_detach_aio_context(bs->backing_hd);
5658 }
5659
5660 bs->aio_context = NULL;
5661}
5662
5663void bdrv_attach_aio_context(BlockDriverState *bs,
5664 AioContext *new_context)
5665{
5666 if (!bs->drv) {
5667 return;
5668 }
5669
5670 bs->aio_context = new_context;
5671
5672 if (bs->backing_hd) {
5673 bdrv_attach_aio_context(bs->backing_hd, new_context);
5674 }
5675 if (bs->file) {
5676 bdrv_attach_aio_context(bs->file, new_context);
5677 }
5678 if (bs->drv->bdrv_attach_aio_context) {
5679 bs->drv->bdrv_attach_aio_context(bs, new_context);
5680 }
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02005681 if (bs->io_limits_enabled) {
5682 throttle_attach_aio_context(&bs->throttle_state, new_context);
5683 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02005684}
5685
5686void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5687{
5688 bdrv_drain_all(); /* ensure there are no in-flight requests */
5689
5690 bdrv_detach_aio_context(bs);
5691
5692 /* This function executes in the old AioContext so acquire the new one in
5693 * case it runs in a different thread.
5694 */
5695 aio_context_acquire(new_context);
5696 bdrv_attach_aio_context(bs, new_context);
5697 aio_context_release(new_context);
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01005698}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02005699
5700void bdrv_add_before_write_notifier(BlockDriverState *bs,
5701 NotifierWithReturn *notifier)
5702{
5703 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5704}
Max Reitz6f176b42013-09-03 10:09:50 +02005705
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005706int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)
Max Reitz6f176b42013-09-03 10:09:50 +02005707{
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005708 if (!bs->drv->bdrv_amend_options) {
Max Reitz6f176b42013-09-03 10:09:50 +02005709 return -ENOTSUP;
5710 }
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005711 return bs->drv->bdrv_amend_options(bs, opts);
Max Reitz6f176b42013-09-03 10:09:50 +02005712}
Benoît Canetf6186f42013-10-02 14:33:48 +02005713
Benoît Canetb5042a32014-03-03 19:11:34 +01005714/* This function will be called by the bdrv_recurse_is_first_non_filter method
5715 * of block filter and by bdrv_is_first_non_filter.
5716 * It is used to test if the given bs is the candidate or recurse more in the
5717 * node graph.
Benoît Canet212a5a82014-01-23 21:31:36 +01005718 */
Benoît Canet212a5a82014-01-23 21:31:36 +01005719bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5720 BlockDriverState *candidate)
Benoît Canetf6186f42013-10-02 14:33:48 +02005721{
Benoît Canetb5042a32014-03-03 19:11:34 +01005722 /* return false if basic checks fails */
5723 if (!bs || !bs->drv) {
5724 return false;
5725 }
5726
5727 /* the code reached a non block filter driver -> check if the bs is
5728 * the same as the candidate. It's the recursion termination condition.
5729 */
5730 if (!bs->drv->is_filter) {
5731 return bs == candidate;
5732 }
5733 /* Down this path the driver is a block filter driver */
5734
5735 /* If the block filter recursion method is defined use it to recurse down
5736 * the node graph.
5737 */
5738 if (bs->drv->bdrv_recurse_is_first_non_filter) {
Benoît Canet212a5a82014-01-23 21:31:36 +01005739 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5740 }
5741
Benoît Canetb5042a32014-03-03 19:11:34 +01005742 /* the driver is a block filter but don't allow to recurse -> return false
5743 */
5744 return false;
Benoît Canet212a5a82014-01-23 21:31:36 +01005745}
5746
5747/* This function checks if the candidate is the first non filter bs down it's
5748 * bs chain. Since we don't have pointers to parents it explore all bs chains
5749 * from the top. Some filters can choose not to pass down the recursion.
5750 */
5751bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5752{
5753 BlockDriverState *bs;
5754
5755 /* walk down the bs forest recursively */
5756 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5757 bool perm;
5758
Benoît Canetb5042a32014-03-03 19:11:34 +01005759 /* try to recurse in this top level bs */
Kevin Wolfe6dc8a12014-02-04 11:45:31 +01005760 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
Benoît Canet212a5a82014-01-23 21:31:36 +01005761
5762 /* candidate is the first non filter */
5763 if (perm) {
5764 return true;
5765 }
5766 }
5767
5768 return false;
Benoît Canetf6186f42013-10-02 14:33:48 +02005769}
Benoît Canet09158f02014-06-27 18:25:25 +02005770
5771BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
5772{
5773 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5774 if (!to_replace_bs) {
5775 error_setg(errp, "Node name '%s' not found", node_name);
5776 return NULL;
5777 }
5778
5779 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5780 return NULL;
5781 }
5782
5783 /* We don't want arbitrary node of the BDS chain to be replaced only the top
5784 * most non filter in order to prevent data corruption.
5785 * Another benefit is that this tests exclude backing files which are
5786 * blocked by the backing blockers.
5787 */
5788 if (!bdrv_is_first_non_filter(to_replace_bs)) {
5789 error_setg(errp, "Only top most non filter can be replaced");
5790 return NULL;
5791 }
5792
5793 return to_replace_bs;
5794}