blob: 0a391bd80fd2d51d232874e70ccc6564633f9cde [file] [log] [blame]
bellardfc01f7e2003-06-30 10:03:06 +00001/*
2 * QEMU System Emulator block driver
ths5fafdf22007-09-16 21:08:06 +00003 *
bellardfc01f7e2003-06-30 10:03:06 +00004 * Copyright (c) 2003 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellardfc01f7e2003-06-30 10:03:06 +00006 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
blueswir13990d092008-12-05 17:53:21 +000024#include "config-host.h"
pbrookfaf07962007-11-11 02:51:17 +000025#include "qemu-common.h"
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +010026#include "trace.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010027#include "monitor/monitor.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010028#include "block/block_int.h"
29#include "block/blockjob.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010030#include "qemu/module.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010031#include "qapi/qmp/qjson.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010032#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010033#include "qemu/notify.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010034#include "block/coroutine.h"
Benoît Canetc13163f2014-01-23 21:31:34 +010035#include "block/qapi.h"
Luiz Capitulinob2023812011-09-21 17:16:47 -030036#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010037#include "qemu/timer.h"
bellardfc01f7e2003-06-30 10:03:06 +000038
Juan Quintela71e72a12009-07-27 16:12:56 +020039#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000040#include <sys/types.h>
41#include <sys/stat.h>
42#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000043#include <sys/queue.h>
blueswir1c5e97232009-03-07 20:06:23 +000044#ifndef __DragonFly__
bellard7674e7b2005-04-26 21:59:26 +000045#include <sys/disk.h>
46#endif
blueswir1c5e97232009-03-07 20:06:23 +000047#endif
bellard7674e7b2005-04-26 21:59:26 +000048
aliguori49dc7682009-03-08 16:26:59 +000049#ifdef _WIN32
50#include <windows.h>
51#endif
52
Fam Zhenge4654d22013-11-13 18:29:43 +080053struct BdrvDirtyBitmap {
54 HBitmap *bitmap;
55 QLIST_ENTRY(BdrvDirtyBitmap) list;
56};
57
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010058#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
59
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +020060static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
aliguorif141eaf2009-04-07 18:43:24 +000061static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
62 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
aliguoric87c0672009-04-07 18:43:20 +000063 BlockDriverCompletionFunc *cb, void *opaque);
aliguorif141eaf2009-04-07 18:43:24 +000064static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
65 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +000066 BlockDriverCompletionFunc *cb, void *opaque);
Kevin Wolff9f05dc2011-07-15 13:50:26 +020067static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
68 int64_t sector_num, int nb_sectors,
69 QEMUIOVector *iov);
70static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
71 int64_t sector_num, int nb_sectors,
72 QEMUIOVector *iov);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +010073static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +000074 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
75 BdrvRequestFlags flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010076static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +000077 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
78 BdrvRequestFlags flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010079static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
80 int64_t sector_num,
81 QEMUIOVector *qiov,
82 int nb_sectors,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +010083 BdrvRequestFlags flags,
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010084 BlockDriverCompletionFunc *cb,
85 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +010086 bool is_write);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010087static void coroutine_fn bdrv_co_do_rw(void *opaque);
Kevin Wolf621f0582012-03-20 15:12:58 +010088static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +020089 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
bellardec530c82006-04-25 22:36:06 +000090
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +010091static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
92 QTAILQ_HEAD_INITIALIZER(bdrv_states);
blueswir17ee930d2008-09-17 19:04:14 +000093
Benoît Canetdc364f42014-01-23 21:31:32 +010094static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
95 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
96
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010097static QLIST_HEAD(, BlockDriver) bdrv_drivers =
98 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +000099
Markus Armbrustereb852012009-10-27 18:41:44 +0100100/* If non-zero, use only whitelisted block drivers */
101static int use_bdrv_whitelist;
102
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000103#ifdef _WIN32
104static int is_windows_drive_prefix(const char *filename)
105{
106 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
107 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
108 filename[1] == ':');
109}
110
111int is_windows_drive(const char *filename)
112{
113 if (is_windows_drive_prefix(filename) &&
114 filename[2] == '\0')
115 return 1;
116 if (strstart(filename, "\\\\.\\", NULL) ||
117 strstart(filename, "//./", NULL))
118 return 1;
119 return 0;
120}
121#endif
122
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800123/* throttling disk I/O limits */
Benoît Canetcc0681c2013-09-02 14:14:39 +0200124void bdrv_set_io_limits(BlockDriverState *bs,
125 ThrottleConfig *cfg)
126{
127 int i;
128
129 throttle_config(&bs->throttle_state, cfg);
130
131 for (i = 0; i < 2; i++) {
132 qemu_co_enter_next(&bs->throttled_reqs[i]);
133 }
134}
135
136/* this function drain all the throttled IOs */
137static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
138{
139 bool drained = false;
140 bool enabled = bs->io_limits_enabled;
141 int i;
142
143 bs->io_limits_enabled = false;
144
145 for (i = 0; i < 2; i++) {
146 while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
147 drained = true;
148 }
149 }
150
151 bs->io_limits_enabled = enabled;
152
153 return drained;
154}
155
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800156void bdrv_io_limits_disable(BlockDriverState *bs)
157{
158 bs->io_limits_enabled = false;
159
Benoît Canetcc0681c2013-09-02 14:14:39 +0200160 bdrv_start_throttled_reqs(bs);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800161
Benoît Canetcc0681c2013-09-02 14:14:39 +0200162 throttle_destroy(&bs->throttle_state);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800163}
164
Benoît Canetcc0681c2013-09-02 14:14:39 +0200165static void bdrv_throttle_read_timer_cb(void *opaque)
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800166{
167 BlockDriverState *bs = opaque;
Benoît Canetcc0681c2013-09-02 14:14:39 +0200168 qemu_co_enter_next(&bs->throttled_reqs[0]);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800169}
170
Benoît Canetcc0681c2013-09-02 14:14:39 +0200171static void bdrv_throttle_write_timer_cb(void *opaque)
172{
173 BlockDriverState *bs = opaque;
174 qemu_co_enter_next(&bs->throttled_reqs[1]);
175}
176
177/* should be called before bdrv_set_io_limits if a limit is set */
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800178void bdrv_io_limits_enable(BlockDriverState *bs)
179{
Benoît Canetcc0681c2013-09-02 14:14:39 +0200180 assert(!bs->io_limits_enabled);
181 throttle_init(&bs->throttle_state,
182 QEMU_CLOCK_VIRTUAL,
183 bdrv_throttle_read_timer_cb,
184 bdrv_throttle_write_timer_cb,
185 bs);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800186 bs->io_limits_enabled = true;
187}
188
Benoît Canetcc0681c2013-09-02 14:14:39 +0200189/* This function makes an IO wait if needed
190 *
191 * @nb_sectors: the number of sectors of the IO
192 * @is_write: is the IO a write
193 */
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800194static void bdrv_io_limits_intercept(BlockDriverState *bs,
Benoît Canetcc0681c2013-09-02 14:14:39 +0200195 int nb_sectors,
196 bool is_write)
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800197{
Benoît Canetcc0681c2013-09-02 14:14:39 +0200198 /* does this io must wait */
199 bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800200
Benoît Canetcc0681c2013-09-02 14:14:39 +0200201 /* if must wait or any request of this type throttled queue the IO */
202 if (must_wait ||
203 !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
204 qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800205 }
206
Benoît Canetcc0681c2013-09-02 14:14:39 +0200207 /* the IO will be executed, do the accounting */
208 throttle_account(&bs->throttle_state,
209 is_write,
210 nb_sectors * BDRV_SECTOR_SIZE);
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) */
336BlockDriverState *bdrv_new(const char *device_name)
bellardfc01f7e2003-06-30 10:03:06 +0000337{
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +0100338 BlockDriverState *bs;
bellardb3380822004-03-14 21:38:54 +0000339
Anthony Liguori7267c092011-08-20 22:09:37 -0500340 bs = g_malloc0(sizeof(BlockDriverState));
Fam Zhenge4654d22013-11-13 18:29:43 +0800341 QLIST_INIT(&bs->dirty_bitmaps);
bellardb3380822004-03-14 21:38:54 +0000342 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
bellardea2384d2004-08-01 21:59:26 +0000343 if (device_name[0] != '\0') {
Benoît Canetdc364f42014-01-23 21:31:32 +0100344 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
bellardea2384d2004-08-01 21:59:26 +0000345 }
Luiz Capitulino28a72822011-09-26 17:43:50 -0300346 bdrv_iostatus_disable(bs);
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200347 notifier_list_init(&bs->close_notifiers);
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200348 notifier_with_return_list_init(&bs->before_write_notifiers);
Benoît Canetcc0681c2013-09-02 14:14:39 +0200349 qemu_co_queue_init(&bs->throttled_reqs[0]);
350 qemu_co_queue_init(&bs->throttled_reqs[1]);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800351 bs->refcnt = 1;
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200352
bellardb3380822004-03-14 21:38:54 +0000353 return bs;
354}
355
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200356void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
357{
358 notifier_list_add(&bs->close_notifiers, notify);
359}
360
bellardea2384d2004-08-01 21:59:26 +0000361BlockDriver *bdrv_find_format(const char *format_name)
362{
363 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100364 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
365 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000366 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100367 }
bellardea2384d2004-08-01 21:59:26 +0000368 }
369 return NULL;
370}
371
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800372static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100373{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800374 static const char *whitelist_rw[] = {
375 CONFIG_BDRV_RW_WHITELIST
376 };
377 static const char *whitelist_ro[] = {
378 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100379 };
380 const char **p;
381
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800382 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100383 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800384 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100385
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800386 for (p = whitelist_rw; *p; p++) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100387 if (!strcmp(drv->format_name, *p)) {
388 return 1;
389 }
390 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800391 if (read_only) {
392 for (p = whitelist_ro; *p; p++) {
393 if (!strcmp(drv->format_name, *p)) {
394 return 1;
395 }
396 }
397 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100398 return 0;
399}
400
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800401BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
402 bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100403{
404 BlockDriver *drv = bdrv_find_format(format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800405 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
Markus Armbrustereb852012009-10-27 18:41:44 +0100406}
407
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800408typedef struct CreateCo {
409 BlockDriver *drv;
410 char *filename;
411 QEMUOptionParameter *options;
412 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200413 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800414} CreateCo;
415
416static void coroutine_fn bdrv_create_co_entry(void *opaque)
417{
Max Reitzcc84d902013-09-06 17:14:26 +0200418 Error *local_err = NULL;
419 int ret;
420
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800421 CreateCo *cco = opaque;
422 assert(cco->drv);
423
Max Reitzcc84d902013-09-06 17:14:26 +0200424 ret = cco->drv->bdrv_create(cco->filename, cco->options, &local_err);
425 if (error_is_set(&local_err)) {
426 error_propagate(&cco->err, local_err);
427 }
428 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800429}
430
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200431int bdrv_create(BlockDriver *drv, const char* filename,
Max Reitzcc84d902013-09-06 17:14:26 +0200432 QEMUOptionParameter *options, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000433{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800434 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200435
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800436 Coroutine *co;
437 CreateCo cco = {
438 .drv = drv,
439 .filename = g_strdup(filename),
440 .options = options,
441 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200442 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800443 };
444
445 if (!drv->bdrv_create) {
Max Reitzcc84d902013-09-06 17:14:26 +0200446 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300447 ret = -ENOTSUP;
448 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800449 }
450
451 if (qemu_in_coroutine()) {
452 /* Fast-path if already in coroutine context */
453 bdrv_create_co_entry(&cco);
454 } else {
455 co = qemu_coroutine_create(bdrv_create_co_entry);
456 qemu_coroutine_enter(co, &cco);
457 while (cco.ret == NOT_DONE) {
458 qemu_aio_wait();
459 }
460 }
461
462 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200463 if (ret < 0) {
464 if (error_is_set(&cco.err)) {
465 error_propagate(errp, cco.err);
466 } else {
467 error_setg_errno(errp, -ret, "Could not create image");
468 }
469 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800470
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300471out:
472 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800473 return ret;
bellardea2384d2004-08-01 21:59:26 +0000474}
475
Max Reitzcc84d902013-09-06 17:14:26 +0200476int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
477 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200478{
479 BlockDriver *drv;
Max Reitzcc84d902013-09-06 17:14:26 +0200480 Error *local_err = NULL;
481 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200482
Kevin Wolf98289622013-07-10 15:47:39 +0200483 drv = bdrv_find_protocol(filename, true);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200484 if (drv == NULL) {
Max Reitzcc84d902013-09-06 17:14:26 +0200485 error_setg(errp, "Could not find protocol for file '%s'", filename);
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000486 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200487 }
488
Max Reitzcc84d902013-09-06 17:14:26 +0200489 ret = bdrv_create(drv, filename, options, &local_err);
490 if (error_is_set(&local_err)) {
491 error_propagate(errp, local_err);
492 }
493 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200494}
495
Kevin Wolf355ef4a2013-12-11 20:14:09 +0100496int bdrv_refresh_limits(BlockDriverState *bs)
Kevin Wolfd34682c2013-12-11 19:26:16 +0100497{
498 BlockDriver *drv = bs->drv;
499
500 memset(&bs->bl, 0, sizeof(bs->bl));
501
Kevin Wolf466ad822013-12-11 19:50:32 +0100502 if (!drv) {
503 return 0;
504 }
505
506 /* Take some limits from the children as a default */
507 if (bs->file) {
508 bdrv_refresh_limits(bs->file);
509 bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
Kevin Wolf339064d2013-11-28 10:23:32 +0100510 bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
511 } else {
512 bs->bl.opt_mem_alignment = 512;
Kevin Wolf466ad822013-12-11 19:50:32 +0100513 }
514
515 if (bs->backing_hd) {
516 bdrv_refresh_limits(bs->backing_hd);
517 bs->bl.opt_transfer_length =
518 MAX(bs->bl.opt_transfer_length,
519 bs->backing_hd->bl.opt_transfer_length);
Kevin Wolf339064d2013-11-28 10:23:32 +0100520 bs->bl.opt_mem_alignment =
521 MAX(bs->bl.opt_mem_alignment,
522 bs->backing_hd->bl.opt_mem_alignment);
Kevin Wolf466ad822013-12-11 19:50:32 +0100523 }
524
525 /* Then let the driver override it */
526 if (drv->bdrv_refresh_limits) {
Kevin Wolfd34682c2013-12-11 19:26:16 +0100527 return drv->bdrv_refresh_limits(bs);
528 }
529
530 return 0;
531}
532
Jim Meyeringeba25052012-05-28 09:27:54 +0200533/*
534 * Create a uniquely-named empty temporary file.
535 * Return 0 upon success, otherwise a negative errno value.
536 */
537int get_tmp_filename(char *filename, int size)
538{
bellardd5249392004-08-03 21:14:23 +0000539#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000540 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200541 /* GetTempFileName requires that its output buffer (4th param)
542 have length MAX_PATH or greater. */
543 assert(size >= MAX_PATH);
544 return (GetTempPath(MAX_PATH, temp_dir)
545 && GetTempFileName(temp_dir, "qem", 0, filename)
546 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000547#else
bellardea2384d2004-08-01 21:59:26 +0000548 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000549 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000550 tmpdir = getenv("TMPDIR");
551 if (!tmpdir)
552 tmpdir = "/tmp";
Jim Meyeringeba25052012-05-28 09:27:54 +0200553 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
554 return -EOVERFLOW;
555 }
bellardea2384d2004-08-01 21:59:26 +0000556 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800557 if (fd < 0) {
558 return -errno;
559 }
560 if (close(fd) != 0) {
561 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200562 return -errno;
563 }
564 return 0;
bellardd5249392004-08-03 21:14:23 +0000565#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200566}
bellardea2384d2004-08-01 21:59:26 +0000567
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200568/*
569 * Detect host devices. By convention, /dev/cdrom[N] is always
570 * recognized as a host CDROM.
571 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200572static BlockDriver *find_hdev_driver(const char *filename)
573{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200574 int score_max = 0, score;
575 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200576
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100577 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200578 if (d->bdrv_probe_device) {
579 score = d->bdrv_probe_device(filename);
580 if (score > score_max) {
581 score_max = score;
582 drv = d;
583 }
584 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200585 }
586
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200587 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200588}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200589
Kevin Wolf98289622013-07-10 15:47:39 +0200590BlockDriver *bdrv_find_protocol(const char *filename,
591 bool allow_protocol_prefix)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200592{
593 BlockDriver *drv1;
594 char protocol[128];
595 int len;
596 const char *p;
597
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200598 /* TODO Drivers without bdrv_file_open must be specified explicitly */
599
Christoph Hellwig39508e72010-06-23 12:25:17 +0200600 /*
601 * XXX(hch): we really should not let host device detection
602 * override an explicit protocol specification, but moving this
603 * later breaks access to device names with colons in them.
604 * Thanks to the brain-dead persistent naming schemes on udev-
605 * based Linux systems those actually are quite common.
606 */
607 drv1 = find_hdev_driver(filename);
608 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200609 return drv1;
610 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200611
Kevin Wolf98289622013-07-10 15:47:39 +0200612 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Christoph Hellwig39508e72010-06-23 12:25:17 +0200613 return bdrv_find_format("file");
614 }
Kevin Wolf98289622013-07-10 15:47:39 +0200615
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000616 p = strchr(filename, ':');
617 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200618 len = p - filename;
619 if (len > sizeof(protocol) - 1)
620 len = sizeof(protocol) - 1;
621 memcpy(protocol, filename, len);
622 protocol[len] = '\0';
623 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
624 if (drv1->protocol_name &&
625 !strcmp(drv1->protocol_name, protocol)) {
626 return drv1;
627 }
628 }
629 return NULL;
630}
631
Kevin Wolff500a6d2012-11-12 17:35:27 +0100632static int find_image_format(BlockDriverState *bs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200633 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000634{
Kevin Wolff500a6d2012-11-12 17:35:27 +0100635 int score, score_max;
bellardea2384d2004-08-01 21:59:26 +0000636 BlockDriver *drv1, *drv;
bellard83f64092006-08-01 16:21:11 +0000637 uint8_t buf[2048];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100638 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700639
Kevin Wolf08a00552010-06-01 18:37:31 +0200640 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Paolo Bonzini8e895592013-01-10 15:39:27 +0100641 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Stefan Weilc98ac352010-07-21 21:51:51 +0200642 drv = bdrv_find_format("raw");
643 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200644 error_setg(errp, "Could not find raw image format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200645 ret = -ENOENT;
646 }
647 *pdrv = drv;
648 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700649 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700650
bellard83f64092006-08-01 16:21:11 +0000651 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000652 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200653 error_setg_errno(errp, -ret, "Could not read image for determining its "
654 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200655 *pdrv = NULL;
656 return ret;
bellard83f64092006-08-01 16:21:11 +0000657 }
658
bellardea2384d2004-08-01 21:59:26 +0000659 score_max = 0;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200660 drv = NULL;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100661 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
bellard83f64092006-08-01 16:21:11 +0000662 if (drv1->bdrv_probe) {
663 score = drv1->bdrv_probe(buf, ret, filename);
664 if (score > score_max) {
665 score_max = score;
666 drv = drv1;
667 }
bellardea2384d2004-08-01 21:59:26 +0000668 }
669 }
Stefan Weilc98ac352010-07-21 21:51:51 +0200670 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200671 error_setg(errp, "Could not determine image format: No compatible "
672 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200673 ret = -ENOENT;
674 }
675 *pdrv = drv;
676 return ret;
bellardea2384d2004-08-01 21:59:26 +0000677}
678
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100679/**
680 * Set the current 'total_sectors' value
681 */
682static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
683{
684 BlockDriver *drv = bs->drv;
685
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700686 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
687 if (bs->sg)
688 return 0;
689
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100690 /* query actual device if possible, otherwise just trust the hint */
691 if (drv->bdrv_getlength) {
692 int64_t length = drv->bdrv_getlength(bs);
693 if (length < 0) {
694 return length;
695 }
Fam Zheng7e382002013-11-06 19:48:06 +0800696 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100697 }
698
699 bs->total_sectors = hint;
700 return 0;
701}
702
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100703/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100704 * Set open flags for a given discard mode
705 *
706 * Return 0 on success, -1 if the discard mode was invalid.
707 */
708int bdrv_parse_discard_flags(const char *mode, int *flags)
709{
710 *flags &= ~BDRV_O_UNMAP;
711
712 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
713 /* do nothing */
714 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
715 *flags |= BDRV_O_UNMAP;
716 } else {
717 return -1;
718 }
719
720 return 0;
721}
722
723/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100724 * Set open flags for a given cache mode
725 *
726 * Return 0 on success, -1 if the cache mode was invalid.
727 */
728int bdrv_parse_cache_flags(const char *mode, int *flags)
729{
730 *flags &= ~BDRV_O_CACHE_MASK;
731
732 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
733 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100734 } else if (!strcmp(mode, "directsync")) {
735 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100736 } else if (!strcmp(mode, "writeback")) {
737 *flags |= BDRV_O_CACHE_WB;
738 } else if (!strcmp(mode, "unsafe")) {
739 *flags |= BDRV_O_CACHE_WB;
740 *flags |= BDRV_O_NO_FLUSH;
741 } else if (!strcmp(mode, "writethrough")) {
742 /* this is the default */
743 } else {
744 return -1;
745 }
746
747 return 0;
748}
749
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000750/**
751 * The copy-on-read flag is actually a reference count so multiple users may
752 * use the feature without worrying about clobbering its previous state.
753 * Copy-on-read stays enabled until all users have called to disable it.
754 */
755void bdrv_enable_copy_on_read(BlockDriverState *bs)
756{
757 bs->copy_on_read++;
758}
759
760void bdrv_disable_copy_on_read(BlockDriverState *bs)
761{
762 assert(bs->copy_on_read > 0);
763 bs->copy_on_read--;
764}
765
Kevin Wolf7b272452012-11-12 17:05:39 +0100766static int bdrv_open_flags(BlockDriverState *bs, int flags)
767{
768 int open_flags = flags | BDRV_O_CACHE_WB;
769
770 /*
771 * Clear flags that are internal to the block layer before opening the
772 * image.
773 */
774 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
775
776 /*
777 * Snapshots should be writable.
778 */
779 if (bs->is_temporary) {
780 open_flags |= BDRV_O_RDWR;
781 }
782
783 return open_flags;
784}
785
Benoît Canet6913c0c2014-01-23 21:31:33 +0100786static int bdrv_assign_node_name(BlockDriverState *bs,
787 const char *node_name,
788 Error **errp)
789{
790 if (!node_name) {
791 return 0;
792 }
793
794 /* empty string node name is invalid */
795 if (node_name[0] == '\0') {
796 error_setg(errp, "Empty node name");
797 return -EINVAL;
798 }
799
800 /* takes care of avoiding duplicates node names */
801 if (bdrv_find_node(node_name)) {
802 error_setg(errp, "Duplicate node name");
803 return -EINVAL;
804 }
805
806 /* copy node name into the bs and insert it into the graph list */
807 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
808 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
809
810 return 0;
811}
812
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200813/*
Kevin Wolf57915332010-04-14 15:24:50 +0200814 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +0100815 *
816 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +0200817 */
Kevin Wolff500a6d2012-11-12 17:35:27 +0100818static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200819 QDict *options, int flags, BlockDriver *drv, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +0200820{
821 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200822 const char *filename;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100823 const char *node_name = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200824 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +0200825
826 assert(drv != NULL);
Paolo Bonzini64058752012-05-08 16:51:49 +0200827 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +0100828 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +0200829
Kevin Wolf45673672013-04-22 17:48:40 +0200830 if (file != NULL) {
831 filename = file->filename;
832 } else {
833 filename = qdict_get_try_str(options, "filename");
834 }
835
836 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
Stefan Hajnoczi28dcee12011-09-22 20:14:12 +0100837
Benoît Canet6913c0c2014-01-23 21:31:33 +0100838 node_name = qdict_get_try_str(options, "node-name");
839 ret = bdrv_assign_node_name(bs, node_name, errp);
840 if (ret < 0) {
841 return ret;
842 }
843 qdict_del(options, "node-name");
844
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100845 /* bdrv_open() with directly using a protocol as drv. This layer is already
846 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
847 * and return immediately. */
848 if (file != NULL && drv->bdrv_file_open) {
849 bdrv_swap(file, bs);
850 return 0;
851 }
852
Kevin Wolf57915332010-04-14 15:24:50 +0200853 bs->open_flags = flags;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +0100854 bs->guest_block_size = 512;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100855 bs->request_alignment = 512;
Asias He0d51b4d2013-08-22 15:24:14 +0800856 bs->zero_beyond_eof = true;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800857 open_flags = bdrv_open_flags(bs, flags);
858 bs->read_only = !(open_flags & BDRV_O_RDWR);
859
860 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200861 error_setg(errp,
862 !bs->read_only && bdrv_is_whitelisted(drv, true)
863 ? "Driver '%s' can only be used for read-only devices"
864 : "Driver '%s' is not whitelisted",
865 drv->format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800866 return -ENOTSUP;
867 }
Kevin Wolf57915332010-04-14 15:24:50 +0200868
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000869 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200870 if (flags & BDRV_O_COPY_ON_READ) {
871 if (!bs->read_only) {
872 bdrv_enable_copy_on_read(bs);
873 } else {
874 error_setg(errp, "Can't use copy-on-read on read-only device");
875 return -EINVAL;
876 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000877 }
878
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100879 if (filename != NULL) {
880 pstrcpy(bs->filename, sizeof(bs->filename), filename);
881 } else {
882 bs->filename[0] = '\0';
883 }
Kevin Wolf57915332010-04-14 15:24:50 +0200884
Kevin Wolf57915332010-04-14 15:24:50 +0200885 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500886 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200887
Stefan Hajnoczi03f541b2011-10-27 10:54:28 +0100888 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100889
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200890 /* Open the image, either directly or using a protocol */
891 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100892 assert(file == NULL);
Benoît Canet030be322013-09-24 17:07:04 +0200893 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200894 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +0100895 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200896 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200897 error_setg(errp, "Can't use '%s' as a block driver for the "
898 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200899 ret = -EINVAL;
900 goto free_and_fail;
901 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100902 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200903 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200904 }
905
Kevin Wolf57915332010-04-14 15:24:50 +0200906 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200907 if (error_is_set(&local_err)) {
908 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +0800909 } else if (bs->filename[0]) {
910 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200911 } else {
912 error_setg_errno(errp, -ret, "Could not open image");
913 }
Kevin Wolf57915332010-04-14 15:24:50 +0200914 goto free_and_fail;
915 }
916
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100917 ret = refresh_total_sectors(bs, bs->total_sectors);
918 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200919 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100920 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200921 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100922
Kevin Wolfd34682c2013-12-11 19:26:16 +0100923 bdrv_refresh_limits(bs);
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100924 assert(bdrv_opt_mem_align(bs) != 0);
925 assert(bs->request_alignment != 0);
Kevin Wolfd34682c2013-12-11 19:26:16 +0100926
Kevin Wolf57915332010-04-14 15:24:50 +0200927#ifndef _WIN32
928 if (bs->is_temporary) {
Dunrong Huangd4cea8d2013-10-03 01:31:27 +0800929 assert(bs->filename[0] != '\0');
930 unlink(bs->filename);
Kevin Wolf57915332010-04-14 15:24:50 +0200931 }
932#endif
933 return 0;
934
935free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +0100936 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -0500937 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +0200938 bs->opaque = NULL;
939 bs->drv = NULL;
940 return ret;
941}
942
943/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200944 * Opens a file using a protocol (file, host_device, nbd, ...)
Kevin Wolf787e4a82013-03-06 11:52:48 +0100945 *
946 * options is a QDict of options to pass to the block drivers, or NULL for an
947 * empty set of options. The reference to the QDict belongs to the block layer
948 * after the call (even on failure), so if the caller intends to reuse the
949 * dictionary, it needs to use QINCREF() before calling bdrv_file_open.
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200950 */
Kevin Wolf787e4a82013-03-06 11:52:48 +0100951int bdrv_file_open(BlockDriverState **pbs, const char *filename,
Max Reitz72daa722013-12-20 19:28:08 +0100952 const char *reference, QDict *options, int flags,
953 Error **errp)
bellardb3380822004-03-14 21:38:54 +0000954{
Max Reitz72daa722013-12-20 19:28:08 +0100955 BlockDriverState *bs = NULL;
Christoph Hellwig6db95602010-04-05 16:53:57 +0200956 BlockDriver *drv;
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100957 const char *drvname;
Kevin Wolf98289622013-07-10 15:47:39 +0200958 bool allow_protocol_prefix = false;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200959 Error *local_err = NULL;
bellard83f64092006-08-01 16:21:11 +0000960 int ret;
961
Kevin Wolf707ff822013-03-06 12:20:31 +0100962 /* NULL means an empty set of options */
963 if (options == NULL) {
964 options = qdict_new();
bellard3b0d4f62005-10-30 18:30:10 +0000965 }
Kevin Wolf707ff822013-03-06 12:20:31 +0100966
Max Reitz72daa722013-12-20 19:28:08 +0100967 if (reference) {
968 if (filename || qdict_size(options)) {
969 error_setg(errp, "Cannot reference an existing block device with "
970 "additional options or a new filename");
971 return -EINVAL;
972 }
973 QDECREF(options);
974
975 bs = bdrv_find(reference);
976 if (!bs) {
977 error_setg(errp, "Cannot find block device '%s'", reference);
978 return -ENODEV;
979 }
980 bdrv_ref(bs);
981 *pbs = bs;
982 return 0;
983 }
984
Kevin Wolf707ff822013-03-06 12:20:31 +0100985 bs = bdrv_new("");
986 bs->options = options;
987 options = qdict_clone_shallow(options);
988
Kevin Wolf035fccd2013-04-09 14:34:19 +0200989 /* Fetch the file name from the options QDict if necessary */
990 if (!filename) {
991 filename = qdict_get_try_str(options, "filename");
992 } else if (filename && !qdict_haskey(options, "filename")) {
993 qdict_put(options, "filename", qstring_from_str(filename));
Kevin Wolf98289622013-07-10 15:47:39 +0200994 allow_protocol_prefix = true;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200995 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200996 error_setg(errp, "Can't specify 'file' and 'filename' options at the "
997 "same time");
Kevin Wolf035fccd2013-04-09 14:34:19 +0200998 ret = -EINVAL;
999 goto fail;
1000 }
1001
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001002 /* Find the right block driver */
1003 drvname = qdict_get_try_str(options, "driver");
1004 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +02001005 drv = bdrv_find_format(drvname);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001006 if (!drv) {
1007 error_setg(errp, "Unknown driver '%s'", drvname);
1008 }
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001009 qdict_del(options, "driver");
1010 } else if (filename) {
Kevin Wolf98289622013-07-10 15:47:39 +02001011 drv = bdrv_find_protocol(filename, allow_protocol_prefix);
1012 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001013 error_setg(errp, "Unknown protocol");
Kevin Wolf98289622013-07-10 15:47:39 +02001014 }
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001015 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001016 error_setg(errp, "Must specify either driver or file");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001017 drv = NULL;
1018 }
1019
1020 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001021 /* errp has been set already */
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001022 ret = -ENOENT;
1023 goto fail;
1024 }
1025
1026 /* Parse the filename and open it */
1027 if (drv->bdrv_parse_filename && filename) {
Kevin Wolf6963a302013-03-15 18:47:22 +01001028 drv->bdrv_parse_filename(filename, options, &local_err);
1029 if (error_is_set(&local_err)) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001030 error_propagate(errp, local_err);
Kevin Wolf6963a302013-03-15 18:47:22 +01001031 ret = -EINVAL;
1032 goto fail;
1033 }
Kevin Wolf56d1b4d2013-04-12 20:02:37 +02001034 qdict_del(options, "filename");
Benoît Canet030be322013-09-24 17:07:04 +02001035 } else if (drv->bdrv_needs_filename && !filename) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001036 error_setg(errp, "The '%s' block driver requires a file name",
1037 drv->format_name);
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001038 ret = -EINVAL;
1039 goto fail;
Kevin Wolf6963a302013-03-15 18:47:22 +01001040 }
1041
Max Reitz505d7582013-12-20 19:28:13 +01001042 if (!drv->bdrv_file_open) {
1043 ret = bdrv_open(bs, filename, options, flags, drv, &local_err);
1044 options = NULL;
1045 } else {
1046 ret = bdrv_open_common(bs, NULL, options, flags, drv, &local_err);
1047 }
Kevin Wolf707ff822013-03-06 12:20:31 +01001048 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001049 error_propagate(errp, local_err);
Kevin Wolf707ff822013-03-06 12:20:31 +01001050 goto fail;
1051 }
1052
1053 /* Check if any unknown options were used */
Max Reitz505d7582013-12-20 19:28:13 +01001054 if (options && (qdict_size(options) != 0)) {
Kevin Wolf707ff822013-03-06 12:20:31 +01001055 const QDictEntry *entry = qdict_first(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001056 error_setg(errp, "Block protocol '%s' doesn't support the option '%s'",
1057 drv->format_name, entry->key);
Kevin Wolf707ff822013-03-06 12:20:31 +01001058 ret = -EINVAL;
1059 goto fail;
1060 }
1061 QDECREF(options);
1062
aliguori71d07702009-03-03 17:37:16 +00001063 bs->growable = 1;
bellard83f64092006-08-01 16:21:11 +00001064 *pbs = bs;
1065 return 0;
Kevin Wolf707ff822013-03-06 12:20:31 +01001066
1067fail:
1068 QDECREF(options);
1069 if (!bs->drv) {
1070 QDECREF(bs->options);
1071 }
Fam Zheng4f6fd342013-08-23 09:14:47 +08001072 bdrv_unref(bs);
Kevin Wolf707ff822013-03-06 12:20:31 +01001073 return ret;
bellardea2384d2004-08-01 21:59:26 +00001074}
bellardfc01f7e2003-06-30 10:03:06 +00001075
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001076/*
1077 * Opens the backing file for a BlockDriverState if not yet open
1078 *
1079 * options is a QDict of options to pass to the block drivers, or NULL for an
1080 * empty set of options. The reference to the QDict is transferred to this
1081 * function (even on failure), so if the caller intends to reuse the dictionary,
1082 * it needs to use QINCREF() before calling bdrv_file_open.
1083 */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001084int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02001085{
1086 char backing_filename[PATH_MAX];
1087 int back_flags, ret;
1088 BlockDriver *back_drv = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001089 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001090
1091 if (bs->backing_hd != NULL) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001092 QDECREF(options);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001093 return 0;
1094 }
1095
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001096 /* NULL means an empty set of options */
1097 if (options == NULL) {
1098 options = qdict_new();
1099 }
1100
Paolo Bonzini9156df12012-10-18 16:49:17 +02001101 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolf1cb6f502013-04-12 20:27:07 +02001102 if (qdict_haskey(options, "file.filename")) {
1103 backing_filename[0] = '\0';
1104 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001105 QDECREF(options);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001106 return 0;
Fam Zhengdbecebd2013-09-22 20:05:06 +08001107 } else {
1108 bdrv_get_full_backing_filename(bs, backing_filename,
1109 sizeof(backing_filename));
Paolo Bonzini9156df12012-10-18 16:49:17 +02001110 }
1111
1112 bs->backing_hd = bdrv_new("");
Paolo Bonzini9156df12012-10-18 16:49:17 +02001113
1114 if (bs->backing_format[0] != '\0') {
1115 back_drv = bdrv_find_format(bs->backing_format);
1116 }
1117
1118 /* backing files always opened read-only */
Thibaut LAURENT87a5deb2013-10-25 02:15:07 +02001119 back_flags = bs->open_flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT |
1120 BDRV_O_COPY_ON_READ);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001121
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001122 ret = bdrv_open(bs->backing_hd,
1123 *backing_filename ? backing_filename : NULL, options,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001124 back_flags, back_drv, &local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001125 if (ret < 0) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001126 bdrv_unref(bs->backing_hd);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001127 bs->backing_hd = NULL;
1128 bs->open_flags |= BDRV_O_NO_BACKING;
Fam Zhengb04b6b62013-11-08 11:26:49 +08001129 error_setg(errp, "Could not open backing file: %s",
1130 error_get_pretty(local_err));
1131 error_free(local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001132 return ret;
1133 }
Peter Feinerd80ac652014-01-08 19:43:25 +00001134
1135 if (bs->backing_hd->file) {
1136 pstrcpy(bs->backing_file, sizeof(bs->backing_file),
1137 bs->backing_hd->file->filename);
1138 }
1139
Kevin Wolfd34682c2013-12-11 19:26:16 +01001140 /* Recalculate the BlockLimits with the backing file */
1141 bdrv_refresh_limits(bs);
1142
Paolo Bonzini9156df12012-10-18 16:49:17 +02001143 return 0;
1144}
1145
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001146/*
Max Reitzda557aa2013-12-20 19:28:11 +01001147 * Opens a disk image whose options are given as BlockdevRef in another block
1148 * device's options.
1149 *
1150 * If force_raw is true, bdrv_file_open() will be used, thereby preventing any
1151 * image format auto-detection. If it is false and a filename is given,
1152 * bdrv_open() will be used for auto-detection.
1153 *
1154 * If allow_none is true, no image will be opened if filename is false and no
1155 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1156 *
1157 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1158 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1159 * itself, all options starting with "${bdref_key}." are considered part of the
1160 * BlockdevRef.
1161 *
1162 * The BlockdevRef will be removed from the options QDict.
1163 */
1164int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1165 QDict *options, const char *bdref_key, int flags,
1166 bool force_raw, bool allow_none, Error **errp)
1167{
1168 QDict *image_options;
1169 int ret;
1170 char *bdref_key_dot;
1171 const char *reference;
1172
1173 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1174 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1175 g_free(bdref_key_dot);
1176
1177 reference = qdict_get_try_str(options, bdref_key);
1178 if (!filename && !reference && !qdict_size(image_options)) {
1179 if (allow_none) {
1180 ret = 0;
1181 } else {
1182 error_setg(errp, "A block device must be specified for \"%s\"",
1183 bdref_key);
1184 ret = -EINVAL;
1185 }
1186 goto done;
1187 }
1188
1189 if (filename && !force_raw) {
1190 /* If a filename is given and the block driver should be detected
1191 automatically (instead of using none), use bdrv_open() in order to do
1192 that auto-detection. */
1193 BlockDriverState *bs;
1194
1195 if (reference) {
1196 error_setg(errp, "Cannot reference an existing block device while "
1197 "giving a filename");
1198 ret = -EINVAL;
1199 goto done;
1200 }
1201
1202 bs = bdrv_new("");
1203 ret = bdrv_open(bs, filename, image_options, flags, NULL, errp);
1204 if (ret < 0) {
1205 bdrv_unref(bs);
1206 } else {
1207 *pbs = bs;
1208 }
1209 } else {
1210 ret = bdrv_file_open(pbs, filename, reference, image_options, flags,
1211 errp);
1212 }
1213
1214done:
1215 qdict_del(options, bdref_key);
1216 return ret;
1217}
1218
1219/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001220 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001221 *
1222 * options is a QDict of options to pass to the block drivers, or NULL for an
1223 * empty set of options. The reference to the QDict belongs to the block layer
1224 * after the call (even on failure), so if the caller intends to reuse the
1225 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001226 */
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001227int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001228 int flags, BlockDriver *drv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001229{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001230 int ret;
Stefan Weil89c9bc32012-11-22 07:25:48 +01001231 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1232 char tmp_filename[PATH_MAX + 1];
Kevin Wolff500a6d2012-11-12 17:35:27 +01001233 BlockDriverState *file = NULL;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001234 const char *drvname;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001235 Error *local_err = NULL;
bellard712e7872005-04-28 21:09:32 +00001236
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001237 /* NULL means an empty set of options */
1238 if (options == NULL) {
1239 options = qdict_new();
1240 }
1241
1242 bs->options = options;
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001243 options = qdict_clone_shallow(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001244
1245 /* For snapshot=on, create a temporary qcow2 overlay */
bellard83f64092006-08-01 16:21:11 +00001246 if (flags & BDRV_O_SNAPSHOT) {
bellardea2384d2004-08-01 21:59:26 +00001247 BlockDriverState *bs1;
1248 int64_t total_size;
Kevin Wolf91a073a2009-05-27 14:48:06 +02001249 BlockDriver *bdrv_qcow2;
Kevin Wolf08b392e2013-03-18 16:17:44 +01001250 QEMUOptionParameter *create_options;
Kevin Wolf9fd31712013-11-14 15:37:12 +01001251 QDict *snapshot_options;
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001252
bellardea2384d2004-08-01 21:59:26 +00001253 /* if snapshot, we create a temporary backing file and open it
1254 instead of opening 'filename' directly */
1255
Kevin Wolf9fd31712013-11-14 15:37:12 +01001256 /* Get the required size from the image */
bellardea2384d2004-08-01 21:59:26 +00001257 bs1 = bdrv_new("");
Kevin Wolf9fd31712013-11-14 15:37:12 +01001258 QINCREF(options);
Kevin Wolfc9fbb992013-11-28 11:58:02 +01001259 ret = bdrv_open(bs1, filename, options, BDRV_O_NO_BACKING,
1260 drv, &local_err);
aliguori51d7c002009-03-05 23:00:29 +00001261 if (ret < 0) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001262 bdrv_unref(bs1);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001263 goto fail;
bellardea2384d2004-08-01 21:59:26 +00001264 }
Jes Sorensen3e829902010-05-27 16:20:30 +02001265 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
aliguori7c96d462008-09-12 17:54:13 +00001266
Fam Zheng4f6fd342013-08-23 09:14:47 +08001267 bdrv_unref(bs1);
ths3b46e622007-09-17 08:09:54 +00001268
Kevin Wolf9fd31712013-11-14 15:37:12 +01001269 /* Create the temporary image */
Jim Meyeringeba25052012-05-28 09:27:54 +02001270 ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));
1271 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001272 error_setg_errno(errp, -ret, "Could not get temporary filename");
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001273 goto fail;
Jim Meyeringeba25052012-05-28 09:27:54 +02001274 }
aliguori7c96d462008-09-12 17:54:13 +00001275
Kevin Wolf91a073a2009-05-27 14:48:06 +02001276 bdrv_qcow2 = bdrv_find_format("qcow2");
Kevin Wolf08b392e2013-03-18 16:17:44 +01001277 create_options = parse_option_parameters("", bdrv_qcow2->create_options,
1278 NULL);
Kevin Wolf91a073a2009-05-27 14:48:06 +02001279
Kevin Wolf08b392e2013-03-18 16:17:44 +01001280 set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
Kevin Wolf91a073a2009-05-27 14:48:06 +02001281
Max Reitzcc84d902013-09-06 17:14:26 +02001282 ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);
Kevin Wolf08b392e2013-03-18 16:17:44 +01001283 free_option_parameters(create_options);
aliguori51d7c002009-03-05 23:00:29 +00001284 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001285 error_setg_errno(errp, -ret, "Could not create temporary overlay "
Max Reitzcc84d902013-09-06 17:14:26 +02001286 "'%s': %s", tmp_filename,
1287 error_get_pretty(local_err));
1288 error_free(local_err);
1289 local_err = NULL;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001290 goto fail;
bellardea2384d2004-08-01 21:59:26 +00001291 }
Kevin Wolf91a073a2009-05-27 14:48:06 +02001292
Kevin Wolf9fd31712013-11-14 15:37:12 +01001293 /* Prepare a new options QDict for the temporary file, where user
1294 * options refer to the backing file */
1295 if (filename) {
1296 qdict_put(options, "file.filename", qstring_from_str(filename));
1297 }
1298 if (drv) {
1299 qdict_put(options, "driver", qstring_from_str(drv->format_name));
1300 }
1301
1302 snapshot_options = qdict_new();
1303 qdict_put(snapshot_options, "backing", options);
1304 qdict_flatten(snapshot_options);
1305
1306 bs->options = snapshot_options;
1307 options = qdict_clone_shallow(bs->options);
1308
bellardea2384d2004-08-01 21:59:26 +00001309 filename = tmp_filename;
Kevin Wolf91a073a2009-05-27 14:48:06 +02001310 drv = bdrv_qcow2;
bellardea2384d2004-08-01 21:59:26 +00001311 bs->is_temporary = 1;
1312 }
bellard712e7872005-04-28 21:09:32 +00001313
Kevin Wolff500a6d2012-11-12 17:35:27 +01001314 /* Open image file without format layer */
Jeff Codybe028ad2012-09-20 15:13:17 -04001315 if (flags & BDRV_O_RDWR) {
1316 flags |= BDRV_O_ALLOW_RDWR;
1317 }
1318
Max Reitz054963f2013-12-20 19:28:12 +01001319 ret = bdrv_open_image(&file, filename, options, "file",
1320 bdrv_open_flags(bs, flags | BDRV_O_UNMAP), true, true,
1321 &local_err);
1322 if (ret < 0) {
1323 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001324 }
1325
1326 /* Find the right image format driver */
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001327 drvname = qdict_get_try_str(options, "driver");
1328 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +02001329 drv = bdrv_find_format(drvname);
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001330 qdict_del(options, "driver");
Kevin Wolf06d22aa2013-08-08 17:44:52 +02001331 if (!drv) {
1332 error_setg(errp, "Invalid driver: '%s'", drvname);
1333 ret = -EINVAL;
1334 goto unlink_and_fail;
1335 }
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001336 }
1337
Kevin Wolff500a6d2012-11-12 17:35:27 +01001338 if (!drv) {
Max Reitz2a05cbe2013-12-20 19:28:10 +01001339 if (file) {
1340 ret = find_image_format(file, filename, &drv, &local_err);
1341 } else {
1342 error_setg(errp, "Must specify either driver or file");
1343 ret = -EINVAL;
1344 goto unlink_and_fail;
1345 }
Kevin Wolff500a6d2012-11-12 17:35:27 +01001346 }
1347
1348 if (!drv) {
1349 goto unlink_and_fail;
1350 }
1351
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001352 /* Open the image */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001353 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001354 if (ret < 0) {
Christoph Hellwig69873072010-01-20 18:13:25 +01001355 goto unlink_and_fail;
1356 }
1357
Max Reitz2a05cbe2013-12-20 19:28:10 +01001358 if (file && (bs->file != file)) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001359 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001360 file = NULL;
1361 }
1362
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001363 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001364 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001365 QDict *backing_options;
1366
Benoît Canet5726d872013-09-25 13:30:01 +02001367 qdict_extract_subqdict(options, &backing_options, "backing.");
Max Reitz34b5d2c2013-09-05 14:45:29 +02001368 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001369 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001370 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001371 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001372 }
1373
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001374 /* Check if any unknown options were used */
1375 if (qdict_size(options) != 0) {
1376 const QDictEntry *entry = qdict_first(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001377 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1378 "support the option '%s'", drv->format_name, bs->device_name,
1379 entry->key);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001380
1381 ret = -EINVAL;
1382 goto close_and_fail;
1383 }
1384 QDECREF(options);
1385
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001386 if (!bdrv_key_required(bs)) {
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001387 bdrv_dev_change_media_cb(bs, true);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001388 }
1389
1390 return 0;
1391
1392unlink_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001393 if (file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001394 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001395 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001396 if (bs->is_temporary) {
1397 unlink(filename);
1398 }
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001399fail:
1400 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001401 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001402 bs->options = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001403 if (error_is_set(&local_err)) {
1404 error_propagate(errp, local_err);
1405 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001406 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001407
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001408close_and_fail:
1409 bdrv_close(bs);
1410 QDECREF(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001411 if (error_is_set(&local_err)) {
1412 error_propagate(errp, local_err);
1413 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001414 return ret;
1415}
1416
Jeff Codye971aa12012-09-20 15:13:19 -04001417typedef struct BlockReopenQueueEntry {
1418 bool prepared;
1419 BDRVReopenState state;
1420 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1421} BlockReopenQueueEntry;
1422
1423/*
1424 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1425 * reopen of multiple devices.
1426 *
1427 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1428 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1429 * be created and initialized. This newly created BlockReopenQueue should be
1430 * passed back in for subsequent calls that are intended to be of the same
1431 * atomic 'set'.
1432 *
1433 * bs is the BlockDriverState to add to the reopen queue.
1434 *
1435 * flags contains the open flags for the associated bs
1436 *
1437 * returns a pointer to bs_queue, which is either the newly allocated
1438 * bs_queue, or the existing bs_queue being used.
1439 *
1440 */
1441BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1442 BlockDriverState *bs, int flags)
1443{
1444 assert(bs != NULL);
1445
1446 BlockReopenQueueEntry *bs_entry;
1447 if (bs_queue == NULL) {
1448 bs_queue = g_new0(BlockReopenQueue, 1);
1449 QSIMPLEQ_INIT(bs_queue);
1450 }
1451
1452 if (bs->file) {
1453 bdrv_reopen_queue(bs_queue, bs->file, flags);
1454 }
1455
1456 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1457 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1458
1459 bs_entry->state.bs = bs;
1460 bs_entry->state.flags = flags;
1461
1462 return bs_queue;
1463}
1464
1465/*
1466 * Reopen multiple BlockDriverStates atomically & transactionally.
1467 *
1468 * The queue passed in (bs_queue) must have been built up previous
1469 * via bdrv_reopen_queue().
1470 *
1471 * Reopens all BDS specified in the queue, with the appropriate
1472 * flags. All devices are prepared for reopen, and failure of any
1473 * device will cause all device changes to be abandonded, and intermediate
1474 * data cleaned up.
1475 *
1476 * If all devices prepare successfully, then the changes are committed
1477 * to all devices.
1478 *
1479 */
1480int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1481{
1482 int ret = -1;
1483 BlockReopenQueueEntry *bs_entry, *next;
1484 Error *local_err = NULL;
1485
1486 assert(bs_queue != NULL);
1487
1488 bdrv_drain_all();
1489
1490 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1491 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1492 error_propagate(errp, local_err);
1493 goto cleanup;
1494 }
1495 bs_entry->prepared = true;
1496 }
1497
1498 /* If we reach this point, we have success and just need to apply the
1499 * changes
1500 */
1501 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1502 bdrv_reopen_commit(&bs_entry->state);
1503 }
1504
1505 ret = 0;
1506
1507cleanup:
1508 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1509 if (ret && bs_entry->prepared) {
1510 bdrv_reopen_abort(&bs_entry->state);
1511 }
1512 g_free(bs_entry);
1513 }
1514 g_free(bs_queue);
1515 return ret;
1516}
1517
1518
1519/* Reopen a single BlockDriverState with the specified flags. */
1520int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1521{
1522 int ret = -1;
1523 Error *local_err = NULL;
1524 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1525
1526 ret = bdrv_reopen_multiple(queue, &local_err);
1527 if (local_err != NULL) {
1528 error_propagate(errp, local_err);
1529 }
1530 return ret;
1531}
1532
1533
1534/*
1535 * Prepares a BlockDriverState for reopen. All changes are staged in the
1536 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1537 * the block driver layer .bdrv_reopen_prepare()
1538 *
1539 * bs is the BlockDriverState to reopen
1540 * flags are the new open flags
1541 * queue is the reopen queue
1542 *
1543 * Returns 0 on success, non-zero on error. On error errp will be set
1544 * as well.
1545 *
1546 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1547 * It is the responsibility of the caller to then call the abort() or
1548 * commit() for any other BDS that have been left in a prepare() state
1549 *
1550 */
1551int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1552 Error **errp)
1553{
1554 int ret = -1;
1555 Error *local_err = NULL;
1556 BlockDriver *drv;
1557
1558 assert(reopen_state != NULL);
1559 assert(reopen_state->bs->drv != NULL);
1560 drv = reopen_state->bs->drv;
1561
1562 /* if we are to stay read-only, do not allow permission change
1563 * to r/w */
1564 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1565 reopen_state->flags & BDRV_O_RDWR) {
1566 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1567 reopen_state->bs->device_name);
1568 goto error;
1569 }
1570
1571
1572 ret = bdrv_flush(reopen_state->bs);
1573 if (ret) {
1574 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1575 strerror(-ret));
1576 goto error;
1577 }
1578
1579 if (drv->bdrv_reopen_prepare) {
1580 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1581 if (ret) {
1582 if (local_err != NULL) {
1583 error_propagate(errp, local_err);
1584 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04001585 error_setg(errp, "failed while preparing to reopen image '%s'",
1586 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04001587 }
1588 goto error;
1589 }
1590 } else {
1591 /* It is currently mandatory to have a bdrv_reopen_prepare()
1592 * handler for each supported drv. */
1593 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1594 drv->format_name, reopen_state->bs->device_name,
1595 "reopening of file");
1596 ret = -1;
1597 goto error;
1598 }
1599
1600 ret = 0;
1601
1602error:
1603 return ret;
1604}
1605
1606/*
1607 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1608 * makes them final by swapping the staging BlockDriverState contents into
1609 * the active BlockDriverState contents.
1610 */
1611void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1612{
1613 BlockDriver *drv;
1614
1615 assert(reopen_state != NULL);
1616 drv = reopen_state->bs->drv;
1617 assert(drv != NULL);
1618
1619 /* If there are any driver level actions to take */
1620 if (drv->bdrv_reopen_commit) {
1621 drv->bdrv_reopen_commit(reopen_state);
1622 }
1623
1624 /* set BDS specific flags now */
1625 reopen_state->bs->open_flags = reopen_state->flags;
1626 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1627 BDRV_O_CACHE_WB);
1628 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf355ef4a2013-12-11 20:14:09 +01001629
1630 bdrv_refresh_limits(reopen_state->bs);
Jeff Codye971aa12012-09-20 15:13:19 -04001631}
1632
1633/*
1634 * Abort the reopen, and delete and free the staged changes in
1635 * reopen_state
1636 */
1637void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1638{
1639 BlockDriver *drv;
1640
1641 assert(reopen_state != NULL);
1642 drv = reopen_state->bs->drv;
1643 assert(drv != NULL);
1644
1645 if (drv->bdrv_reopen_abort) {
1646 drv->bdrv_reopen_abort(reopen_state);
1647 }
1648}
1649
1650
bellardfc01f7e2003-06-30 10:03:06 +00001651void bdrv_close(BlockDriverState *bs)
1652{
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001653 if (bs->job) {
1654 block_job_cancel_sync(bs->job);
1655 }
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02001656 bdrv_drain_all(); /* complete I/O */
1657 bdrv_flush(bs);
1658 bdrv_drain_all(); /* in case flush left pending I/O */
Paolo Bonzinid7d512f2012-08-23 11:20:36 +02001659 notifier_list_notify(&bs->close_notifiers, bs);
Kevin Wolf7094f122012-04-11 11:06:37 +02001660
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001661 if (bs->drv) {
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001662 if (bs->backing_hd) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001663 bdrv_unref(bs->backing_hd);
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001664 bs->backing_hd = NULL;
1665 }
bellardea2384d2004-08-01 21:59:26 +00001666 bs->drv->bdrv_close(bs);
Anthony Liguori7267c092011-08-20 22:09:37 -05001667 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00001668#ifdef _WIN32
1669 if (bs->is_temporary) {
1670 unlink(bs->filename);
1671 }
bellard67b915a2004-03-31 23:37:16 +00001672#endif
bellardea2384d2004-08-01 21:59:26 +00001673 bs->opaque = NULL;
1674 bs->drv = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001675 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02001676 bs->backing_file[0] = '\0';
1677 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02001678 bs->total_sectors = 0;
1679 bs->encrypted = 0;
1680 bs->valid_key = 0;
1681 bs->sg = 0;
1682 bs->growable = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08001683 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001684 QDECREF(bs->options);
1685 bs->options = NULL;
bellardb3380822004-03-14 21:38:54 +00001686
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001687 if (bs->file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001688 bdrv_unref(bs->file);
Paolo Bonzini0ac93772012-05-08 16:51:44 +02001689 bs->file = NULL;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001690 }
bellardb3380822004-03-14 21:38:54 +00001691 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001692
Pavel Hrdina9ca11152012-08-09 12:44:48 +02001693 bdrv_dev_change_media_cb(bs, false);
1694
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001695 /*throttling disk I/O limits*/
1696 if (bs->io_limits_enabled) {
1697 bdrv_io_limits_disable(bs);
1698 }
bellardb3380822004-03-14 21:38:54 +00001699}
1700
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001701void bdrv_close_all(void)
1702{
1703 BlockDriverState *bs;
1704
Benoît Canetdc364f42014-01-23 21:31:32 +01001705 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001706 bdrv_close(bs);
1707 }
1708}
1709
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001710/* Check if any requests are in-flight (including throttled requests) */
1711static bool bdrv_requests_pending(BlockDriverState *bs)
1712{
1713 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1714 return true;
1715 }
Benoît Canetcc0681c2013-09-02 14:14:39 +02001716 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1717 return true;
1718 }
1719 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001720 return true;
1721 }
1722 if (bs->file && bdrv_requests_pending(bs->file)) {
1723 return true;
1724 }
1725 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1726 return true;
1727 }
1728 return false;
1729}
1730
1731static bool bdrv_requests_pending_all(void)
1732{
1733 BlockDriverState *bs;
Benoît Canetdc364f42014-01-23 21:31:32 +01001734 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001735 if (bdrv_requests_pending(bs)) {
1736 return true;
1737 }
1738 }
1739 return false;
1740}
1741
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001742/*
1743 * Wait for pending requests to complete across all BlockDriverStates
1744 *
1745 * This function does not flush data to disk, use bdrv_flush_all() for that
1746 * after calling this function.
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001747 *
1748 * Note that completion of an asynchronous I/O operation can trigger any
1749 * number of other I/O operations on other devices---for example a coroutine
1750 * can be arbitrarily complex and a constant flow of I/O can come until the
1751 * coroutine is complete. Because of this, it is not possible to have a
1752 * function to drain a single device's I/O queue.
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001753 */
1754void bdrv_drain_all(void)
1755{
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001756 /* Always run first iteration so any pending completion BHs run */
1757 bool busy = true;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001758 BlockDriverState *bs;
1759
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001760 while (busy) {
Benoît Canetdc364f42014-01-23 21:31:32 +01001761 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczi0b06ef32013-11-26 16:18:00 +01001762 bdrv_start_throttled_reqs(bs);
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001763 }
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001764
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001765 busy = bdrv_requests_pending_all();
1766 busy |= aio_poll(qemu_get_aio_context(), busy);
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001767 }
1768}
1769
Benoît Canetdc364f42014-01-23 21:31:32 +01001770/* make a BlockDriverState anonymous by removing from bdrv_state and
1771 * graph_bdrv_state list.
Ryan Harperd22b2f42011-03-29 20:51:47 -05001772 Also, NULL terminate the device_name to prevent double remove */
1773void bdrv_make_anon(BlockDriverState *bs)
1774{
1775 if (bs->device_name[0] != '\0') {
Benoît Canetdc364f42014-01-23 21:31:32 +01001776 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
Ryan Harperd22b2f42011-03-29 20:51:47 -05001777 }
1778 bs->device_name[0] = '\0';
Benoît Canetdc364f42014-01-23 21:31:32 +01001779 if (bs->node_name[0] != '\0') {
1780 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1781 }
1782 bs->node_name[0] = '\0';
Ryan Harperd22b2f42011-03-29 20:51:47 -05001783}
1784
Paolo Bonzinie023b2e2012-05-08 16:51:41 +02001785static void bdrv_rebind(BlockDriverState *bs)
1786{
1787 if (bs->drv && bs->drv->bdrv_rebind) {
1788 bs->drv->bdrv_rebind(bs);
1789 }
1790}
1791
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001792static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1793 BlockDriverState *bs_src)
1794{
1795 /* move some fields that need to stay attached to the device */
1796 bs_dest->open_flags = bs_src->open_flags;
1797
1798 /* dev info */
1799 bs_dest->dev_ops = bs_src->dev_ops;
1800 bs_dest->dev_opaque = bs_src->dev_opaque;
1801 bs_dest->dev = bs_src->dev;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01001802 bs_dest->guest_block_size = bs_src->guest_block_size;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001803 bs_dest->copy_on_read = bs_src->copy_on_read;
1804
1805 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1806
Benoît Canetcc0681c2013-09-02 14:14:39 +02001807 /* i/o throttled req */
1808 memcpy(&bs_dest->throttle_state,
1809 &bs_src->throttle_state,
1810 sizeof(ThrottleState));
1811 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1812 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001813 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1814
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001815 /* r/w error */
1816 bs_dest->on_read_error = bs_src->on_read_error;
1817 bs_dest->on_write_error = bs_src->on_write_error;
1818
1819 /* i/o status */
1820 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1821 bs_dest->iostatus = bs_src->iostatus;
1822
1823 /* dirty bitmap */
Fam Zhenge4654d22013-11-13 18:29:43 +08001824 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001825
Fam Zheng9fcb0252013-08-23 09:14:46 +08001826 /* reference count */
1827 bs_dest->refcnt = bs_src->refcnt;
1828
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001829 /* job */
1830 bs_dest->in_use = bs_src->in_use;
1831 bs_dest->job = bs_src->job;
1832
1833 /* keep the same entry in bdrv_states */
1834 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1835 bs_src->device_name);
Benoît Canetdc364f42014-01-23 21:31:32 +01001836 bs_dest->device_list = bs_src->device_list;
1837
1838 /* keep the same entry in graph_bdrv_states
1839 * We do want to swap name but don't want to swap linked list entries
1840 */
1841 bs_dest->node_list = bs_src->node_list;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001842}
1843
1844/*
1845 * Swap bs contents for two image chains while they are live,
1846 * while keeping required fields on the BlockDriverState that is
1847 * actually attached to a device.
1848 *
1849 * This will modify the BlockDriverState fields, and swap contents
1850 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1851 *
1852 * bs_new is required to be anonymous.
1853 *
1854 * This function does not create any image files.
1855 */
1856void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
1857{
1858 BlockDriverState tmp;
1859
1860 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1861 assert(bs_new->device_name[0] == '\0');
Fam Zhenge4654d22013-11-13 18:29:43 +08001862 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001863 assert(bs_new->job == NULL);
1864 assert(bs_new->dev == NULL);
1865 assert(bs_new->in_use == 0);
1866 assert(bs_new->io_limits_enabled == false);
Benoît Canetcc0681c2013-09-02 14:14:39 +02001867 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001868
1869 tmp = *bs_new;
1870 *bs_new = *bs_old;
1871 *bs_old = tmp;
1872
1873 /* there are some fields that should not be swapped, move them back */
1874 bdrv_move_feature_fields(&tmp, bs_old);
1875 bdrv_move_feature_fields(bs_old, bs_new);
1876 bdrv_move_feature_fields(bs_new, &tmp);
1877
1878 /* bs_new shouldn't be in bdrv_states even after the swap! */
1879 assert(bs_new->device_name[0] == '\0');
1880
1881 /* Check a few fields that should remain attached to the device */
1882 assert(bs_new->dev == NULL);
1883 assert(bs_new->job == NULL);
1884 assert(bs_new->in_use == 0);
1885 assert(bs_new->io_limits_enabled == false);
Benoît Canetcc0681c2013-09-02 14:14:39 +02001886 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001887
1888 bdrv_rebind(bs_new);
1889 bdrv_rebind(bs_old);
1890}
1891
Jeff Cody8802d1f2012-02-28 15:54:06 -05001892/*
1893 * Add new bs contents at the top of an image chain while the chain is
1894 * live, while keeping required fields on the top layer.
1895 *
1896 * This will modify the BlockDriverState fields, and swap contents
1897 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1898 *
Jeff Codyf6801b82012-03-27 16:30:19 -04001899 * bs_new is required to be anonymous.
1900 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05001901 * This function does not create any image files.
1902 */
1903void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
1904{
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001905 bdrv_swap(bs_new, bs_top);
Jeff Cody8802d1f2012-02-28 15:54:06 -05001906
1907 /* The contents of 'tmp' will become bs_top, as we are
1908 * swapping bs_new and bs_top contents. */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001909 bs_top->backing_hd = bs_new;
1910 bs_top->open_flags &= ~BDRV_O_NO_BACKING;
1911 pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
1912 bs_new->filename);
1913 pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
1914 bs_new->drv ? bs_new->drv->format_name : "");
Jeff Cody8802d1f2012-02-28 15:54:06 -05001915}
1916
Fam Zheng4f6fd342013-08-23 09:14:47 +08001917static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00001918{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001919 assert(!bs->dev);
Paolo Bonzini3e914652012-03-30 13:17:11 +02001920 assert(!bs->job);
1921 assert(!bs->in_use);
Fam Zheng4f6fd342013-08-23 09:14:47 +08001922 assert(!bs->refcnt);
Fam Zhenge4654d22013-11-13 18:29:43 +08001923 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Markus Armbruster18846de2010-06-29 16:58:30 +02001924
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02001925 bdrv_close(bs);
1926
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01001927 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05001928 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00001929
Anthony Liguori7267c092011-08-20 22:09:37 -05001930 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00001931}
1932
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001933int bdrv_attach_dev(BlockDriverState *bs, void *dev)
1934/* TODO change to DeviceState *dev when all users are qdevified */
Markus Armbruster18846de2010-06-29 16:58:30 +02001935{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001936 if (bs->dev) {
Markus Armbruster18846de2010-06-29 16:58:30 +02001937 return -EBUSY;
1938 }
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001939 bs->dev = dev;
Luiz Capitulino28a72822011-09-26 17:43:50 -03001940 bdrv_iostatus_reset(bs);
Markus Armbruster18846de2010-06-29 16:58:30 +02001941 return 0;
1942}
1943
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001944/* TODO qdevified devices don't use this, remove when devices are qdevified */
1945void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
Markus Armbruster18846de2010-06-29 16:58:30 +02001946{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001947 if (bdrv_attach_dev(bs, dev) < 0) {
1948 abort();
1949 }
1950}
1951
1952void bdrv_detach_dev(BlockDriverState *bs, void *dev)
1953/* TODO change to DeviceState *dev when all users are qdevified */
1954{
1955 assert(bs->dev == dev);
1956 bs->dev = NULL;
Markus Armbruster0e49de52011-08-03 15:07:41 +02001957 bs->dev_ops = NULL;
1958 bs->dev_opaque = NULL;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01001959 bs->guest_block_size = 512;
Markus Armbruster18846de2010-06-29 16:58:30 +02001960}
1961
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001962/* TODO change to return DeviceState * when all users are qdevified */
1963void *bdrv_get_attached_dev(BlockDriverState *bs)
Markus Armbruster18846de2010-06-29 16:58:30 +02001964{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001965 return bs->dev;
Markus Armbruster18846de2010-06-29 16:58:30 +02001966}
1967
Markus Armbruster0e49de52011-08-03 15:07:41 +02001968void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
1969 void *opaque)
1970{
1971 bs->dev_ops = ops;
1972 bs->dev_opaque = opaque;
1973}
1974
Paolo Bonzini32c81a42012-09-28 17:22:58 +02001975void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
1976 enum MonitorEvent ev,
1977 BlockErrorAction action, bool is_read)
Luiz Capitulino329c0a42012-01-25 16:59:43 -02001978{
1979 QObject *data;
1980 const char *action_str;
1981
1982 switch (action) {
1983 case BDRV_ACTION_REPORT:
1984 action_str = "report";
1985 break;
1986 case BDRV_ACTION_IGNORE:
1987 action_str = "ignore";
1988 break;
1989 case BDRV_ACTION_STOP:
1990 action_str = "stop";
1991 break;
1992 default:
1993 abort();
1994 }
1995
1996 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1997 bdrv->device_name,
1998 action_str,
1999 is_read ? "read" : "write");
Paolo Bonzini32c81a42012-09-28 17:22:58 +02002000 monitor_protocol_event(ev, data);
Luiz Capitulino329c0a42012-01-25 16:59:43 -02002001
2002 qobject_decref(data);
2003}
2004
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002005static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
2006{
2007 QObject *data;
2008
2009 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
2010 bdrv_get_device_name(bs), ejected);
2011 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
2012
2013 qobject_decref(data);
2014}
2015
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002016static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
Markus Armbruster0e49de52011-08-03 15:07:41 +02002017{
Markus Armbruster145feb12011-08-03 15:07:42 +02002018 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002019 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002020 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002021 if (tray_was_closed) {
2022 /* tray open */
2023 bdrv_emit_qmp_eject_event(bs, true);
2024 }
2025 if (load) {
2026 /* tray close */
2027 bdrv_emit_qmp_eject_event(bs, false);
2028 }
Markus Armbruster145feb12011-08-03 15:07:42 +02002029 }
2030}
2031
Markus Armbruster2c6942f2011-09-06 18:58:51 +02002032bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2033{
2034 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2035}
2036
Paolo Bonzini025ccaa2011-11-07 17:50:13 +01002037void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2038{
2039 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2040 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2041 }
2042}
2043
Markus Armbrustere4def802011-09-06 18:58:53 +02002044bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2045{
2046 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2047 return bs->dev_ops->is_tray_open(bs->dev_opaque);
2048 }
2049 return false;
2050}
2051
Markus Armbruster145feb12011-08-03 15:07:42 +02002052static void bdrv_dev_resize_cb(BlockDriverState *bs)
2053{
2054 if (bs->dev_ops && bs->dev_ops->resize_cb) {
2055 bs->dev_ops->resize_cb(bs->dev_opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +02002056 }
2057}
2058
Markus Armbrusterf1076392011-09-06 18:58:46 +02002059bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2060{
2061 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2062 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2063 }
2064 return false;
2065}
2066
aliguorie97fc192009-04-21 23:11:50 +00002067/*
2068 * Run consistency checks on an image
2069 *
Kevin Wolfe076f332010-06-29 11:43:13 +02002070 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02002071 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02002072 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00002073 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02002074int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00002075{
2076 if (bs->drv->bdrv_check == NULL) {
2077 return -ENOTSUP;
2078 }
2079
Kevin Wolfe076f332010-06-29 11:43:13 +02002080 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02002081 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00002082}
2083
Kevin Wolf8a426612010-07-16 17:17:01 +02002084#define COMMIT_BUF_SECTORS 2048
2085
bellard33e39632003-07-06 17:15:21 +00002086/* commit COW file into the raw image */
2087int bdrv_commit(BlockDriverState *bs)
2088{
bellard19cb3732006-08-19 11:45:59 +00002089 BlockDriver *drv = bs->drv;
Jeff Cody72706ea2014-01-24 09:02:35 -05002090 int64_t sector, total_sectors, length, backing_length;
Kevin Wolf8a426612010-07-16 17:17:01 +02002091 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04002092 int ret = 0;
Jeff Cody72706ea2014-01-24 09:02:35 -05002093 uint8_t *buf = NULL;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02002094 char filename[PATH_MAX];
bellard33e39632003-07-06 17:15:21 +00002095
bellard19cb3732006-08-19 11:45:59 +00002096 if (!drv)
2097 return -ENOMEDIUM;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002098
2099 if (!bs->backing_hd) {
2100 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00002101 }
2102
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00002103 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
2104 return -EBUSY;
2105 }
2106
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002107 ro = bs->backing_hd->read_only;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02002108 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2109 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002110 open_flags = bs->backing_hd->open_flags;
2111
2112 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002113 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2114 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002115 }
bellard33e39632003-07-06 17:15:21 +00002116 }
bellardea2384d2004-08-01 21:59:26 +00002117
Jeff Cody72706ea2014-01-24 09:02:35 -05002118 length = bdrv_getlength(bs);
2119 if (length < 0) {
2120 ret = length;
2121 goto ro_cleanup;
2122 }
2123
2124 backing_length = bdrv_getlength(bs->backing_hd);
2125 if (backing_length < 0) {
2126 ret = backing_length;
2127 goto ro_cleanup;
2128 }
2129
2130 /* If our top snapshot is larger than the backing file image,
2131 * grow the backing file image if possible. If not possible,
2132 * we must return an error */
2133 if (length > backing_length) {
2134 ret = bdrv_truncate(bs->backing_hd, length);
2135 if (ret < 0) {
2136 goto ro_cleanup;
2137 }
2138 }
2139
2140 total_sectors = length >> BDRV_SECTOR_BITS;
Anthony Liguori7267c092011-08-20 22:09:37 -05002141 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
bellardea2384d2004-08-01 21:59:26 +00002142
Kevin Wolf8a426612010-07-16 17:17:01 +02002143 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02002144 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2145 if (ret < 0) {
2146 goto ro_cleanup;
2147 }
2148 if (ret) {
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002149 ret = bdrv_read(bs, sector, buf, n);
2150 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002151 goto ro_cleanup;
2152 }
2153
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002154 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2155 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002156 goto ro_cleanup;
2157 }
bellardea2384d2004-08-01 21:59:26 +00002158 }
2159 }
bellard95389c82005-12-18 18:28:15 +00002160
Christoph Hellwig1d449522010-01-17 12:32:30 +01002161 if (drv->bdrv_make_empty) {
2162 ret = drv->bdrv_make_empty(bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002163 if (ret < 0) {
2164 goto ro_cleanup;
2165 }
Christoph Hellwig1d449522010-01-17 12:32:30 +01002166 bdrv_flush(bs);
2167 }
bellard95389c82005-12-18 18:28:15 +00002168
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002169 /*
2170 * Make sure all data we wrote to the backing device is actually
2171 * stable on disk.
2172 */
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002173 if (bs->backing_hd) {
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002174 bdrv_flush(bs->backing_hd);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002175 }
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002176
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002177 ret = 0;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002178ro_cleanup:
Anthony Liguori7267c092011-08-20 22:09:37 -05002179 g_free(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002180
2181 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002182 /* ignoring error return here */
2183 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002184 }
2185
Christoph Hellwig1d449522010-01-17 12:32:30 +01002186 return ret;
bellard33e39632003-07-06 17:15:21 +00002187}
2188
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002189int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002190{
2191 BlockDriverState *bs;
2192
Benoît Canetdc364f42014-01-23 21:31:32 +01002193 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Jeff Cody272d2d82013-02-26 09:55:48 -05002194 if (bs->drv && bs->backing_hd) {
2195 int ret = bdrv_commit(bs);
2196 if (ret < 0) {
2197 return ret;
2198 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002199 }
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002200 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002201 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002202}
2203
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002204/**
2205 * Remove an active request from the tracked requests list
2206 *
2207 * This function should be called when a tracked request is completing.
2208 */
2209static void tracked_request_end(BdrvTrackedRequest *req)
2210{
2211 QLIST_REMOVE(req, list);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002212 qemu_co_queue_restart_all(&req->wait_queue);
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002213}
2214
2215/**
2216 * Add an active request to the tracked requests list
2217 */
2218static void tracked_request_begin(BdrvTrackedRequest *req,
2219 BlockDriverState *bs,
Kevin Wolf793ed472013-12-03 15:31:25 +01002220 int64_t offset,
2221 unsigned int bytes, bool is_write)
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002222{
2223 *req = (BdrvTrackedRequest){
2224 .bs = bs,
Kevin Wolf793ed472013-12-03 15:31:25 +01002225 .offset = offset,
2226 .bytes = bytes,
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002227 .is_write = is_write,
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00002228 .co = qemu_coroutine_self(),
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002229 };
2230
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002231 qemu_co_queue_init(&req->wait_queue);
2232
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002233 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2234}
2235
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002236/**
2237 * Round a region to cluster boundaries
2238 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002239void bdrv_round_to_clusters(BlockDriverState *bs,
2240 int64_t sector_num, int nb_sectors,
2241 int64_t *cluster_sector_num,
2242 int *cluster_nb_sectors)
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002243{
2244 BlockDriverInfo bdi;
2245
2246 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2247 *cluster_sector_num = sector_num;
2248 *cluster_nb_sectors = nb_sectors;
2249 } else {
2250 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2251 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2252 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2253 nb_sectors, c);
2254 }
2255}
2256
Kevin Wolf793ed472013-12-03 15:31:25 +01002257static void round_bytes_to_clusters(BlockDriverState *bs,
2258 int64_t offset, unsigned int bytes,
2259 int64_t *cluster_offset,
2260 unsigned int *cluster_bytes)
2261{
2262 BlockDriverInfo bdi;
2263
2264 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2265 *cluster_offset = offset;
2266 *cluster_bytes = bytes;
2267 } else {
2268 *cluster_offset = QEMU_ALIGN_DOWN(offset, bdi.cluster_size);
2269 *cluster_bytes = QEMU_ALIGN_UP(offset - *cluster_offset + bytes,
2270 bdi.cluster_size);
2271 }
2272}
2273
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002274static bool tracked_request_overlaps(BdrvTrackedRequest *req,
Kevin Wolf793ed472013-12-03 15:31:25 +01002275 int64_t offset, unsigned int bytes)
2276{
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002277 /* aaaa bbbb */
Kevin Wolf793ed472013-12-03 15:31:25 +01002278 if (offset >= req->offset + req->bytes) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002279 return false;
2280 }
2281 /* bbbb aaaa */
Kevin Wolf793ed472013-12-03 15:31:25 +01002282 if (req->offset >= offset + bytes) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002283 return false;
2284 }
2285 return true;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002286}
2287
2288static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01002289 BdrvTrackedRequest *self, int64_t offset, unsigned int bytes)
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002290{
2291 BdrvTrackedRequest *req;
Kevin Wolf793ed472013-12-03 15:31:25 +01002292 int64_t cluster_offset;
2293 unsigned int cluster_bytes;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002294 bool retry;
2295
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002296 /* If we touch the same cluster it counts as an overlap. This guarantees
2297 * that allocating writes will be serialized and not race with each other
2298 * for the same cluster. For example, in copy-on-read it ensures that the
2299 * CoR read and write operations are atomic and guest writes cannot
2300 * interleave between them.
2301 */
Kevin Wolf793ed472013-12-03 15:31:25 +01002302 round_bytes_to_clusters(bs, offset, bytes, &cluster_offset, &cluster_bytes);
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002303
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002304 do {
2305 retry = false;
2306 QLIST_FOREACH(req, &bs->tracked_requests, list) {
Kevin Wolf65afd212013-12-03 14:55:55 +01002307 if (req == self) {
2308 continue;
2309 }
Kevin Wolf793ed472013-12-03 15:31:25 +01002310 if (tracked_request_overlaps(req, cluster_offset, cluster_bytes)) {
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00002311 /* Hitting this means there was a reentrant request, for
2312 * example, a block driver issuing nested requests. This must
2313 * never happen since it means deadlock.
2314 */
2315 assert(qemu_coroutine_self() != req->co);
2316
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002317 qemu_co_queue_wait(&req->wait_queue);
2318 retry = true;
2319 break;
2320 }
2321 }
2322 } while (retry);
2323}
2324
Kevin Wolf756e6732010-01-12 12:55:17 +01002325/*
2326 * Return values:
2327 * 0 - success
2328 * -EINVAL - backing format specified, but no file
2329 * -ENOSPC - can't update the backing file because no space is left in the
2330 * image file header
2331 * -ENOTSUP - format driver doesn't support changing the backing file
2332 */
2333int bdrv_change_backing_file(BlockDriverState *bs,
2334 const char *backing_file, const char *backing_fmt)
2335{
2336 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002337 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002338
Paolo Bonzini5f377792012-04-12 14:01:01 +02002339 /* Backing file format doesn't make sense without a backing file */
2340 if (backing_fmt && !backing_file) {
2341 return -EINVAL;
2342 }
2343
Kevin Wolf756e6732010-01-12 12:55:17 +01002344 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002345 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002346 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002347 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002348 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002349
2350 if (ret == 0) {
2351 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2352 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2353 }
2354 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002355}
2356
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002357/*
2358 * Finds the image layer in the chain that has 'bs' as its backing file.
2359 *
2360 * active is the current topmost image.
2361 *
2362 * Returns NULL if bs is not found in active's image chain,
2363 * or if active == bs.
2364 */
2365BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2366 BlockDriverState *bs)
2367{
2368 BlockDriverState *overlay = NULL;
2369 BlockDriverState *intermediate;
2370
2371 assert(active != NULL);
2372 assert(bs != NULL);
2373
2374 /* if bs is the same as active, then by definition it has no overlay
2375 */
2376 if (active == bs) {
2377 return NULL;
2378 }
2379
2380 intermediate = active;
2381 while (intermediate->backing_hd) {
2382 if (intermediate->backing_hd == bs) {
2383 overlay = intermediate;
2384 break;
2385 }
2386 intermediate = intermediate->backing_hd;
2387 }
2388
2389 return overlay;
2390}
2391
2392typedef struct BlkIntermediateStates {
2393 BlockDriverState *bs;
2394 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2395} BlkIntermediateStates;
2396
2397
2398/*
2399 * Drops images above 'base' up to and including 'top', and sets the image
2400 * above 'top' to have base as its backing file.
2401 *
2402 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2403 * information in 'bs' can be properly updated.
2404 *
2405 * E.g., this will convert the following chain:
2406 * bottom <- base <- intermediate <- top <- active
2407 *
2408 * to
2409 *
2410 * bottom <- base <- active
2411 *
2412 * It is allowed for bottom==base, in which case it converts:
2413 *
2414 * base <- intermediate <- top <- active
2415 *
2416 * to
2417 *
2418 * base <- active
2419 *
2420 * Error conditions:
2421 * if active == top, that is considered an error
2422 *
2423 */
2424int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2425 BlockDriverState *base)
2426{
2427 BlockDriverState *intermediate;
2428 BlockDriverState *base_bs = NULL;
2429 BlockDriverState *new_top_bs = NULL;
2430 BlkIntermediateStates *intermediate_state, *next;
2431 int ret = -EIO;
2432
2433 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2434 QSIMPLEQ_INIT(&states_to_delete);
2435
2436 if (!top->drv || !base->drv) {
2437 goto exit;
2438 }
2439
2440 new_top_bs = bdrv_find_overlay(active, top);
2441
2442 if (new_top_bs == NULL) {
2443 /* we could not find the image above 'top', this is an error */
2444 goto exit;
2445 }
2446
2447 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2448 * to do, no intermediate images */
2449 if (new_top_bs->backing_hd == base) {
2450 ret = 0;
2451 goto exit;
2452 }
2453
2454 intermediate = top;
2455
2456 /* now we will go down through the list, and add each BDS we find
2457 * into our deletion queue, until we hit the 'base'
2458 */
2459 while (intermediate) {
2460 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2461 intermediate_state->bs = intermediate;
2462 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2463
2464 if (intermediate->backing_hd == base) {
2465 base_bs = intermediate->backing_hd;
2466 break;
2467 }
2468 intermediate = intermediate->backing_hd;
2469 }
2470 if (base_bs == NULL) {
2471 /* something went wrong, we did not end at the base. safely
2472 * unravel everything, and exit with error */
2473 goto exit;
2474 }
2475
2476 /* success - we can delete the intermediate states, and link top->base */
2477 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2478 base_bs->drv ? base_bs->drv->format_name : "");
2479 if (ret) {
2480 goto exit;
2481 }
2482 new_top_bs->backing_hd = base_bs;
2483
Kevin Wolf355ef4a2013-12-11 20:14:09 +01002484 bdrv_refresh_limits(new_top_bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002485
2486 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2487 /* so that bdrv_close() does not recursively close the chain */
2488 intermediate_state->bs->backing_hd = NULL;
Fam Zheng4f6fd342013-08-23 09:14:47 +08002489 bdrv_unref(intermediate_state->bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002490 }
2491 ret = 0;
2492
2493exit:
2494 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2495 g_free(intermediate_state);
2496 }
2497 return ret;
2498}
2499
2500
aliguori71d07702009-03-03 17:37:16 +00002501static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2502 size_t size)
2503{
2504 int64_t len;
2505
2506 if (!bdrv_is_inserted(bs))
2507 return -ENOMEDIUM;
2508
2509 if (bs->growable)
2510 return 0;
2511
2512 len = bdrv_getlength(bs);
2513
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02002514 if (offset < 0)
2515 return -EIO;
2516
2517 if ((offset > len) || (len - offset < size))
aliguori71d07702009-03-03 17:37:16 +00002518 return -EIO;
2519
2520 return 0;
2521}
2522
2523static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2524 int nb_sectors)
2525{
Jes Sorenseneb5a3162010-05-27 16:20:31 +02002526 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2527 nb_sectors * BDRV_SECTOR_SIZE);
aliguori71d07702009-03-03 17:37:16 +00002528}
2529
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002530typedef struct RwCo {
2531 BlockDriverState *bs;
2532 int64_t sector_num;
2533 int nb_sectors;
2534 QEMUIOVector *qiov;
2535 bool is_write;
2536 int ret;
Peter Lieven4105eaa2013-07-11 14:16:22 +02002537 BdrvRequestFlags flags;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002538} RwCo;
2539
2540static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2541{
2542 RwCo *rwco = opaque;
2543
2544 if (!rwco->is_write) {
2545 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002546 rwco->nb_sectors, rwco->qiov,
2547 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002548 } else {
2549 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002550 rwco->nb_sectors, rwco->qiov,
2551 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002552 }
2553}
2554
2555/*
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002556 * Process a vectored synchronous request using coroutines
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002557 */
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002558static int bdrv_rwv_co(BlockDriverState *bs, int64_t sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002559 QEMUIOVector *qiov, bool is_write,
2560 BdrvRequestFlags flags)
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002561{
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002562 Coroutine *co;
2563 RwCo rwco = {
2564 .bs = bs,
2565 .sector_num = sector_num,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002566 .nb_sectors = qiov->size >> BDRV_SECTOR_BITS,
2567 .qiov = qiov,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002568 .is_write = is_write,
2569 .ret = NOT_DONE,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002570 .flags = flags,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002571 };
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002572 assert((qiov->size & (BDRV_SECTOR_SIZE - 1)) == 0);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002573
Zhi Yong Wu498e3862012-04-02 18:59:34 +08002574 /**
2575 * In sync call context, when the vcpu is blocked, this throttling timer
2576 * will not fire; so the I/O throttling function has to be disabled here
2577 * if it has been enabled.
2578 */
2579 if (bs->io_limits_enabled) {
2580 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2581 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2582 bdrv_io_limits_disable(bs);
2583 }
2584
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002585 if (qemu_in_coroutine()) {
2586 /* Fast-path if already in coroutine context */
2587 bdrv_rw_co_entry(&rwco);
2588 } else {
2589 co = qemu_coroutine_create(bdrv_rw_co_entry);
2590 qemu_coroutine_enter(co, &rwco);
2591 while (rwco.ret == NOT_DONE) {
2592 qemu_aio_wait();
2593 }
2594 }
2595 return rwco.ret;
2596}
2597
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002598/*
2599 * Process a synchronous request using coroutines
2600 */
2601static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002602 int nb_sectors, bool is_write, BdrvRequestFlags flags)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002603{
2604 QEMUIOVector qiov;
2605 struct iovec iov = {
2606 .iov_base = (void *)buf,
2607 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2608 };
2609
2610 qemu_iovec_init_external(&qiov, &iov, 1);
Peter Lieven4105eaa2013-07-11 14:16:22 +02002611 return bdrv_rwv_co(bs, sector_num, &qiov, is_write, flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002612}
2613
bellard19cb3732006-08-19 11:45:59 +00002614/* return < 0 if error. See bdrv_write() for the return codes */
ths5fafdf22007-09-16 21:08:06 +00002615int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002616 uint8_t *buf, int nb_sectors)
2617{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002618 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
bellardfc01f7e2003-06-30 10:03:06 +00002619}
2620
Markus Armbruster07d27a42012-06-29 17:34:29 +02002621/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2622int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2623 uint8_t *buf, int nb_sectors)
2624{
2625 bool enabled;
2626 int ret;
2627
2628 enabled = bs->io_limits_enabled;
2629 bs->io_limits_enabled = false;
Peter Lieven4e7395e2013-07-18 10:37:32 +02002630 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
Markus Armbruster07d27a42012-06-29 17:34:29 +02002631 bs->io_limits_enabled = enabled;
2632 return ret;
2633}
2634
ths5fafdf22007-09-16 21:08:06 +00002635/* Return < 0 if error. Important errors are:
bellard19cb3732006-08-19 11:45:59 +00002636 -EIO generic I/O error (may happen for all errors)
2637 -ENOMEDIUM No media inserted.
2638 -EINVAL Invalid sector number or nb_sectors
2639 -EACCES Trying to write a read-only device
2640*/
ths5fafdf22007-09-16 21:08:06 +00002641int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002642 const uint8_t *buf, int nb_sectors)
2643{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002644 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
bellard83f64092006-08-01 16:21:11 +00002645}
2646
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002647int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov)
2648{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002649 return bdrv_rwv_co(bs, sector_num, qiov, true, 0);
2650}
2651
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002652int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2653 int nb_sectors, BdrvRequestFlags flags)
Peter Lieven4105eaa2013-07-11 14:16:22 +02002654{
2655 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002656 BDRV_REQ_ZERO_WRITE | flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002657}
2658
Peter Lievend75cbb52013-10-24 12:07:03 +02002659/*
2660 * Completely zero out a block device with the help of bdrv_write_zeroes.
2661 * The operation is sped up by checking the block status and only writing
2662 * zeroes to the device if they currently do not return zeroes. Optional
2663 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2664 *
2665 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2666 */
2667int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2668{
2669 int64_t target_size = bdrv_getlength(bs) / BDRV_SECTOR_SIZE;
2670 int64_t ret, nb_sectors, sector_num = 0;
2671 int n;
2672
2673 for (;;) {
2674 nb_sectors = target_size - sector_num;
2675 if (nb_sectors <= 0) {
2676 return 0;
2677 }
2678 if (nb_sectors > INT_MAX) {
2679 nb_sectors = INT_MAX;
2680 }
2681 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
Peter Lieven3d94ce62013-12-12 13:57:05 +01002682 if (ret < 0) {
2683 error_report("error getting block status at sector %" PRId64 ": %s",
2684 sector_num, strerror(-ret));
2685 return ret;
2686 }
Peter Lievend75cbb52013-10-24 12:07:03 +02002687 if (ret & BDRV_BLOCK_ZERO) {
2688 sector_num += n;
2689 continue;
2690 }
2691 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2692 if (ret < 0) {
2693 error_report("error writing zeroes at sector %" PRId64 ": %s",
2694 sector_num, strerror(-ret));
2695 return ret;
2696 }
2697 sector_num += n;
2698 }
2699}
2700
aliguorieda578e2009-03-12 19:57:16 +00002701int bdrv_pread(BlockDriverState *bs, int64_t offset,
2702 void *buf, int count1)
bellard83f64092006-08-01 16:21:11 +00002703{
Jan Kiszka6ea44302009-11-30 18:21:19 +01002704 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
bellard83f64092006-08-01 16:21:11 +00002705 int len, nb_sectors, count;
2706 int64_t sector_num;
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002707 int ret;
bellard83f64092006-08-01 16:21:11 +00002708
2709 count = count1;
2710 /* first read to align to sector start */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002711 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
bellard83f64092006-08-01 16:21:11 +00002712 if (len > count)
2713 len = count;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002714 sector_num = offset >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002715 if (len > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002716 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2717 return ret;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002718 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
bellard83f64092006-08-01 16:21:11 +00002719 count -= len;
2720 if (count == 0)
2721 return count1;
2722 sector_num++;
2723 buf += len;
2724 }
2725
2726 /* read the sectors "in place" */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002727 nb_sectors = count >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002728 if (nb_sectors > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002729 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
2730 return ret;
bellard83f64092006-08-01 16:21:11 +00002731 sector_num += nb_sectors;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002732 len = nb_sectors << BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002733 buf += len;
2734 count -= len;
2735 }
2736
2737 /* add data from the last sector */
2738 if (count > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002739 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2740 return ret;
bellard83f64092006-08-01 16:21:11 +00002741 memcpy(buf, tmp_buf, count);
2742 }
2743 return count1;
2744}
2745
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002746int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
bellard83f64092006-08-01 16:21:11 +00002747{
Jan Kiszka6ea44302009-11-30 18:21:19 +01002748 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
bellard83f64092006-08-01 16:21:11 +00002749 int len, nb_sectors, count;
2750 int64_t sector_num;
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002751 int ret;
bellard83f64092006-08-01 16:21:11 +00002752
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002753 count = qiov->size;
2754
bellard83f64092006-08-01 16:21:11 +00002755 /* first write to align to sector start */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002756 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
bellard83f64092006-08-01 16:21:11 +00002757 if (len > count)
2758 len = count;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002759 sector_num = offset >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002760 if (len > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002761 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2762 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002763 qemu_iovec_to_buf(qiov, 0, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)),
2764 len);
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002765 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2766 return ret;
bellard83f64092006-08-01 16:21:11 +00002767 count -= len;
2768 if (count == 0)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002769 return qiov->size;
bellard83f64092006-08-01 16:21:11 +00002770 sector_num++;
bellard83f64092006-08-01 16:21:11 +00002771 }
2772
2773 /* write the sectors "in place" */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002774 nb_sectors = count >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002775 if (nb_sectors > 0) {
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002776 QEMUIOVector qiov_inplace;
2777
2778 qemu_iovec_init(&qiov_inplace, qiov->niov);
2779 qemu_iovec_concat(&qiov_inplace, qiov, len,
2780 nb_sectors << BDRV_SECTOR_BITS);
2781 ret = bdrv_writev(bs, sector_num, &qiov_inplace);
2782 qemu_iovec_destroy(&qiov_inplace);
2783 if (ret < 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002784 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002785 }
2786
bellard83f64092006-08-01 16:21:11 +00002787 sector_num += nb_sectors;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002788 len = nb_sectors << BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002789 count -= len;
2790 }
2791
2792 /* add data from the last sector */
2793 if (count > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002794 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2795 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002796 qemu_iovec_to_buf(qiov, qiov->size - count, tmp_buf, count);
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002797 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2798 return ret;
bellard83f64092006-08-01 16:21:11 +00002799 }
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002800 return qiov->size;
2801}
2802
2803int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2804 const void *buf, int count1)
2805{
2806 QEMUIOVector qiov;
2807 struct iovec iov = {
2808 .iov_base = (void *) buf,
2809 .iov_len = count1,
2810 };
2811
2812 qemu_iovec_init_external(&qiov, &iov, 1);
2813 return bdrv_pwritev(bs, offset, &qiov);
bellard83f64092006-08-01 16:21:11 +00002814}
bellard83f64092006-08-01 16:21:11 +00002815
Kevin Wolff08145f2010-06-16 16:38:15 +02002816/*
2817 * Writes to the file and ensures that no writes are reordered across this
2818 * request (acts as a barrier)
2819 *
2820 * Returns 0 on success, -errno in error cases.
2821 */
2822int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2823 const void *buf, int count)
2824{
2825 int ret;
2826
2827 ret = bdrv_pwrite(bs, offset, buf, count);
2828 if (ret < 0) {
2829 return ret;
2830 }
2831
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002832 /* No flush needed for cache modes that already do it */
2833 if (bs->enable_write_cache) {
Kevin Wolff08145f2010-06-16 16:38:15 +02002834 bdrv_flush(bs);
2835 }
2836
2837 return 0;
2838}
2839
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002840static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002841 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2842{
2843 /* Perform I/O through a temporary buffer so that users who scribble over
2844 * their read buffer while the operation is in progress do not end up
2845 * modifying the image file. This is critical for zero-copy guest I/O
2846 * where anything might happen inside guest memory.
2847 */
2848 void *bounce_buffer;
2849
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002850 BlockDriver *drv = bs->drv;
Stefan Hajnocziab185922011-11-17 13:40:31 +00002851 struct iovec iov;
2852 QEMUIOVector bounce_qiov;
2853 int64_t cluster_sector_num;
2854 int cluster_nb_sectors;
2855 size_t skip_bytes;
2856 int ret;
2857
2858 /* Cover entire cluster so no additional backing file I/O is required when
2859 * allocating cluster in the image file.
2860 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002861 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2862 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002863
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002864 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2865 cluster_sector_num, cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002866
2867 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2868 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2869 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2870
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002871 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2872 &bounce_qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002873 if (ret < 0) {
2874 goto err;
2875 }
2876
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002877 if (drv->bdrv_co_write_zeroes &&
2878 buffer_is_zero(bounce_buffer, iov.iov_len)) {
Kevin Wolf621f0582012-03-20 15:12:58 +01002879 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002880 cluster_nb_sectors, 0);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002881 } else {
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002882 /* This does not change the data on the disk, it is not necessary
2883 * to flush even in cache=writethrough mode.
2884 */
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002885 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002886 &bounce_qiov);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002887 }
2888
Stefan Hajnocziab185922011-11-17 13:40:31 +00002889 if (ret < 0) {
2890 /* It might be okay to ignore write errors for guest requests. If this
2891 * is a deliberate copy-on-read then we don't want to ignore the error.
2892 * Simply report it in all cases.
2893 */
2894 goto err;
2895 }
2896
2897 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
Michael Tokarev03396142012-06-07 20:17:55 +04002898 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2899 nb_sectors * BDRV_SECTOR_SIZE);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002900
2901err:
2902 qemu_vfree(bounce_buffer);
2903 return ret;
2904}
2905
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002906/*
Kevin Wolfd0c7f642013-12-02 15:07:48 +01002907 * Forwards an already correctly aligned request to the BlockDriver. This
2908 * handles copy on read and zeroing after EOF; any other features must be
2909 * implemented by the caller.
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002910 */
Kevin Wolfd0c7f642013-12-02 15:07:48 +01002911static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01002912 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
Kevin Wolfec746e12013-12-04 12:13:10 +01002913 int64_t align, QEMUIOVector *qiov, int flags)
Kevin Wolfda1fa912011-07-14 17:27:13 +02002914{
2915 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002916 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002917
Kevin Wolfd0c7f642013-12-02 15:07:48 +01002918 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
2919 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002920
Kevin Wolfd0c7f642013-12-02 15:07:48 +01002921 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
2922 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
2923
2924 /* Handle Copy on Read and associated serialisation */
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002925 if (flags & BDRV_REQ_COPY_ON_READ) {
2926 bs->copy_on_read_in_flight++;
2927 }
2928
2929 if (bs->copy_on_read_in_flight) {
Kevin Wolf65afd212013-12-03 14:55:55 +01002930 wait_for_overlapping_requests(bs, req, offset, bytes);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002931 }
2932
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002933 if (flags & BDRV_REQ_COPY_ON_READ) {
Stefan Hajnocziab185922011-11-17 13:40:31 +00002934 int pnum;
2935
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02002936 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002937 if (ret < 0) {
2938 goto out;
2939 }
2940
2941 if (!ret || pnum != nb_sectors) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002942 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002943 goto out;
2944 }
2945 }
2946
Kevin Wolfd0c7f642013-12-02 15:07:48 +01002947 /* Forward the request to the BlockDriver */
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08002948 if (!(bs->zero_beyond_eof && bs->growable)) {
2949 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
2950 } else {
2951 /* Read zeros after EOF of growable BDSes */
2952 int64_t len, total_sectors, max_nb_sectors;
2953
2954 len = bdrv_getlength(bs);
2955 if (len < 0) {
2956 ret = len;
2957 goto out;
2958 }
2959
Fam Zhengd055a1f2013-09-26 19:55:33 +08002960 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
Kevin Wolfec746e12013-12-04 12:13:10 +01002961 max_nb_sectors = MAX(0, ROUND_UP(total_sectors - sector_num,
2962 align >> BDRV_SECTOR_BITS));
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08002963 if (max_nb_sectors > 0) {
2964 ret = drv->bdrv_co_readv(bs, sector_num,
2965 MIN(nb_sectors, max_nb_sectors), qiov);
2966 } else {
2967 ret = 0;
2968 }
2969
2970 /* Reading beyond end of file is supposed to produce zeroes */
2971 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
2972 uint64_t offset = MAX(0, total_sectors - sector_num);
2973 uint64_t bytes = (sector_num + nb_sectors - offset) *
2974 BDRV_SECTOR_SIZE;
2975 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
2976 }
2977 }
Stefan Hajnocziab185922011-11-17 13:40:31 +00002978
2979out:
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002980 if (flags & BDRV_REQ_COPY_ON_READ) {
2981 bs->copy_on_read_in_flight--;
2982 }
2983
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002984 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002985}
2986
Kevin Wolfd0c7f642013-12-02 15:07:48 +01002987/*
2988 * Handle a read request in coroutine context
2989 */
Kevin Wolf1b0288a2013-12-02 16:09:46 +01002990static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
2991 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Kevin Wolfd0c7f642013-12-02 15:07:48 +01002992 BdrvRequestFlags flags)
2993{
2994 BlockDriver *drv = bs->drv;
Kevin Wolf65afd212013-12-03 14:55:55 +01002995 BdrvTrackedRequest req;
2996
Kevin Wolf1b0288a2013-12-02 16:09:46 +01002997 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
2998 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
2999 uint8_t *head_buf = NULL;
3000 uint8_t *tail_buf = NULL;
3001 QEMUIOVector local_qiov;
3002 bool use_local_qiov = false;
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003003 int ret;
3004
3005 if (!drv) {
3006 return -ENOMEDIUM;
3007 }
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003008 if (bdrv_check_byte_request(bs, offset, bytes)) {
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003009 return -EIO;
3010 }
3011
3012 if (bs->copy_on_read) {
3013 flags |= BDRV_REQ_COPY_ON_READ;
3014 }
3015
3016 /* throttling disk I/O */
3017 if (bs->io_limits_enabled) {
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003018 /* TODO Switch to byte granularity */
3019 bdrv_io_limits_intercept(bs, bytes >> BDRV_SECTOR_BITS, false);
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003020 }
3021
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003022 /* Align read if necessary by padding qiov */
3023 if (offset & (align - 1)) {
3024 head_buf = qemu_blockalign(bs, align);
3025 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3026 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3027 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3028 use_local_qiov = true;
3029
3030 bytes += offset & (align - 1);
3031 offset = offset & ~(align - 1);
3032 }
3033
3034 if ((offset + bytes) & (align - 1)) {
3035 if (!use_local_qiov) {
3036 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3037 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3038 use_local_qiov = true;
3039 }
3040 tail_buf = qemu_blockalign(bs, align);
3041 qemu_iovec_add(&local_qiov, tail_buf,
3042 align - ((offset + bytes) & (align - 1)));
3043
3044 bytes = ROUND_UP(bytes, align);
3045 }
3046
Kevin Wolf65afd212013-12-03 14:55:55 +01003047 tracked_request_begin(&req, bs, offset, bytes, false);
Kevin Wolfec746e12013-12-04 12:13:10 +01003048 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003049 use_local_qiov ? &local_qiov : qiov,
3050 flags);
Kevin Wolf65afd212013-12-03 14:55:55 +01003051 tracked_request_end(&req);
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003052
3053 if (use_local_qiov) {
3054 qemu_iovec_destroy(&local_qiov);
3055 qemu_vfree(head_buf);
3056 qemu_vfree(tail_buf);
3057 }
3058
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003059 return ret;
3060}
3061
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003062static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3063 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3064 BdrvRequestFlags flags)
3065{
3066 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3067 return -EINVAL;
3068 }
3069
3070 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3071 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3072}
3073
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003074int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
Kevin Wolfda1fa912011-07-14 17:27:13 +02003075 int nb_sectors, QEMUIOVector *qiov)
3076{
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003077 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02003078
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003079 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3080}
3081
3082int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3083 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3084{
3085 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3086
3087 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3088 BDRV_REQ_COPY_ON_READ);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003089}
3090
Peter Lievenc31cb702013-10-24 12:06:58 +02003091/* if no limit is specified in the BlockLimits use a default
3092 * of 32768 512-byte sectors (16 MiB) per request.
3093 */
3094#define MAX_WRITE_ZEROES_DEFAULT 32768
3095
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003096static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003097 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003098{
3099 BlockDriver *drv = bs->drv;
3100 QEMUIOVector qiov;
Peter Lievenc31cb702013-10-24 12:06:58 +02003101 struct iovec iov = {0};
3102 int ret = 0;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003103
Peter Lievenc31cb702013-10-24 12:06:58 +02003104 int max_write_zeroes = bs->bl.max_write_zeroes ?
3105 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
Kevin Wolf621f0582012-03-20 15:12:58 +01003106
Peter Lievenc31cb702013-10-24 12:06:58 +02003107 while (nb_sectors > 0 && !ret) {
3108 int num = nb_sectors;
3109
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003110 /* Align request. Block drivers can expect the "bulk" of the request
3111 * to be aligned.
3112 */
3113 if (bs->bl.write_zeroes_alignment
3114 && num > bs->bl.write_zeroes_alignment) {
3115 if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3116 /* Make a small request up to the first aligned sector. */
Peter Lievenc31cb702013-10-24 12:06:58 +02003117 num = bs->bl.write_zeroes_alignment;
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003118 num -= sector_num % bs->bl.write_zeroes_alignment;
3119 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3120 /* Shorten the request to the last aligned sector. num cannot
3121 * underflow because num > bs->bl.write_zeroes_alignment.
3122 */
3123 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
Peter Lievenc31cb702013-10-24 12:06:58 +02003124 }
Kevin Wolf621f0582012-03-20 15:12:58 +01003125 }
Peter Lievenc31cb702013-10-24 12:06:58 +02003126
3127 /* limit request size */
3128 if (num > max_write_zeroes) {
3129 num = max_write_zeroes;
3130 }
3131
3132 ret = -ENOTSUP;
3133 /* First try the efficient write zeroes operation */
3134 if (drv->bdrv_co_write_zeroes) {
3135 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3136 }
3137
3138 if (ret == -ENOTSUP) {
3139 /* Fall back to bounce buffer if write zeroes is unsupported */
3140 iov.iov_len = num * BDRV_SECTOR_SIZE;
3141 if (iov.iov_base == NULL) {
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003142 iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE);
3143 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
Peter Lievenc31cb702013-10-24 12:06:58 +02003144 }
3145 qemu_iovec_init_external(&qiov, &iov, 1);
3146
3147 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003148
3149 /* Keep bounce buffer around if it is big enough for all
3150 * all future requests.
3151 */
3152 if (num < max_write_zeroes) {
3153 qemu_vfree(iov.iov_base);
3154 iov.iov_base = NULL;
3155 }
Peter Lievenc31cb702013-10-24 12:06:58 +02003156 }
3157
3158 sector_num += num;
3159 nb_sectors -= num;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003160 }
3161
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003162 qemu_vfree(iov.iov_base);
3163 return ret;
3164}
3165
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003166/*
Kevin Wolfb404f722013-12-03 14:02:23 +01003167 * Forwards an already correctly aligned write request to the BlockDriver.
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003168 */
Kevin Wolfb404f722013-12-03 14:02:23 +01003169static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01003170 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3171 QEMUIOVector *qiov, int flags)
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003172{
3173 BlockDriver *drv = bs->drv;
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003174 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003175
Kevin Wolfb404f722013-12-03 14:02:23 +01003176 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3177 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003178
Kevin Wolfb404f722013-12-03 14:02:23 +01003179 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3180 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
Benoît Canetcc0681c2013-09-02 14:14:39 +02003181
Kevin Wolf244eade2013-12-03 14:30:44 +01003182 if (bs->copy_on_read_in_flight) {
Kevin Wolf65afd212013-12-03 14:55:55 +01003183 wait_for_overlapping_requests(bs, req, offset, bytes);
Kevin Wolf244eade2013-12-03 14:30:44 +01003184 }
3185
Kevin Wolf65afd212013-12-03 14:55:55 +01003186 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003187
3188 if (ret < 0) {
3189 /* Do nothing, write notifier decided to fail this request */
3190 } else if (flags & BDRV_REQ_ZERO_WRITE) {
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003191 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003192 } else {
3193 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3194 }
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003195
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02003196 if (ret == 0 && !bs->enable_write_cache) {
3197 ret = bdrv_co_flush(bs);
3198 }
3199
Fam Zhenge4654d22013-11-13 18:29:43 +08003200 bdrv_set_dirty(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02003201
3202 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3203 bs->wr_highest_sector = sector_num + nb_sectors - 1;
3204 }
Paolo Bonzinidf2a6f22013-09-04 19:00:21 +02003205 if (bs->growable && ret >= 0) {
3206 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3207 }
Kevin Wolfda1fa912011-07-14 17:27:13 +02003208
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003209 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003210}
3211
Kevin Wolfb404f722013-12-03 14:02:23 +01003212/*
3213 * Handle a write request in coroutine context
3214 */
Kevin Wolf66015532013-12-03 14:40:18 +01003215static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3216 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Kevin Wolfb404f722013-12-03 14:02:23 +01003217 BdrvRequestFlags flags)
3218{
Kevin Wolf65afd212013-12-03 14:55:55 +01003219 BdrvTrackedRequest req;
Kevin Wolfb404f722013-12-03 14:02:23 +01003220 int ret;
3221
3222 if (!bs->drv) {
3223 return -ENOMEDIUM;
3224 }
3225 if (bs->read_only) {
3226 return -EACCES;
3227 }
Kevin Wolf66015532013-12-03 14:40:18 +01003228 if (bdrv_check_byte_request(bs, offset, bytes)) {
Kevin Wolfb404f722013-12-03 14:02:23 +01003229 return -EIO;
3230 }
3231
Kevin Wolfb404f722013-12-03 14:02:23 +01003232 /* throttling disk I/O */
3233 if (bs->io_limits_enabled) {
Kevin Wolf66015532013-12-03 14:40:18 +01003234 /* TODO Switch to byte granularity */
3235 bdrv_io_limits_intercept(bs, bytes >> BDRV_SECTOR_BITS, true);
Kevin Wolfb404f722013-12-03 14:02:23 +01003236 }
3237
Kevin Wolf65afd212013-12-03 14:55:55 +01003238 tracked_request_begin(&req, bs, offset, bytes, true);
3239 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes, qiov, flags);
3240 tracked_request_end(&req);
Kevin Wolfb404f722013-12-03 14:02:23 +01003241
3242 return ret;
3243}
3244
Kevin Wolf66015532013-12-03 14:40:18 +01003245static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3246 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3247 BdrvRequestFlags flags)
3248{
3249 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3250 return -EINVAL;
3251 }
3252
3253 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3254 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3255}
3256
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003257int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3258 int nb_sectors, QEMUIOVector *qiov)
3259{
3260 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3261
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003262 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3263}
3264
3265int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003266 int64_t sector_num, int nb_sectors,
3267 BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003268{
Paolo Bonzini94d6ff22013-11-22 13:39:45 +01003269 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003270
Peter Lievend32f35c2013-10-24 12:06:52 +02003271 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3272 flags &= ~BDRV_REQ_MAY_UNMAP;
3273 }
3274
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003275 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003276 BDRV_REQ_ZERO_WRITE | flags);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003277}
3278
bellard83f64092006-08-01 16:21:11 +00003279/**
bellard83f64092006-08-01 16:21:11 +00003280 * Truncate file to 'offset' bytes (needed only for file protocols)
3281 */
3282int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3283{
3284 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003285 int ret;
bellard83f64092006-08-01 16:21:11 +00003286 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003287 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00003288 if (!drv->bdrv_truncate)
3289 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02003290 if (bs->read_only)
3291 return -EACCES;
Marcelo Tosatti85916752011-01-26 12:12:35 -02003292 if (bdrv_in_use(bs))
3293 return -EBUSY;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003294 ret = drv->bdrv_truncate(bs, offset);
3295 if (ret == 0) {
3296 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
Markus Armbruster145feb12011-08-03 15:07:42 +02003297 bdrv_dev_resize_cb(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003298 }
3299 return ret;
bellard83f64092006-08-01 16:21:11 +00003300}
3301
3302/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08003303 * Length of a allocated file in bytes. Sparse files are counted by actual
3304 * allocated space. Return < 0 if error or unknown.
3305 */
3306int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3307{
3308 BlockDriver *drv = bs->drv;
3309 if (!drv) {
3310 return -ENOMEDIUM;
3311 }
3312 if (drv->bdrv_get_allocated_file_size) {
3313 return drv->bdrv_get_allocated_file_size(bs);
3314 }
3315 if (bs->file) {
3316 return bdrv_get_allocated_file_size(bs->file);
3317 }
3318 return -ENOTSUP;
3319}
3320
3321/**
bellard83f64092006-08-01 16:21:11 +00003322 * Length of a file in bytes. Return < 0 if error or unknown.
3323 */
3324int64_t bdrv_getlength(BlockDriverState *bs)
3325{
3326 BlockDriver *drv = bs->drv;
3327 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003328 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003329
Kevin Wolfb94a2612013-10-29 12:18:58 +01003330 if (drv->has_variable_length) {
3331 int ret = refresh_total_sectors(bs, bs->total_sectors);
3332 if (ret < 0) {
3333 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01003334 }
bellard83f64092006-08-01 16:21:11 +00003335 }
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01003336 return bs->total_sectors * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00003337}
3338
bellard19cb3732006-08-19 11:45:59 +00003339/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00003340void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00003341{
bellard19cb3732006-08-19 11:45:59 +00003342 int64_t length;
3343 length = bdrv_getlength(bs);
3344 if (length < 0)
3345 length = 0;
3346 else
Jan Kiszka6ea44302009-11-30 18:21:19 +01003347 length = length >> BDRV_SECTOR_BITS;
bellard19cb3732006-08-19 11:45:59 +00003348 *nb_sectors_ptr = length;
bellardfc01f7e2003-06-30 10:03:06 +00003349}
bellardcf989512004-02-16 21:56:36 +00003350
Paolo Bonziniff06f5f2012-09-28 17:22:54 +02003351void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3352 BlockdevOnError on_write_error)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02003353{
3354 bs->on_read_error = on_read_error;
3355 bs->on_write_error = on_write_error;
3356}
3357
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +02003358BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02003359{
3360 return is_read ? bs->on_read_error : bs->on_write_error;
3361}
3362
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003363BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3364{
3365 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3366
3367 switch (on_err) {
3368 case BLOCKDEV_ON_ERROR_ENOSPC:
3369 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
3370 case BLOCKDEV_ON_ERROR_STOP:
3371 return BDRV_ACTION_STOP;
3372 case BLOCKDEV_ON_ERROR_REPORT:
3373 return BDRV_ACTION_REPORT;
3374 case BLOCKDEV_ON_ERROR_IGNORE:
3375 return BDRV_ACTION_IGNORE;
3376 default:
3377 abort();
3378 }
3379}
3380
3381/* This is done by device models because, while the block layer knows
3382 * about the error, it does not know whether an operation comes from
3383 * the device or the block layer (from a job, for example).
3384 */
3385void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3386 bool is_read, int error)
3387{
3388 assert(error >= 0);
Paolo Bonzini32c81a42012-09-28 17:22:58 +02003389 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003390 if (action == BDRV_ACTION_STOP) {
3391 vm_stop(RUN_STATE_IO_ERROR);
3392 bdrv_iostatus_set_err(bs, error);
3393 }
3394}
3395
bellardb3380822004-03-14 21:38:54 +00003396int bdrv_is_read_only(BlockDriverState *bs)
3397{
3398 return bs->read_only;
3399}
3400
ths985a03b2007-12-24 16:10:43 +00003401int bdrv_is_sg(BlockDriverState *bs)
3402{
3403 return bs->sg;
3404}
3405
Christoph Hellwige900a7b2009-09-04 19:01:15 +02003406int bdrv_enable_write_cache(BlockDriverState *bs)
3407{
3408 return bs->enable_write_cache;
3409}
3410
Paolo Bonzini425b0142012-06-06 00:04:52 +02003411void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3412{
3413 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04003414
3415 /* so a reopen() will preserve wce */
3416 if (wce) {
3417 bs->open_flags |= BDRV_O_CACHE_WB;
3418 } else {
3419 bs->open_flags &= ~BDRV_O_CACHE_WB;
3420 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02003421}
3422
bellardea2384d2004-08-01 21:59:26 +00003423int bdrv_is_encrypted(BlockDriverState *bs)
3424{
3425 if (bs->backing_hd && bs->backing_hd->encrypted)
3426 return 1;
3427 return bs->encrypted;
3428}
3429
aliguoric0f4ce72009-03-05 23:01:01 +00003430int bdrv_key_required(BlockDriverState *bs)
3431{
3432 BlockDriverState *backing_hd = bs->backing_hd;
3433
3434 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3435 return 1;
3436 return (bs->encrypted && !bs->valid_key);
3437}
3438
bellardea2384d2004-08-01 21:59:26 +00003439int bdrv_set_key(BlockDriverState *bs, const char *key)
3440{
3441 int ret;
3442 if (bs->backing_hd && bs->backing_hd->encrypted) {
3443 ret = bdrv_set_key(bs->backing_hd, key);
3444 if (ret < 0)
3445 return ret;
3446 if (!bs->encrypted)
3447 return 0;
3448 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02003449 if (!bs->encrypted) {
3450 return -EINVAL;
3451 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3452 return -ENOMEDIUM;
3453 }
aliguoric0f4ce72009-03-05 23:01:01 +00003454 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00003455 if (ret < 0) {
3456 bs->valid_key = 0;
3457 } else if (!bs->valid_key) {
3458 bs->valid_key = 1;
3459 /* call the change callback now, we skipped it on open */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02003460 bdrv_dev_change_media_cb(bs, true);
aliguoribb5fc202009-03-05 23:01:15 +00003461 }
aliguoric0f4ce72009-03-05 23:01:01 +00003462 return ret;
bellardea2384d2004-08-01 21:59:26 +00003463}
3464
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003465const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00003466{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003467 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00003468}
3469
ths5fafdf22007-09-16 21:08:06 +00003470void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00003471 void *opaque)
3472{
3473 BlockDriver *drv;
3474
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01003475 QLIST_FOREACH(drv, &bdrv_drivers, list) {
bellardea2384d2004-08-01 21:59:26 +00003476 it(opaque, drv->format_name);
3477 }
3478}
3479
Benoît Canetdc364f42014-01-23 21:31:32 +01003480/* This function is to find block backend bs */
bellardb3380822004-03-14 21:38:54 +00003481BlockDriverState *bdrv_find(const char *name)
3482{
3483 BlockDriverState *bs;
3484
Benoît Canetdc364f42014-01-23 21:31:32 +01003485 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003486 if (!strcmp(name, bs->device_name)) {
bellardb3380822004-03-14 21:38:54 +00003487 return bs;
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003488 }
bellardb3380822004-03-14 21:38:54 +00003489 }
3490 return NULL;
3491}
3492
Benoît Canetdc364f42014-01-23 21:31:32 +01003493/* This function is to find a node in the bs graph */
3494BlockDriverState *bdrv_find_node(const char *node_name)
3495{
3496 BlockDriverState *bs;
3497
3498 assert(node_name);
3499
3500 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3501 if (!strcmp(node_name, bs->node_name)) {
3502 return bs;
3503 }
3504 }
3505 return NULL;
3506}
3507
Benoît Canetc13163f2014-01-23 21:31:34 +01003508/* Put this QMP function here so it can access the static graph_bdrv_states. */
3509BlockDeviceInfoList *bdrv_named_nodes_list(void)
3510{
3511 BlockDeviceInfoList *list, *entry;
3512 BlockDriverState *bs;
3513
3514 list = NULL;
3515 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3516 entry = g_malloc0(sizeof(*entry));
3517 entry->value = bdrv_block_device_info(bs);
3518 entry->next = list;
3519 list = entry;
3520 }
3521
3522 return list;
3523}
3524
Benoît Canet12d3ba82014-01-23 21:31:35 +01003525BlockDriverState *bdrv_lookup_bs(const char *device,
3526 const char *node_name,
3527 Error **errp)
3528{
3529 BlockDriverState *bs = NULL;
3530
3531 if ((!device && !node_name) || (device && node_name)) {
3532 error_setg(errp, "Use either device or node-name but not both");
3533 return NULL;
3534 }
3535
3536 if (device) {
3537 bs = bdrv_find(device);
3538
3539 if (!bs) {
3540 error_set(errp, QERR_DEVICE_NOT_FOUND, device);
3541 return NULL;
3542 }
3543
3544 return bs;
3545 }
3546
3547 bs = bdrv_find_node(node_name);
3548
3549 if (!bs) {
3550 error_set(errp, QERR_DEVICE_NOT_FOUND, node_name);
3551 return NULL;
3552 }
3553
3554 return bs;
3555}
3556
Markus Armbruster2f399b02010-06-02 18:55:20 +02003557BlockDriverState *bdrv_next(BlockDriverState *bs)
3558{
3559 if (!bs) {
3560 return QTAILQ_FIRST(&bdrv_states);
3561 }
Benoît Canetdc364f42014-01-23 21:31:32 +01003562 return QTAILQ_NEXT(bs, device_list);
Markus Armbruster2f399b02010-06-02 18:55:20 +02003563}
3564
aliguori51de9762009-03-05 23:00:43 +00003565void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
bellard81d09122004-07-14 17:21:37 +00003566{
3567 BlockDriverState *bs;
3568
Benoît Canetdc364f42014-01-23 21:31:32 +01003569 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
aliguori51de9762009-03-05 23:00:43 +00003570 it(opaque, bs);
bellard81d09122004-07-14 17:21:37 +00003571 }
3572}
3573
bellardea2384d2004-08-01 21:59:26 +00003574const char *bdrv_get_device_name(BlockDriverState *bs)
3575{
3576 return bs->device_name;
3577}
3578
Markus Armbrusterc8433282012-06-05 16:49:24 +02003579int bdrv_get_flags(BlockDriverState *bs)
3580{
3581 return bs->open_flags;
3582}
3583
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003584int bdrv_flush_all(void)
aliguoric6ca28d2008-10-06 13:55:43 +00003585{
3586 BlockDriverState *bs;
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003587 int result = 0;
aliguoric6ca28d2008-10-06 13:55:43 +00003588
Benoît Canetdc364f42014-01-23 21:31:32 +01003589 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003590 int ret = bdrv_flush(bs);
3591 if (ret < 0 && !result) {
3592 result = ret;
3593 }
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003594 }
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003595
3596 return result;
aliguoric6ca28d2008-10-06 13:55:43 +00003597}
3598
Peter Lieven3ac21622013-06-28 12:47:42 +02003599int bdrv_has_zero_init_1(BlockDriverState *bs)
3600{
3601 return 1;
3602}
3603
Kevin Wolff2feebb2010-04-14 17:30:35 +02003604int bdrv_has_zero_init(BlockDriverState *bs)
3605{
3606 assert(bs->drv);
3607
Paolo Bonzini11212d82013-09-04 19:00:27 +02003608 /* If BS is a copy on write image, it is initialized to
3609 the contents of the base image, which may not be zeroes. */
3610 if (bs->backing_hd) {
3611 return 0;
3612 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02003613 if (bs->drv->bdrv_has_zero_init) {
3614 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02003615 }
3616
Peter Lieven3ac21622013-06-28 12:47:42 +02003617 /* safe default */
3618 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02003619}
3620
Peter Lieven4ce78692013-10-24 12:06:54 +02003621bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3622{
3623 BlockDriverInfo bdi;
3624
3625 if (bs->backing_hd) {
3626 return false;
3627 }
3628
3629 if (bdrv_get_info(bs, &bdi) == 0) {
3630 return bdi.unallocated_blocks_are_zero;
3631 }
3632
3633 return false;
3634}
3635
3636bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3637{
3638 BlockDriverInfo bdi;
3639
3640 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3641 return false;
3642 }
3643
3644 if (bdrv_get_info(bs, &bdi) == 0) {
3645 return bdi.can_write_zeroes_with_unmap;
3646 }
3647
3648 return false;
3649}
3650
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003651typedef struct BdrvCoGetBlockStatusData {
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003652 BlockDriverState *bs;
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +01003653 BlockDriverState *base;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003654 int64_t sector_num;
3655 int nb_sectors;
3656 int *pnum;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003657 int64_t ret;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003658 bool done;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003659} BdrvCoGetBlockStatusData;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003660
thsf58c7b32008-06-05 21:53:49 +00003661/*
3662 * Returns true iff the specified sector is present in the disk image. Drivers
3663 * not implementing the functionality are assumed to not support backing files,
3664 * hence all their sectors are reported as allocated.
3665 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003666 * If 'sector_num' is beyond the end of the disk image the return value is 0
3667 * and 'pnum' is set to 0.
3668 *
thsf58c7b32008-06-05 21:53:49 +00003669 * 'pnum' is set to the number of sectors (including and immediately following
3670 * the specified sector) that are known to be in the same
3671 * allocated/unallocated state.
3672 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003673 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3674 * beyond the end of the disk image it will be clamped.
thsf58c7b32008-06-05 21:53:49 +00003675 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003676static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3677 int64_t sector_num,
3678 int nb_sectors, int *pnum)
thsf58c7b32008-06-05 21:53:49 +00003679{
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003680 int64_t length;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003681 int64_t n;
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003682 int64_t ret, ret2;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003683
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003684 length = bdrv_getlength(bs);
3685 if (length < 0) {
3686 return length;
3687 }
3688
3689 if (sector_num >= (length >> BDRV_SECTOR_BITS)) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003690 *pnum = 0;
3691 return 0;
3692 }
3693
3694 n = bs->total_sectors - sector_num;
3695 if (n < nb_sectors) {
3696 nb_sectors = n;
3697 }
3698
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003699 if (!bs->drv->bdrv_co_get_block_status) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003700 *pnum = nb_sectors;
Paolo Bonzini918e92d2013-09-04 19:00:37 +02003701 ret = BDRV_BLOCK_DATA;
3702 if (bs->drv->protocol_name) {
3703 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
3704 }
3705 return ret;
thsf58c7b32008-06-05 21:53:49 +00003706 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003707
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003708 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
3709 if (ret < 0) {
Peter Lieven3e0a2332013-09-24 15:35:08 +02003710 *pnum = 0;
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003711 return ret;
3712 }
3713
Peter Lieven92bc50a2013-10-08 14:43:14 +02003714 if (ret & BDRV_BLOCK_RAW) {
3715 assert(ret & BDRV_BLOCK_OFFSET_VALID);
3716 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3717 *pnum, pnum);
3718 }
3719
Peter Lievenc3d86882013-10-24 12:07:04 +02003720 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
3721 if (bdrv_unallocated_blocks_are_zero(bs)) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003722 ret |= BDRV_BLOCK_ZERO;
Peter Lieven1f9db222013-09-24 15:35:09 +02003723 } else if (bs->backing_hd) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003724 BlockDriverState *bs2 = bs->backing_hd;
3725 int64_t length2 = bdrv_getlength(bs2);
3726 if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {
3727 ret |= BDRV_BLOCK_ZERO;
3728 }
3729 }
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003730 }
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003731
3732 if (bs->file &&
3733 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
3734 (ret & BDRV_BLOCK_OFFSET_VALID)) {
3735 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3736 *pnum, pnum);
3737 if (ret2 >= 0) {
3738 /* Ignore errors. This is just providing extra information, it
3739 * is useful but not necessary.
3740 */
3741 ret |= (ret2 & BDRV_BLOCK_ZERO);
3742 }
3743 }
3744
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003745 return ret;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003746}
3747
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003748/* Coroutine wrapper for bdrv_get_block_status() */
3749static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003750{
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003751 BdrvCoGetBlockStatusData *data = opaque;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003752 BlockDriverState *bs = data->bs;
3753
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003754 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
3755 data->pnum);
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003756 data->done = true;
3757}
3758
3759/*
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003760 * Synchronous wrapper around bdrv_co_get_block_status().
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003761 *
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003762 * See bdrv_co_get_block_status() for details.
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003763 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003764int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
3765 int nb_sectors, int *pnum)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003766{
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003767 Coroutine *co;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003768 BdrvCoGetBlockStatusData data = {
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003769 .bs = bs,
3770 .sector_num = sector_num,
3771 .nb_sectors = nb_sectors,
3772 .pnum = pnum,
3773 .done = false,
3774 };
3775
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003776 if (qemu_in_coroutine()) {
3777 /* Fast-path if already in coroutine context */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003778 bdrv_get_block_status_co_entry(&data);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003779 } else {
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003780 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003781 qemu_coroutine_enter(co, &data);
3782 while (!data.done) {
3783 qemu_aio_wait();
3784 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003785 }
3786 return data.ret;
thsf58c7b32008-06-05 21:53:49 +00003787}
3788
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003789int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
3790 int nb_sectors, int *pnum)
3791{
Paolo Bonzini4333bb72013-09-04 19:00:29 +02003792 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
3793 if (ret < 0) {
3794 return ret;
3795 }
3796 return
3797 (ret & BDRV_BLOCK_DATA) ||
3798 ((ret & BDRV_BLOCK_ZERO) && !bdrv_has_zero_init(bs));
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003799}
3800
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003801/*
3802 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
3803 *
3804 * Return true if the given sector is allocated in any image between
3805 * BASE and TOP (inclusive). BASE can be NULL to check if the given
3806 * sector is allocated in any image of the chain. Return false otherwise.
3807 *
3808 * 'pnum' is set to the number of sectors (including and immediately following
3809 * the specified sector) that are known to be in the same
3810 * allocated/unallocated state.
3811 *
3812 */
Paolo Bonzini4f578632013-09-04 19:00:24 +02003813int bdrv_is_allocated_above(BlockDriverState *top,
3814 BlockDriverState *base,
3815 int64_t sector_num,
3816 int nb_sectors, int *pnum)
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003817{
3818 BlockDriverState *intermediate;
3819 int ret, n = nb_sectors;
3820
3821 intermediate = top;
3822 while (intermediate && intermediate != base) {
3823 int pnum_inter;
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003824 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
3825 &pnum_inter);
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003826 if (ret < 0) {
3827 return ret;
3828 } else if (ret) {
3829 *pnum = pnum_inter;
3830 return 1;
3831 }
3832
3833 /*
3834 * [sector_num, nb_sectors] is unallocated on top but intermediate
3835 * might have
3836 *
3837 * [sector_num+x, nr_sectors] allocated.
3838 */
Vishvananda Ishaya63ba17d2013-01-24 10:02:08 -08003839 if (n > pnum_inter &&
3840 (intermediate == top ||
3841 sector_num + pnum_inter < intermediate->total_sectors)) {
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003842 n = pnum_inter;
3843 }
3844
3845 intermediate = intermediate->backing_hd;
3846 }
3847
3848 *pnum = n;
3849 return 0;
3850}
3851
aliguori045df332009-03-05 23:00:48 +00003852const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3853{
3854 if (bs->backing_hd && bs->backing_hd->encrypted)
3855 return bs->backing_file;
3856 else if (bs->encrypted)
3857 return bs->filename;
3858 else
3859 return NULL;
3860}
3861
ths5fafdf22007-09-16 21:08:06 +00003862void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00003863 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00003864{
Kevin Wolf3574c602011-10-26 11:02:11 +02003865 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00003866}
3867
ths5fafdf22007-09-16 21:08:06 +00003868int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellardfaea38e2006-08-05 21:31:00 +00003869 const uint8_t *buf, int nb_sectors)
3870{
3871 BlockDriver *drv = bs->drv;
3872 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003873 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003874 if (!drv->bdrv_write_compressed)
3875 return -ENOTSUP;
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02003876 if (bdrv_check_request(bs, sector_num, nb_sectors))
3877 return -EIO;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003878
Fam Zhenge4654d22013-11-13 18:29:43 +08003879 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003880
bellardfaea38e2006-08-05 21:31:00 +00003881 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
3882}
ths3b46e622007-09-17 08:09:54 +00003883
bellardfaea38e2006-08-05 21:31:00 +00003884int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3885{
3886 BlockDriver *drv = bs->drv;
3887 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003888 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003889 if (!drv->bdrv_get_info)
3890 return -ENOTSUP;
3891 memset(bdi, 0, sizeof(*bdi));
3892 return drv->bdrv_get_info(bs, bdi);
3893}
3894
Max Reitzeae041f2013-10-09 10:46:16 +02003895ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3896{
3897 BlockDriver *drv = bs->drv;
3898 if (drv && drv->bdrv_get_specific_info) {
3899 return drv->bdrv_get_specific_info(bs);
3900 }
3901 return NULL;
3902}
3903
Christoph Hellwig45566e92009-07-10 23:11:57 +02003904int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
3905 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00003906{
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003907 QEMUIOVector qiov;
3908 struct iovec iov = {
3909 .iov_base = (void *) buf,
3910 .iov_len = size,
3911 };
3912
3913 qemu_iovec_init_external(&qiov, &iov, 1);
3914 return bdrv_writev_vmstate(bs, &qiov, pos);
3915}
3916
3917int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
3918{
aliguori178e08a2009-04-05 19:10:55 +00003919 BlockDriver *drv = bs->drv;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003920
3921 if (!drv) {
aliguori178e08a2009-04-05 19:10:55 +00003922 return -ENOMEDIUM;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003923 } else if (drv->bdrv_save_vmstate) {
3924 return drv->bdrv_save_vmstate(bs, qiov, pos);
3925 } else if (bs->file) {
3926 return bdrv_writev_vmstate(bs->file, qiov, pos);
3927 }
3928
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003929 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00003930}
3931
Christoph Hellwig45566e92009-07-10 23:11:57 +02003932int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
3933 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00003934{
3935 BlockDriver *drv = bs->drv;
3936 if (!drv)
3937 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003938 if (drv->bdrv_load_vmstate)
3939 return drv->bdrv_load_vmstate(bs, buf, pos, size);
3940 if (bs->file)
3941 return bdrv_load_vmstate(bs->file, buf, pos, size);
3942 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00003943}
3944
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003945void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3946{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003947 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003948 return;
3949 }
3950
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003951 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01003952}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003953
Kevin Wolf41c695c2012-12-06 14:32:58 +01003954int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3955 const char *tag)
3956{
3957 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3958 bs = bs->file;
3959 }
3960
3961 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3962 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3963 }
3964
3965 return -ENOTSUP;
3966}
3967
Fam Zheng4cc70e92013-11-20 10:01:54 +08003968int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3969{
3970 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3971 bs = bs->file;
3972 }
3973
3974 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3975 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3976 }
3977
3978 return -ENOTSUP;
3979}
3980
Kevin Wolf41c695c2012-12-06 14:32:58 +01003981int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3982{
3983 while (bs && bs->drv && !bs->drv->bdrv_debug_resume) {
3984 bs = bs->file;
3985 }
3986
3987 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3988 return bs->drv->bdrv_debug_resume(bs, tag);
3989 }
3990
3991 return -ENOTSUP;
3992}
3993
3994bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3995{
3996 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3997 bs = bs->file;
3998 }
3999
4000 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4001 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4002 }
4003
4004 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004005}
4006
Blue Swirl199630b2010-07-25 20:49:34 +00004007int bdrv_is_snapshot(BlockDriverState *bs)
4008{
4009 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4010}
4011
Jeff Codyb1b1d782012-10-16 15:49:09 -04004012/* backing_file can either be relative, or absolute, or a protocol. If it is
4013 * relative, it must be relative to the chain. So, passing in bs->filename
4014 * from a BDS as backing_file should not be done, as that may be relative to
4015 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004016BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4017 const char *backing_file)
4018{
Jeff Codyb1b1d782012-10-16 15:49:09 -04004019 char *filename_full = NULL;
4020 char *backing_file_full = NULL;
4021 char *filename_tmp = NULL;
4022 int is_protocol = 0;
4023 BlockDriverState *curr_bs = NULL;
4024 BlockDriverState *retval = NULL;
4025
4026 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004027 return NULL;
4028 }
4029
Jeff Codyb1b1d782012-10-16 15:49:09 -04004030 filename_full = g_malloc(PATH_MAX);
4031 backing_file_full = g_malloc(PATH_MAX);
4032 filename_tmp = g_malloc(PATH_MAX);
4033
4034 is_protocol = path_has_protocol(backing_file);
4035
4036 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4037
4038 /* If either of the filename paths is actually a protocol, then
4039 * compare unmodified paths; otherwise make paths relative */
4040 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4041 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4042 retval = curr_bs->backing_hd;
4043 break;
4044 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004045 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04004046 /* If not an absolute filename path, make it relative to the current
4047 * image's filename path */
4048 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4049 backing_file);
4050
4051 /* We are going to compare absolute pathnames */
4052 if (!realpath(filename_tmp, filename_full)) {
4053 continue;
4054 }
4055
4056 /* We need to make sure the backing filename we are comparing against
4057 * is relative to the current image filename (or absolute) */
4058 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4059 curr_bs->backing_file);
4060
4061 if (!realpath(filename_tmp, backing_file_full)) {
4062 continue;
4063 }
4064
4065 if (strcmp(backing_file_full, filename_full) == 0) {
4066 retval = curr_bs->backing_hd;
4067 break;
4068 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004069 }
4070 }
4071
Jeff Codyb1b1d782012-10-16 15:49:09 -04004072 g_free(filename_full);
4073 g_free(backing_file_full);
4074 g_free(filename_tmp);
4075 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004076}
4077
Benoît Canetf198fd12012-08-02 10:22:47 +02004078int bdrv_get_backing_file_depth(BlockDriverState *bs)
4079{
4080 if (!bs->drv) {
4081 return 0;
4082 }
4083
4084 if (!bs->backing_hd) {
4085 return 0;
4086 }
4087
4088 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4089}
4090
Jeff Cody79fac562012-09-27 13:29:15 -04004091BlockDriverState *bdrv_find_base(BlockDriverState *bs)
4092{
4093 BlockDriverState *curr_bs = NULL;
4094
4095 if (!bs) {
4096 return NULL;
4097 }
4098
4099 curr_bs = bs;
4100
4101 while (curr_bs->backing_hd) {
4102 curr_bs = curr_bs->backing_hd;
4103 }
4104 return curr_bs;
4105}
4106
bellard83f64092006-08-01 16:21:11 +00004107/**************************************************************/
4108/* async I/Os */
4109
aliguori3b69e4b2009-01-22 16:59:24 +00004110BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
aliguorif141eaf2009-04-07 18:43:24 +00004111 QEMUIOVector *qiov, int nb_sectors,
aliguori3b69e4b2009-01-22 16:59:24 +00004112 BlockDriverCompletionFunc *cb, void *opaque)
4113{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01004114 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4115
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004116 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004117 cb, opaque, false);
bellard83f64092006-08-01 16:21:11 +00004118}
4119
aliguorif141eaf2009-04-07 18:43:24 +00004120BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4121 QEMUIOVector *qiov, int nb_sectors,
4122 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00004123{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01004124 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4125
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004126 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004127 cb, opaque, true);
bellard83f64092006-08-01 16:21:11 +00004128}
4129
Paolo Bonzinid5ef94d2013-11-22 13:39:46 +01004130BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4131 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4132 BlockDriverCompletionFunc *cb, void *opaque)
4133{
4134 trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4135
4136 return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4137 BDRV_REQ_ZERO_WRITE | flags,
4138 cb, opaque, true);
4139}
4140
Kevin Wolf40b4f532009-09-09 17:53:37 +02004141
4142typedef struct MultiwriteCB {
4143 int error;
4144 int num_requests;
4145 int num_callbacks;
4146 struct {
4147 BlockDriverCompletionFunc *cb;
4148 void *opaque;
4149 QEMUIOVector *free_qiov;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004150 } callbacks[];
4151} MultiwriteCB;
4152
4153static void multiwrite_user_cb(MultiwriteCB *mcb)
4154{
4155 int i;
4156
4157 for (i = 0; i < mcb->num_callbacks; i++) {
4158 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
Stefan Hajnoczi1e1ea482010-04-21 20:35:45 +01004159 if (mcb->callbacks[i].free_qiov) {
4160 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4161 }
Anthony Liguori7267c092011-08-20 22:09:37 -05004162 g_free(mcb->callbacks[i].free_qiov);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004163 }
4164}
4165
4166static void multiwrite_cb(void *opaque, int ret)
4167{
4168 MultiwriteCB *mcb = opaque;
4169
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01004170 trace_multiwrite_cb(mcb, ret);
4171
Kevin Wolfcb6d3ca2010-04-01 22:48:44 +02004172 if (ret < 0 && !mcb->error) {
Kevin Wolf40b4f532009-09-09 17:53:37 +02004173 mcb->error = ret;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004174 }
4175
4176 mcb->num_requests--;
4177 if (mcb->num_requests == 0) {
Kevin Wolfde189a12010-07-01 16:08:51 +02004178 multiwrite_user_cb(mcb);
Anthony Liguori7267c092011-08-20 22:09:37 -05004179 g_free(mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004180 }
4181}
4182
4183static int multiwrite_req_compare(const void *a, const void *b)
4184{
Christoph Hellwig77be4362010-05-19 20:53:10 +02004185 const BlockRequest *req1 = a, *req2 = b;
4186
4187 /*
4188 * Note that we can't simply subtract req2->sector from req1->sector
4189 * here as that could overflow the return value.
4190 */
4191 if (req1->sector > req2->sector) {
4192 return 1;
4193 } else if (req1->sector < req2->sector) {
4194 return -1;
4195 } else {
4196 return 0;
4197 }
Kevin Wolf40b4f532009-09-09 17:53:37 +02004198}
4199
4200/*
4201 * Takes a bunch of requests and tries to merge them. Returns the number of
4202 * requests that remain after merging.
4203 */
4204static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4205 int num_reqs, MultiwriteCB *mcb)
4206{
4207 int i, outidx;
4208
4209 // Sort requests by start sector
4210 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4211
4212 // Check if adjacent requests touch the same clusters. If so, combine them,
4213 // filling up gaps with zero sectors.
4214 outidx = 0;
4215 for (i = 1; i < num_reqs; i++) {
4216 int merge = 0;
4217 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4218
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01004219 // Handle exactly sequential writes and overlapping writes.
Kevin Wolf40b4f532009-09-09 17:53:37 +02004220 if (reqs[i].sector <= oldreq_last) {
4221 merge = 1;
4222 }
4223
Christoph Hellwige2a305f2010-01-26 14:49:08 +01004224 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4225 merge = 0;
4226 }
4227
Kevin Wolf40b4f532009-09-09 17:53:37 +02004228 if (merge) {
4229 size_t size;
Anthony Liguori7267c092011-08-20 22:09:37 -05004230 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
Kevin Wolf40b4f532009-09-09 17:53:37 +02004231 qemu_iovec_init(qiov,
4232 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4233
4234 // Add the first request to the merged one. If the requests are
4235 // overlapping, drop the last sectors of the first request.
4236 size = (reqs[i].sector - reqs[outidx].sector) << 9;
Michael Tokarev1b093c42012-03-12 21:28:06 +04004237 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004238
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01004239 // We should need to add any zeros between the two requests
4240 assert (reqs[i].sector <= oldreq_last);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004241
4242 // Add the second request
Michael Tokarev1b093c42012-03-12 21:28:06 +04004243 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004244
Kevin Wolfcbf1dff2010-05-21 11:09:42 +02004245 reqs[outidx].nb_sectors = qiov->size >> 9;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004246 reqs[outidx].qiov = qiov;
4247
4248 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4249 } else {
4250 outidx++;
4251 reqs[outidx].sector = reqs[i].sector;
4252 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4253 reqs[outidx].qiov = reqs[i].qiov;
4254 }
4255 }
4256
4257 return outidx + 1;
4258}
4259
4260/*
4261 * Submit multiple AIO write requests at once.
4262 *
4263 * On success, the function returns 0 and all requests in the reqs array have
4264 * been submitted. In error case this function returns -1, and any of the
4265 * requests may or may not be submitted yet. In particular, this means that the
4266 * callback will be called for some of the requests, for others it won't. The
4267 * caller must check the error field of the BlockRequest to wait for the right
4268 * callbacks (if error != 0, no callback will be called).
4269 *
4270 * The implementation may modify the contents of the reqs array, e.g. to merge
4271 * requests. However, the fields opaque and error are left unmodified as they
4272 * are used to signal failure for a single request to the caller.
4273 */
4274int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4275{
Kevin Wolf40b4f532009-09-09 17:53:37 +02004276 MultiwriteCB *mcb;
4277 int i;
4278
Ryan Harper301db7c2011-03-07 10:01:04 -06004279 /* don't submit writes if we don't have a medium */
4280 if (bs->drv == NULL) {
4281 for (i = 0; i < num_reqs; i++) {
4282 reqs[i].error = -ENOMEDIUM;
4283 }
4284 return -1;
4285 }
4286
Kevin Wolf40b4f532009-09-09 17:53:37 +02004287 if (num_reqs == 0) {
4288 return 0;
4289 }
4290
4291 // Create MultiwriteCB structure
Anthony Liguori7267c092011-08-20 22:09:37 -05004292 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
Kevin Wolf40b4f532009-09-09 17:53:37 +02004293 mcb->num_requests = 0;
4294 mcb->num_callbacks = num_reqs;
4295
4296 for (i = 0; i < num_reqs; i++) {
4297 mcb->callbacks[i].cb = reqs[i].cb;
4298 mcb->callbacks[i].opaque = reqs[i].opaque;
4299 }
4300
4301 // Check for mergable requests
4302 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4303
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01004304 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4305
Paolo Bonzinidf9309f2011-11-14 17:50:50 +01004306 /* Run the aio requests. */
4307 mcb->num_requests = num_reqs;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004308 for (i = 0; i < num_reqs; i++) {
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004309 bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4310 reqs[i].nb_sectors, reqs[i].flags,
4311 multiwrite_cb, mcb,
4312 true);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004313 }
4314
4315 return 0;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004316}
4317
bellard83f64092006-08-01 16:21:11 +00004318void bdrv_aio_cancel(BlockDriverAIOCB *acb)
pbrookce1a14d2006-08-07 02:38:06 +00004319{
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004320 acb->aiocb_info->cancel(acb);
bellard83f64092006-08-01 16:21:11 +00004321}
4322
4323/**************************************************************/
4324/* async block device emulation */
4325
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004326typedef struct BlockDriverAIOCBSync {
4327 BlockDriverAIOCB common;
4328 QEMUBH *bh;
4329 int ret;
4330 /* vector translation state */
4331 QEMUIOVector *qiov;
4332 uint8_t *bounce;
4333 int is_write;
4334} BlockDriverAIOCBSync;
4335
4336static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4337{
Kevin Wolfb666d232010-05-05 11:44:39 +02004338 BlockDriverAIOCBSync *acb =
4339 container_of(blockacb, BlockDriverAIOCBSync, common);
Dor Laor6a7ad292009-06-01 12:07:23 +03004340 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03004341 acb->bh = NULL;
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004342 qemu_aio_release(acb);
4343}
4344
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004345static const AIOCBInfo bdrv_em_aiocb_info = {
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004346 .aiocb_size = sizeof(BlockDriverAIOCBSync),
4347 .cancel = bdrv_aio_cancel_em,
4348};
4349
bellard83f64092006-08-01 16:21:11 +00004350static void bdrv_aio_bh_cb(void *opaque)
bellardbeac80c2006-06-26 20:08:57 +00004351{
pbrookce1a14d2006-08-07 02:38:06 +00004352 BlockDriverAIOCBSync *acb = opaque;
aliguorif141eaf2009-04-07 18:43:24 +00004353
aliguorif141eaf2009-04-07 18:43:24 +00004354 if (!acb->is_write)
Michael Tokarev03396142012-06-07 20:17:55 +04004355 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
aliguoriceb42de2009-04-07 18:43:28 +00004356 qemu_vfree(acb->bounce);
pbrookce1a14d2006-08-07 02:38:06 +00004357 acb->common.cb(acb->common.opaque, acb->ret);
Dor Laor6a7ad292009-06-01 12:07:23 +03004358 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03004359 acb->bh = NULL;
pbrookce1a14d2006-08-07 02:38:06 +00004360 qemu_aio_release(acb);
bellardbeac80c2006-06-26 20:08:57 +00004361}
bellardbeac80c2006-06-26 20:08:57 +00004362
aliguorif141eaf2009-04-07 18:43:24 +00004363static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4364 int64_t sector_num,
4365 QEMUIOVector *qiov,
4366 int nb_sectors,
4367 BlockDriverCompletionFunc *cb,
4368 void *opaque,
4369 int is_write)
4370
bellardea2384d2004-08-01 21:59:26 +00004371{
pbrookce1a14d2006-08-07 02:38:06 +00004372 BlockDriverAIOCBSync *acb;
pbrookce1a14d2006-08-07 02:38:06 +00004373
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004374 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
aliguorif141eaf2009-04-07 18:43:24 +00004375 acb->is_write = is_write;
4376 acb->qiov = qiov;
aliguorie268ca52009-04-22 20:20:00 +00004377 acb->bounce = qemu_blockalign(bs, qiov->size);
Paolo Bonzini3f3aace2011-11-14 17:50:54 +01004378 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
aliguorif141eaf2009-04-07 18:43:24 +00004379
4380 if (is_write) {
Michael Tokarevd5e6b162012-06-07 20:21:06 +04004381 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01004382 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00004383 } else {
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01004384 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00004385 }
4386
pbrookce1a14d2006-08-07 02:38:06 +00004387 qemu_bh_schedule(acb->bh);
aliguorif141eaf2009-04-07 18:43:24 +00004388
pbrookce1a14d2006-08-07 02:38:06 +00004389 return &acb->common;
pbrook7a6cba62006-06-04 11:39:07 +00004390}
4391
aliguorif141eaf2009-04-07 18:43:24 +00004392static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4393 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +00004394 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00004395{
aliguorif141eaf2009-04-07 18:43:24 +00004396 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
bellard83f64092006-08-01 16:21:11 +00004397}
4398
aliguorif141eaf2009-04-07 18:43:24 +00004399static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4400 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4401 BlockDriverCompletionFunc *cb, void *opaque)
4402{
4403 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4404}
4405
Kevin Wolf68485422011-06-30 10:05:46 +02004406
4407typedef struct BlockDriverAIOCBCoroutine {
4408 BlockDriverAIOCB common;
4409 BlockRequest req;
4410 bool is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004411 bool *done;
Kevin Wolf68485422011-06-30 10:05:46 +02004412 QEMUBH* bh;
4413} BlockDriverAIOCBCoroutine;
4414
4415static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4416{
Kevin Wolfd318aea2012-11-13 16:35:08 +01004417 BlockDriverAIOCBCoroutine *acb =
4418 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4419 bool done = false;
4420
4421 acb->done = &done;
4422 while (!done) {
4423 qemu_aio_wait();
4424 }
Kevin Wolf68485422011-06-30 10:05:46 +02004425}
4426
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004427static const AIOCBInfo bdrv_em_co_aiocb_info = {
Kevin Wolf68485422011-06-30 10:05:46 +02004428 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
4429 .cancel = bdrv_aio_co_cancel_em,
4430};
4431
Paolo Bonzini35246a62011-10-14 10:41:29 +02004432static void bdrv_co_em_bh(void *opaque)
Kevin Wolf68485422011-06-30 10:05:46 +02004433{
4434 BlockDriverAIOCBCoroutine *acb = opaque;
4435
4436 acb->common.cb(acb->common.opaque, acb->req.error);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004437
4438 if (acb->done) {
4439 *acb->done = true;
4440 }
4441
Kevin Wolf68485422011-06-30 10:05:46 +02004442 qemu_bh_delete(acb->bh);
4443 qemu_aio_release(acb);
4444}
4445
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004446/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4447static void coroutine_fn bdrv_co_do_rw(void *opaque)
4448{
4449 BlockDriverAIOCBCoroutine *acb = opaque;
4450 BlockDriverState *bs = acb->common.bs;
4451
4452 if (!acb->is_write) {
4453 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004454 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004455 } else {
4456 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004457 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004458 }
4459
Paolo Bonzini35246a62011-10-14 10:41:29 +02004460 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004461 qemu_bh_schedule(acb->bh);
4462}
4463
Kevin Wolf68485422011-06-30 10:05:46 +02004464static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4465 int64_t sector_num,
4466 QEMUIOVector *qiov,
4467 int nb_sectors,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004468 BdrvRequestFlags flags,
Kevin Wolf68485422011-06-30 10:05:46 +02004469 BlockDriverCompletionFunc *cb,
4470 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004471 bool is_write)
Kevin Wolf68485422011-06-30 10:05:46 +02004472{
4473 Coroutine *co;
4474 BlockDriverAIOCBCoroutine *acb;
4475
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004476 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolf68485422011-06-30 10:05:46 +02004477 acb->req.sector = sector_num;
4478 acb->req.nb_sectors = nb_sectors;
4479 acb->req.qiov = qiov;
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004480 acb->req.flags = flags;
Kevin Wolf68485422011-06-30 10:05:46 +02004481 acb->is_write = is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004482 acb->done = NULL;
Kevin Wolf68485422011-06-30 10:05:46 +02004483
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004484 co = qemu_coroutine_create(bdrv_co_do_rw);
Kevin Wolf68485422011-06-30 10:05:46 +02004485 qemu_coroutine_enter(co, acb);
4486
4487 return &acb->common;
4488}
4489
Paolo Bonzini07f07612011-10-17 12:32:12 +02004490static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004491{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004492 BlockDriverAIOCBCoroutine *acb = opaque;
4493 BlockDriverState *bs = acb->common.bs;
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004494
Paolo Bonzini07f07612011-10-17 12:32:12 +02004495 acb->req.error = bdrv_co_flush(bs);
4496 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004497 qemu_bh_schedule(acb->bh);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004498}
4499
Paolo Bonzini07f07612011-10-17 12:32:12 +02004500BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Alexander Graf016f5cf2010-05-26 17:51:49 +02004501 BlockDriverCompletionFunc *cb, void *opaque)
4502{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004503 trace_bdrv_aio_flush(bs, opaque);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004504
Paolo Bonzini07f07612011-10-17 12:32:12 +02004505 Coroutine *co;
4506 BlockDriverAIOCBCoroutine *acb;
Alexander Graf016f5cf2010-05-26 17:51:49 +02004507
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004508 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004509 acb->done = NULL;
4510
Paolo Bonzini07f07612011-10-17 12:32:12 +02004511 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4512 qemu_coroutine_enter(co, acb);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004513
Alexander Graf016f5cf2010-05-26 17:51:49 +02004514 return &acb->common;
4515}
4516
Paolo Bonzini4265d622011-10-17 12:32:14 +02004517static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4518{
4519 BlockDriverAIOCBCoroutine *acb = opaque;
4520 BlockDriverState *bs = acb->common.bs;
4521
4522 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4523 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
4524 qemu_bh_schedule(acb->bh);
4525}
4526
4527BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4528 int64_t sector_num, int nb_sectors,
4529 BlockDriverCompletionFunc *cb, void *opaque)
4530{
4531 Coroutine *co;
4532 BlockDriverAIOCBCoroutine *acb;
4533
4534 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4535
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004536 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +02004537 acb->req.sector = sector_num;
4538 acb->req.nb_sectors = nb_sectors;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004539 acb->done = NULL;
Paolo Bonzini4265d622011-10-17 12:32:14 +02004540 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4541 qemu_coroutine_enter(co, acb);
4542
4543 return &acb->common;
4544}
4545
bellardea2384d2004-08-01 21:59:26 +00004546void bdrv_init(void)
4547{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05004548 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00004549}
pbrookce1a14d2006-08-07 02:38:06 +00004550
Markus Armbrustereb852012009-10-27 18:41:44 +01004551void bdrv_init_with_whitelist(void)
4552{
4553 use_bdrv_whitelist = 1;
4554 bdrv_init();
4555}
4556
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004557void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004558 BlockDriverCompletionFunc *cb, void *opaque)
aliguori6bbff9a2009-03-20 18:25:59 +00004559{
pbrookce1a14d2006-08-07 02:38:06 +00004560 BlockDriverAIOCB *acb;
4561
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004562 acb = g_slice_alloc(aiocb_info->aiocb_size);
4563 acb->aiocb_info = aiocb_info;
pbrookce1a14d2006-08-07 02:38:06 +00004564 acb->bs = bs;
4565 acb->cb = cb;
4566 acb->opaque = opaque;
4567 return acb;
4568}
4569
4570void qemu_aio_release(void *p)
4571{
Stefan Hajnoczid37c9752012-10-31 16:34:36 +01004572 BlockDriverAIOCB *acb = p;
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004573 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
pbrookce1a14d2006-08-07 02:38:06 +00004574}
bellard19cb3732006-08-19 11:45:59 +00004575
4576/**************************************************************/
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004577/* Coroutine block device emulation */
4578
4579typedef struct CoroutineIOCompletion {
4580 Coroutine *coroutine;
4581 int ret;
4582} CoroutineIOCompletion;
4583
4584static void bdrv_co_io_em_complete(void *opaque, int ret)
4585{
4586 CoroutineIOCompletion *co = opaque;
4587
4588 co->ret = ret;
4589 qemu_coroutine_enter(co->coroutine, NULL);
4590}
4591
4592static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4593 int nb_sectors, QEMUIOVector *iov,
4594 bool is_write)
4595{
4596 CoroutineIOCompletion co = {
4597 .coroutine = qemu_coroutine_self(),
4598 };
4599 BlockDriverAIOCB *acb;
4600
4601 if (is_write) {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004602 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4603 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004604 } else {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004605 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4606 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004607 }
4608
Stefan Hajnoczi59370aa2011-09-30 17:34:58 +01004609 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004610 if (!acb) {
4611 return -EIO;
4612 }
4613 qemu_coroutine_yield();
4614
4615 return co.ret;
4616}
4617
4618static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4619 int64_t sector_num, int nb_sectors,
4620 QEMUIOVector *iov)
4621{
4622 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4623}
4624
4625static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4626 int64_t sector_num, int nb_sectors,
4627 QEMUIOVector *iov)
4628{
4629 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4630}
4631
Paolo Bonzini07f07612011-10-17 12:32:12 +02004632static void coroutine_fn bdrv_flush_co_entry(void *opaque)
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004633{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004634 RwCo *rwco = opaque;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004635
Paolo Bonzini07f07612011-10-17 12:32:12 +02004636 rwco->ret = bdrv_co_flush(rwco->bs);
4637}
4638
4639int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4640{
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004641 int ret;
4642
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004643 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Paolo Bonzini07f07612011-10-17 12:32:12 +02004644 return 0;
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004645 }
4646
Kevin Wolfca716362011-11-10 18:13:59 +01004647 /* Write back cached data to the OS even with cache=unsafe */
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004648 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004649 if (bs->drv->bdrv_co_flush_to_os) {
4650 ret = bs->drv->bdrv_co_flush_to_os(bs);
4651 if (ret < 0) {
4652 return ret;
4653 }
4654 }
4655
Kevin Wolfca716362011-11-10 18:13:59 +01004656 /* But don't actually force it to the disk with cache=unsafe */
4657 if (bs->open_flags & BDRV_O_NO_FLUSH) {
Kevin Wolfd4c82322012-08-15 12:52:45 +02004658 goto flush_parent;
Kevin Wolfca716362011-11-10 18:13:59 +01004659 }
4660
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004661 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004662 if (bs->drv->bdrv_co_flush_to_disk) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004663 ret = bs->drv->bdrv_co_flush_to_disk(bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004664 } else if (bs->drv->bdrv_aio_flush) {
4665 BlockDriverAIOCB *acb;
4666 CoroutineIOCompletion co = {
4667 .coroutine = qemu_coroutine_self(),
4668 };
4669
4670 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4671 if (acb == NULL) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004672 ret = -EIO;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004673 } else {
4674 qemu_coroutine_yield();
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004675 ret = co.ret;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004676 }
Paolo Bonzini07f07612011-10-17 12:32:12 +02004677 } else {
4678 /*
4679 * Some block drivers always operate in either writethrough or unsafe
4680 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4681 * know how the server works (because the behaviour is hardcoded or
4682 * depends on server-side configuration), so we can't ensure that
4683 * everything is safe on disk. Returning an error doesn't work because
4684 * that would break guests even if the server operates in writethrough
4685 * mode.
4686 *
4687 * Let's hope the user knows what he's doing.
4688 */
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004689 ret = 0;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004690 }
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004691 if (ret < 0) {
4692 return ret;
4693 }
4694
4695 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4696 * in the case of cache=unsafe, so there are no useless flushes.
4697 */
Kevin Wolfd4c82322012-08-15 12:52:45 +02004698flush_parent:
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004699 return bdrv_co_flush(bs->file);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004700}
4701
Anthony Liguori0f154232011-11-14 15:09:45 -06004702void bdrv_invalidate_cache(BlockDriverState *bs)
4703{
4704 if (bs->drv && bs->drv->bdrv_invalidate_cache) {
4705 bs->drv->bdrv_invalidate_cache(bs);
4706 }
4707}
4708
4709void bdrv_invalidate_cache_all(void)
4710{
4711 BlockDriverState *bs;
4712
Benoît Canetdc364f42014-01-23 21:31:32 +01004713 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Anthony Liguori0f154232011-11-14 15:09:45 -06004714 bdrv_invalidate_cache(bs);
4715 }
4716}
4717
Benoît Canet07789262012-03-23 08:36:49 +01004718void bdrv_clear_incoming_migration_all(void)
4719{
4720 BlockDriverState *bs;
4721
Benoît Canetdc364f42014-01-23 21:31:32 +01004722 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Benoît Canet07789262012-03-23 08:36:49 +01004723 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
4724 }
4725}
4726
Paolo Bonzini07f07612011-10-17 12:32:12 +02004727int bdrv_flush(BlockDriverState *bs)
4728{
4729 Coroutine *co;
4730 RwCo rwco = {
4731 .bs = bs,
4732 .ret = NOT_DONE,
4733 };
4734
4735 if (qemu_in_coroutine()) {
4736 /* Fast-path if already in coroutine context */
4737 bdrv_flush_co_entry(&rwco);
4738 } else {
4739 co = qemu_coroutine_create(bdrv_flush_co_entry);
4740 qemu_coroutine_enter(co, &rwco);
4741 while (rwco.ret == NOT_DONE) {
4742 qemu_aio_wait();
4743 }
4744 }
4745
4746 return rwco.ret;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004747}
4748
Paolo Bonzini4265d622011-10-17 12:32:14 +02004749static void coroutine_fn bdrv_discard_co_entry(void *opaque)
4750{
4751 RwCo *rwco = opaque;
4752
4753 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
4754}
4755
Peter Lieven6f14da52013-10-24 12:06:59 +02004756/* if no limit is specified in the BlockLimits use a default
4757 * of 32768 512-byte sectors (16 MiB) per request.
4758 */
4759#define MAX_DISCARD_DEFAULT 32768
4760
Paolo Bonzini4265d622011-10-17 12:32:14 +02004761int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
4762 int nb_sectors)
4763{
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01004764 int max_discard;
4765
Paolo Bonzini4265d622011-10-17 12:32:14 +02004766 if (!bs->drv) {
4767 return -ENOMEDIUM;
4768 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
4769 return -EIO;
4770 } else if (bs->read_only) {
4771 return -EROFS;
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004772 }
4773
Fam Zhenge4654d22013-11-13 18:29:43 +08004774 bdrv_reset_dirty(bs, sector_num, nb_sectors);
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004775
Paolo Bonzini9e8f1832013-02-08 14:06:11 +01004776 /* Do nothing if disabled. */
4777 if (!(bs->open_flags & BDRV_O_UNMAP)) {
4778 return 0;
4779 }
4780
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01004781 if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
Paolo Bonzini4265d622011-10-17 12:32:14 +02004782 return 0;
4783 }
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01004784
4785 max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT;
4786 while (nb_sectors > 0) {
4787 int ret;
4788 int num = nb_sectors;
4789
4790 /* align request */
4791 if (bs->bl.discard_alignment &&
4792 num >= bs->bl.discard_alignment &&
4793 sector_num % bs->bl.discard_alignment) {
4794 if (num > bs->bl.discard_alignment) {
4795 num = bs->bl.discard_alignment;
4796 }
4797 num -= sector_num % bs->bl.discard_alignment;
4798 }
4799
4800 /* limit request size */
4801 if (num > max_discard) {
4802 num = max_discard;
4803 }
4804
4805 if (bs->drv->bdrv_co_discard) {
4806 ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
4807 } else {
4808 BlockDriverAIOCB *acb;
4809 CoroutineIOCompletion co = {
4810 .coroutine = qemu_coroutine_self(),
4811 };
4812
4813 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
4814 bdrv_co_io_em_complete, &co);
4815 if (acb == NULL) {
4816 return -EIO;
4817 } else {
4818 qemu_coroutine_yield();
4819 ret = co.ret;
4820 }
4821 }
Paolo Bonzini7ce21012013-11-22 13:39:47 +01004822 if (ret && ret != -ENOTSUP) {
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01004823 return ret;
4824 }
4825
4826 sector_num += num;
4827 nb_sectors -= num;
4828 }
4829 return 0;
Paolo Bonzini4265d622011-10-17 12:32:14 +02004830}
4831
4832int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
4833{
4834 Coroutine *co;
4835 RwCo rwco = {
4836 .bs = bs,
4837 .sector_num = sector_num,
4838 .nb_sectors = nb_sectors,
4839 .ret = NOT_DONE,
4840 };
4841
4842 if (qemu_in_coroutine()) {
4843 /* Fast-path if already in coroutine context */
4844 bdrv_discard_co_entry(&rwco);
4845 } else {
4846 co = qemu_coroutine_create(bdrv_discard_co_entry);
4847 qemu_coroutine_enter(co, &rwco);
4848 while (rwco.ret == NOT_DONE) {
4849 qemu_aio_wait();
4850 }
4851 }
4852
4853 return rwco.ret;
4854}
4855
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004856/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00004857/* removable device support */
4858
4859/**
4860 * Return TRUE if the media is present
4861 */
4862int bdrv_is_inserted(BlockDriverState *bs)
4863{
4864 BlockDriver *drv = bs->drv;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02004865
bellard19cb3732006-08-19 11:45:59 +00004866 if (!drv)
4867 return 0;
4868 if (!drv->bdrv_is_inserted)
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02004869 return 1;
4870 return drv->bdrv_is_inserted(bs);
bellard19cb3732006-08-19 11:45:59 +00004871}
4872
4873/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02004874 * Return whether the media changed since the last call to this
4875 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00004876 */
4877int bdrv_media_changed(BlockDriverState *bs)
4878{
4879 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00004880
Markus Armbruster8e49ca42011-08-03 15:08:08 +02004881 if (drv && drv->bdrv_media_changed) {
4882 return drv->bdrv_media_changed(bs);
4883 }
4884 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00004885}
4886
4887/**
4888 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4889 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02004890void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00004891{
4892 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00004893
Markus Armbruster822e1cd2011-07-20 18:23:42 +02004894 if (drv && drv->bdrv_eject) {
4895 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00004896 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02004897
4898 if (bs->device_name[0] != '\0') {
4899 bdrv_emit_qmp_eject_event(bs, eject_flag);
4900 }
bellard19cb3732006-08-19 11:45:59 +00004901}
4902
bellard19cb3732006-08-19 11:45:59 +00004903/**
4904 * Lock or unlock the media (if it is locked, the user won't be able
4905 * to eject it manually).
4906 */
Markus Armbruster025e8492011-09-06 18:58:47 +02004907void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00004908{
4909 BlockDriver *drv = bs->drv;
4910
Markus Armbruster025e8492011-09-06 18:58:47 +02004911 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01004912
Markus Armbruster025e8492011-09-06 18:58:47 +02004913 if (drv && drv->bdrv_lock_medium) {
4914 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00004915 }
4916}
ths985a03b2007-12-24 16:10:43 +00004917
4918/* needed for generic scsi interface */
4919
4920int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
4921{
4922 BlockDriver *drv = bs->drv;
4923
4924 if (drv && drv->bdrv_ioctl)
4925 return drv->bdrv_ioctl(bs, req, buf);
4926 return -ENOTSUP;
4927}
aliguori7d780662009-03-12 19:57:08 +00004928
aliguori221f7152009-03-28 17:28:41 +00004929BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
4930 unsigned long int req, void *buf,
4931 BlockDriverCompletionFunc *cb, void *opaque)
aliguori7d780662009-03-12 19:57:08 +00004932{
aliguori221f7152009-03-28 17:28:41 +00004933 BlockDriver *drv = bs->drv;
aliguori7d780662009-03-12 19:57:08 +00004934
aliguori221f7152009-03-28 17:28:41 +00004935 if (drv && drv->bdrv_aio_ioctl)
4936 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
4937 return NULL;
aliguori7d780662009-03-12 19:57:08 +00004938}
aliguorie268ca52009-04-22 20:20:00 +00004939
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01004940void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
Markus Armbruster7b6f9302011-09-06 18:58:56 +02004941{
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01004942 bs->guest_block_size = align;
Markus Armbruster7b6f9302011-09-06 18:58:56 +02004943}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004944
aliguorie268ca52009-04-22 20:20:00 +00004945void *qemu_blockalign(BlockDriverState *bs, size_t size)
4946{
Kevin Wolf339064d2013-11-28 10:23:32 +01004947 return qemu_memalign(bdrv_opt_mem_align(bs), size);
aliguorie268ca52009-04-22 20:20:00 +00004948}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004949
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01004950/*
4951 * Check if all memory in this vector is sector aligned.
4952 */
4953bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
4954{
4955 int i;
Kevin Wolf339064d2013-11-28 10:23:32 +01004956 size_t alignment = bdrv_opt_mem_align(bs);
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01004957
4958 for (i = 0; i < qiov->niov; i++) {
Kevin Wolf339064d2013-11-28 10:23:32 +01004959 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01004960 return false;
4961 }
Kevin Wolf339064d2013-11-28 10:23:32 +01004962 if (qiov->iov[i].iov_len % alignment) {
Kevin Wolf1ff735b2013-12-05 13:01:46 +01004963 return false;
4964 }
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01004965 }
4966
4967 return true;
4968}
4969
Fam Zhenge4654d22013-11-13 18:29:43 +08004970BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004971{
4972 int64_t bitmap_size;
Fam Zhenge4654d22013-11-13 18:29:43 +08004973 BdrvDirtyBitmap *bitmap;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004974
Paolo Bonzini50717e92013-01-21 17:09:45 +01004975 assert((granularity & (granularity - 1)) == 0);
4976
Fam Zhenge4654d22013-11-13 18:29:43 +08004977 granularity >>= BDRV_SECTOR_BITS;
4978 assert(granularity);
4979 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS);
4980 bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
4981 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
4982 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
4983 return bitmap;
4984}
4985
4986void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
4987{
4988 BdrvDirtyBitmap *bm, *next;
4989 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
4990 if (bm == bitmap) {
4991 QLIST_REMOVE(bitmap, list);
4992 hbitmap_free(bitmap->bitmap);
4993 g_free(bitmap);
4994 return;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004995 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004996 }
4997}
4998
Fam Zheng21b56832013-11-13 18:29:44 +08004999BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5000{
5001 BdrvDirtyBitmap *bm;
5002 BlockDirtyInfoList *list = NULL;
5003 BlockDirtyInfoList **plist = &list;
5004
5005 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5006 BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
5007 BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
5008 info->count = bdrv_get_dirty_count(bs, bm);
5009 info->granularity =
5010 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5011 entry->value = info;
5012 *plist = entry;
5013 plist = &entry->next;
5014 }
5015
5016 return list;
5017}
5018
Fam Zhenge4654d22013-11-13 18:29:43 +08005019int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005020{
Fam Zhenge4654d22013-11-13 18:29:43 +08005021 if (bitmap) {
5022 return hbitmap_get(bitmap->bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005023 } else {
5024 return 0;
5025 }
5026}
5027
Fam Zhenge4654d22013-11-13 18:29:43 +08005028void bdrv_dirty_iter_init(BlockDriverState *bs,
5029 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02005030{
Fam Zhenge4654d22013-11-13 18:29:43 +08005031 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02005032}
5033
5034void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5035 int nr_sectors)
5036{
Fam Zhenge4654d22013-11-13 18:29:43 +08005037 BdrvDirtyBitmap *bitmap;
5038 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5039 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01005040 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02005041}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005042
Fam Zhenge4654d22013-11-13 18:29:43 +08005043void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5044{
5045 BdrvDirtyBitmap *bitmap;
5046 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5047 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5048 }
5049}
5050
5051int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5052{
5053 return hbitmap_count(bitmap->bitmap);
5054}
5055
Fam Zheng9fcb0252013-08-23 09:14:46 +08005056/* Get a reference to bs */
5057void bdrv_ref(BlockDriverState *bs)
5058{
5059 bs->refcnt++;
5060}
5061
5062/* Release a previously grabbed reference to bs.
5063 * If after releasing, reference count is zero, the BlockDriverState is
5064 * deleted. */
5065void bdrv_unref(BlockDriverState *bs)
5066{
5067 assert(bs->refcnt > 0);
5068 if (--bs->refcnt == 0) {
5069 bdrv_delete(bs);
5070 }
5071}
5072
Marcelo Tosattidb593f22011-01-26 12:12:34 -02005073void bdrv_set_in_use(BlockDriverState *bs, int in_use)
5074{
5075 assert(bs->in_use != in_use);
5076 bs->in_use = in_use;
5077}
5078
5079int bdrv_in_use(BlockDriverState *bs)
5080{
5081 return bs->in_use;
5082}
5083
Luiz Capitulino28a72822011-09-26 17:43:50 -03005084void bdrv_iostatus_enable(BlockDriverState *bs)
5085{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005086 bs->iostatus_enabled = true;
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005087 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005088}
5089
5090/* The I/O status is only enabled if the drive explicitly
5091 * enables it _and_ the VM is configured to stop on errors */
5092bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5093{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005094 return (bs->iostatus_enabled &&
Paolo Bonzini92aa5c62012-09-28 17:22:55 +02005095 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5096 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
5097 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
Luiz Capitulino28a72822011-09-26 17:43:50 -03005098}
5099
5100void bdrv_iostatus_disable(BlockDriverState *bs)
5101{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005102 bs->iostatus_enabled = false;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005103}
5104
5105void bdrv_iostatus_reset(BlockDriverState *bs)
5106{
5107 if (bdrv_iostatus_is_enabled(bs)) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005108 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Paolo Bonzini3bd293c2012-10-18 16:49:27 +02005109 if (bs->job) {
5110 block_job_iostatus_reset(bs->job);
5111 }
Luiz Capitulino28a72822011-09-26 17:43:50 -03005112 }
5113}
5114
Luiz Capitulino28a72822011-09-26 17:43:50 -03005115void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5116{
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02005117 assert(bdrv_iostatus_is_enabled(bs));
5118 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005119 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5120 BLOCK_DEVICE_IO_STATUS_FAILED;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005121 }
5122}
5123
Christoph Hellwiga597e792011-08-25 08:26:01 +02005124void
5125bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5126 enum BlockAcctType type)
5127{
5128 assert(type < BDRV_MAX_IOTYPE);
5129
5130 cookie->bytes = bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02005131 cookie->start_time_ns = get_clock();
Christoph Hellwiga597e792011-08-25 08:26:01 +02005132 cookie->type = type;
5133}
5134
5135void
5136bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5137{
5138 assert(cookie->type < BDRV_MAX_IOTYPE);
5139
5140 bs->nr_bytes[cookie->type] += cookie->bytes;
5141 bs->nr_ops[cookie->type]++;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02005142 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +02005143}
5144
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005145void bdrv_img_create(const char *filename, const char *fmt,
5146 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005147 char *options, uint64_t img_size, int flags,
5148 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005149{
5150 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolfd2208942011-06-01 14:03:31 +02005151 QEMUOptionParameter *backing_fmt, *backing_file, *size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005152 BlockDriver *drv, *proto_drv;
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00005153 BlockDriver *backing_drv = NULL;
Max Reitzcc84d902013-09-06 17:14:26 +02005154 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005155 int ret = 0;
5156
5157 /* Find driver and parse its options */
5158 drv = bdrv_find_format(fmt);
5159 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005160 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005161 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005162 }
5163
Kevin Wolf98289622013-07-10 15:47:39 +02005164 proto_drv = bdrv_find_protocol(filename, true);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005165 if (!proto_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005166 error_setg(errp, "Unknown protocol '%s'", filename);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005167 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005168 }
5169
5170 create_options = append_option_parameters(create_options,
5171 drv->create_options);
5172 create_options = append_option_parameters(create_options,
5173 proto_drv->create_options);
5174
5175 /* Create parameter list with default values */
5176 param = parse_option_parameters("", create_options, param);
5177
5178 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
5179
5180 /* Parse -o options */
5181 if (options) {
5182 param = parse_option_parameters(options, create_options, param);
5183 if (param == NULL) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005184 error_setg(errp, "Invalid options for file format '%s'.", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005185 goto out;
5186 }
5187 }
5188
5189 if (base_filename) {
5190 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
5191 base_filename)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005192 error_setg(errp, "Backing file not supported for file format '%s'",
5193 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005194 goto out;
5195 }
5196 }
5197
5198 if (base_fmt) {
5199 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005200 error_setg(errp, "Backing file format not supported for file "
5201 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005202 goto out;
5203 }
5204 }
5205
Jes Sorensen792da932010-12-16 13:52:17 +01005206 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
5207 if (backing_file && backing_file->value.s) {
5208 if (!strcmp(filename, backing_file->value.s)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005209 error_setg(errp, "Error: Trying to create an image with the "
5210 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01005211 goto out;
5212 }
5213 }
5214
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005215 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
5216 if (backing_fmt && backing_fmt->value.s) {
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00005217 backing_drv = bdrv_find_format(backing_fmt->value.s);
5218 if (!backing_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005219 error_setg(errp, "Unknown backing file format '%s'",
5220 backing_fmt->value.s);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005221 goto out;
5222 }
5223 }
5224
5225 // The size for the image must always be specified, with one exception:
5226 // If we are using a backing file, we can obtain the size from there
Kevin Wolfd2208942011-06-01 14:03:31 +02005227 size = get_option_parameter(param, BLOCK_OPT_SIZE);
5228 if (size && size->value.n == -1) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005229 if (backing_file && backing_file->value.s) {
Max Reitz66f6b812013-12-03 14:57:52 +01005230 BlockDriverState *bs;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005231 uint64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005232 char buf[32];
Paolo Bonzini63090da2012-04-12 14:01:03 +02005233 int back_flags;
5234
5235 /* backing files always opened read-only */
5236 back_flags =
5237 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005238
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005239 bs = bdrv_new("");
5240
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01005241 ret = bdrv_open(bs, backing_file->value.s, NULL, back_flags,
Max Reitzcc84d902013-09-06 17:14:26 +02005242 backing_drv, &local_err);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005243 if (ret < 0) {
Max Reitzcc84d902013-09-06 17:14:26 +02005244 error_setg_errno(errp, -ret, "Could not open '%s': %s",
5245 backing_file->value.s,
5246 error_get_pretty(local_err));
5247 error_free(local_err);
5248 local_err = NULL;
Max Reitz66f6b812013-12-03 14:57:52 +01005249 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005250 goto out;
5251 }
5252 bdrv_get_geometry(bs, &size);
5253 size *= 512;
5254
5255 snprintf(buf, sizeof(buf), "%" PRId64, size);
5256 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
Max Reitz66f6b812013-12-03 14:57:52 +01005257
5258 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005259 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005260 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005261 goto out;
5262 }
5263 }
5264
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005265 if (!quiet) {
5266 printf("Formatting '%s', fmt=%s ", filename, fmt);
5267 print_option_parameters(param);
5268 puts("");
5269 }
Max Reitzcc84d902013-09-06 17:14:26 +02005270 ret = bdrv_create(drv, filename, param, &local_err);
5271 if (ret == -EFBIG) {
5272 /* This is generally a better message than whatever the driver would
5273 * deliver (especially because of the cluster_size_hint), since that
5274 * is most probably not much different from "image too large". */
5275 const char *cluster_size_hint = "";
5276 if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
5277 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005278 }
Max Reitzcc84d902013-09-06 17:14:26 +02005279 error_setg(errp, "The image size is too large for file format '%s'"
5280 "%s", fmt, cluster_size_hint);
5281 error_free(local_err);
5282 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005283 }
5284
5285out:
5286 free_option_parameters(create_options);
5287 free_option_parameters(param);
5288
Max Reitzcc84d902013-09-06 17:14:26 +02005289 if (error_is_set(&local_err)) {
5290 error_propagate(errp, local_err);
5291 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005292}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01005293
5294AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5295{
5296 /* Currently BlockDriverState always uses the main loop AioContext */
5297 return qemu_get_aio_context();
5298}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02005299
5300void bdrv_add_before_write_notifier(BlockDriverState *bs,
5301 NotifierWithReturn *notifier)
5302{
5303 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5304}
Max Reitz6f176b42013-09-03 10:09:50 +02005305
5306int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options)
5307{
5308 if (bs->drv->bdrv_amend_options == NULL) {
5309 return -ENOTSUP;
5310 }
5311 return bs->drv->bdrv_amend_options(bs, options);
5312}
Benoît Canetf6186f42013-10-02 14:33:48 +02005313
Benoît Canet212a5a82014-01-23 21:31:36 +01005314/* Used to recurse on single child block filters.
5315 * Single child block filter will store their child in bs->file.
5316 */
5317bool bdrv_generic_is_first_non_filter(BlockDriverState *bs,
5318 BlockDriverState *candidate)
Benoît Canetf6186f42013-10-02 14:33:48 +02005319{
Benoît Canet212a5a82014-01-23 21:31:36 +01005320 if (!bs->drv) {
5321 return false;
Benoît Canetf6186f42013-10-02 14:33:48 +02005322 }
5323
Benoît Canet212a5a82014-01-23 21:31:36 +01005324 if (!bs->drv->authorizations[BS_IS_A_FILTER]) {
5325 if (bs == candidate) {
5326 return true;
5327 } else {
5328 return false;
5329 }
Benoît Canetf6186f42013-10-02 14:33:48 +02005330 }
5331
Benoît Canet212a5a82014-01-23 21:31:36 +01005332 if (!bs->drv->authorizations[BS_FILTER_PASS_DOWN]) {
5333 return false;
5334 }
5335
5336 if (!bs->file) {
5337 return false;
5338 }
5339
5340 return bdrv_recurse_is_first_non_filter(bs->file, candidate);
Benoît Canetf6186f42013-10-02 14:33:48 +02005341}
5342
Benoît Canet212a5a82014-01-23 21:31:36 +01005343bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5344 BlockDriverState *candidate)
Benoît Canetf6186f42013-10-02 14:33:48 +02005345{
Benoît Canet212a5a82014-01-23 21:31:36 +01005346 if (bs->drv && bs->drv->bdrv_recurse_is_first_non_filter) {
5347 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5348 }
5349
5350 return bdrv_generic_is_first_non_filter(bs, candidate);
5351}
5352
5353/* This function checks if the candidate is the first non filter bs down it's
5354 * bs chain. Since we don't have pointers to parents it explore all bs chains
5355 * from the top. Some filters can choose not to pass down the recursion.
5356 */
5357bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5358{
5359 BlockDriverState *bs;
5360
5361 /* walk down the bs forest recursively */
5362 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5363 bool perm;
5364
5365 if (!bs->file) {
5366 continue;
5367 }
5368
5369 perm = bdrv_recurse_is_first_non_filter(bs->file, candidate);
5370
5371 /* candidate is the first non filter */
5372 if (perm) {
5373 return true;
5374 }
5375 }
5376
5377 return false;
Benoît Canetf6186f42013-10-02 14:33:48 +02005378}