blob: 3d78581c6379629880baf59fce0ddbcf6056b972 [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"
Luiz Capitulinob2023812011-09-21 17:16:47 -030035#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010036#include "qemu/timer.h"
bellardfc01f7e2003-06-30 10:03:06 +000037
Juan Quintela71e72a12009-07-27 16:12:56 +020038#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000039#include <sys/types.h>
40#include <sys/stat.h>
41#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000042#include <sys/queue.h>
blueswir1c5e97232009-03-07 20:06:23 +000043#ifndef __DragonFly__
bellard7674e7b2005-04-26 21:59:26 +000044#include <sys/disk.h>
45#endif
blueswir1c5e97232009-03-07 20:06:23 +000046#endif
bellard7674e7b2005-04-26 21:59:26 +000047
aliguori49dc7682009-03-08 16:26:59 +000048#ifdef _WIN32
49#include <windows.h>
50#endif
51
Fam Zhenge4654d22013-11-13 18:29:43 +080052struct BdrvDirtyBitmap {
53 HBitmap *bitmap;
54 QLIST_ENTRY(BdrvDirtyBitmap) list;
55};
56
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010057#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
58
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +020059static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
aliguorif141eaf2009-04-07 18:43:24 +000060static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
61 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
aliguoric87c0672009-04-07 18:43:20 +000062 BlockDriverCompletionFunc *cb, void *opaque);
aliguorif141eaf2009-04-07 18:43:24 +000063static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
64 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +000065 BlockDriverCompletionFunc *cb, void *opaque);
Kevin Wolff9f05dc2011-07-15 13:50:26 +020066static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
67 int64_t sector_num, int nb_sectors,
68 QEMUIOVector *iov);
69static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
70 int64_t sector_num, int nb_sectors,
71 QEMUIOVector *iov);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +010072static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +000073 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
74 BdrvRequestFlags flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010075static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +000076 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
77 BdrvRequestFlags flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010078static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
79 int64_t sector_num,
80 QEMUIOVector *qiov,
81 int nb_sectors,
82 BlockDriverCompletionFunc *cb,
83 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +010084 bool is_write);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010085static void coroutine_fn bdrv_co_do_rw(void *opaque);
Kevin Wolf621f0582012-03-20 15:12:58 +010086static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +020087 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
bellardec530c82006-04-25 22:36:06 +000088
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +010089static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
90 QTAILQ_HEAD_INITIALIZER(bdrv_states);
blueswir17ee930d2008-09-17 19:04:14 +000091
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010092static QLIST_HEAD(, BlockDriver) bdrv_drivers =
93 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +000094
Markus Armbrustereb852012009-10-27 18:41:44 +010095/* If non-zero, use only whitelisted block drivers */
96static int use_bdrv_whitelist;
97
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +000098#ifdef _WIN32
99static int is_windows_drive_prefix(const char *filename)
100{
101 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
102 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
103 filename[1] == ':');
104}
105
106int is_windows_drive(const char *filename)
107{
108 if (is_windows_drive_prefix(filename) &&
109 filename[2] == '\0')
110 return 1;
111 if (strstart(filename, "\\\\.\\", NULL) ||
112 strstart(filename, "//./", NULL))
113 return 1;
114 return 0;
115}
116#endif
117
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800118/* throttling disk I/O limits */
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200119void bdrv_set_io_limits(BlockDriverState *bs,
120 ThrottleConfig *cfg)
121{
122 int i;
123
124 throttle_config(&bs->throttle_state, cfg);
125
126 for (i = 0; i < 2; i++) {
127 qemu_co_enter_next(&bs->throttled_reqs[i]);
128 }
129}
130
131/* this function drain all the throttled IOs */
132static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
133{
134 bool drained = false;
135 bool enabled = bs->io_limits_enabled;
136 int i;
137
138 bs->io_limits_enabled = false;
139
140 for (i = 0; i < 2; i++) {
141 while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
142 drained = true;
143 }
144 }
145
146 bs->io_limits_enabled = enabled;
147
148 return drained;
149}
150
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800151void bdrv_io_limits_disable(BlockDriverState *bs)
152{
153 bs->io_limits_enabled = false;
154
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200155 bdrv_start_throttled_reqs(bs);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800156
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200157 throttle_destroy(&bs->throttle_state);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800158}
159
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200160static void bdrv_throttle_read_timer_cb(void *opaque)
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800161{
162 BlockDriverState *bs = opaque;
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200163 qemu_co_enter_next(&bs->throttled_reqs[0]);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800164}
165
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200166static void bdrv_throttle_write_timer_cb(void *opaque)
167{
168 BlockDriverState *bs = opaque;
169 qemu_co_enter_next(&bs->throttled_reqs[1]);
170}
171
172/* should be called before bdrv_set_io_limits if a limit is set */
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800173void bdrv_io_limits_enable(BlockDriverState *bs)
174{
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200175 assert(!bs->io_limits_enabled);
176 throttle_init(&bs->throttle_state,
177 QEMU_CLOCK_VIRTUAL,
178 bdrv_throttle_read_timer_cb,
179 bdrv_throttle_write_timer_cb,
180 bs);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800181 bs->io_limits_enabled = true;
182}
183
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200184/* This function makes an IO wait if needed
185 *
186 * @nb_sectors: the number of sectors of the IO
187 * @is_write: is the IO a write
188 */
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800189static void bdrv_io_limits_intercept(BlockDriverState *bs,
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200190 int nb_sectors,
191 bool is_write)
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800192{
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200193 /* does this io must wait */
194 bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800195
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200196 /* if must wait or any request of this type throttled queue the IO */
197 if (must_wait ||
198 !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
199 qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800200 }
201
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200202 /* the IO will be executed, do the accounting */
203 throttle_account(&bs->throttle_state,
204 is_write,
205 nb_sectors * BDRV_SECTOR_SIZE);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800206
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200207 /* if the next request must wait -> do nothing */
208 if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
209 return;
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800210 }
211
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200212 /* else queue next request for execution */
213 qemu_co_queue_next(&bs->throttled_reqs[is_write]);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800214}
215
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000216/* check if the path starts with "<protocol>:" */
217static int path_has_protocol(const char *path)
218{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200219 const char *p;
220
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000221#ifdef _WIN32
222 if (is_windows_drive(path) ||
223 is_windows_drive_prefix(path)) {
224 return 0;
225 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200226 p = path + strcspn(path, ":/\\");
227#else
228 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000229#endif
230
Paolo Bonzini947995c2012-05-08 16:51:48 +0200231 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000232}
233
bellard83f64092006-08-01 16:21:11 +0000234int path_is_absolute(const char *path)
235{
bellard21664422007-01-07 18:22:37 +0000236#ifdef _WIN32
237 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200238 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000239 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200240 }
241 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000242#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200243 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000244#endif
bellard83f64092006-08-01 16:21:11 +0000245}
246
247/* if filename is absolute, just copy it to dest. Otherwise, build a
248 path to it by considering it is relative to base_path. URL are
249 supported. */
250void path_combine(char *dest, int dest_size,
251 const char *base_path,
252 const char *filename)
253{
254 const char *p, *p1;
255 int len;
256
257 if (dest_size <= 0)
258 return;
259 if (path_is_absolute(filename)) {
260 pstrcpy(dest, dest_size, filename);
261 } else {
262 p = strchr(base_path, ':');
263 if (p)
264 p++;
265 else
266 p = base_path;
bellard3b9f94e2007-01-07 17:27:07 +0000267 p1 = strrchr(base_path, '/');
268#ifdef _WIN32
269 {
270 const char *p2;
271 p2 = strrchr(base_path, '\\');
272 if (!p1 || p2 > p1)
273 p1 = p2;
274 }
275#endif
bellard83f64092006-08-01 16:21:11 +0000276 if (p1)
277 p1++;
278 else
279 p1 = base_path;
280 if (p1 > p)
281 p = p1;
282 len = p - base_path;
283 if (len > dest_size - 1)
284 len = dest_size - 1;
285 memcpy(dest, base_path, len);
286 dest[len] = '\0';
287 pstrcat(dest, dest_size, filename);
288 }
289}
290
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200291void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
292{
293 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
294 pstrcpy(dest, sz, bs->backing_file);
295 } else {
296 path_combine(dest, sz, bs->filename, bs->backing_file);
297 }
298}
299
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500300void bdrv_register(BlockDriver *bdrv)
bellardea2384d2004-08-01 21:59:26 +0000301{
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +0100302 /* Block drivers without coroutine functions need emulation */
303 if (!bdrv->bdrv_co_readv) {
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200304 bdrv->bdrv_co_readv = bdrv_co_readv_em;
305 bdrv->bdrv_co_writev = bdrv_co_writev_em;
306
Stefan Hajnoczif8c35c12011-10-13 21:09:31 +0100307 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
308 * the block driver lacks aio we need to emulate that too.
309 */
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200310 if (!bdrv->bdrv_aio_readv) {
311 /* add AIO emulation layer */
312 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
313 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200314 }
bellard83f64092006-08-01 16:21:11 +0000315 }
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +0200316
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100317 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000318}
bellardb3380822004-03-14 21:38:54 +0000319
320/* create a new block device (by default it is empty) */
321BlockDriverState *bdrv_new(const char *device_name)
bellardfc01f7e2003-06-30 10:03:06 +0000322{
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +0100323 BlockDriverState *bs;
bellardb3380822004-03-14 21:38:54 +0000324
Anthony Liguori7267c092011-08-20 22:09:37 -0500325 bs = g_malloc0(sizeof(BlockDriverState));
Fam Zhenge4654d22013-11-13 18:29:43 +0800326 QLIST_INIT(&bs->dirty_bitmaps);
bellardb3380822004-03-14 21:38:54 +0000327 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
bellardea2384d2004-08-01 21:59:26 +0000328 if (device_name[0] != '\0') {
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +0100329 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
bellardea2384d2004-08-01 21:59:26 +0000330 }
Luiz Capitulino28a72822011-09-26 17:43:50 -0300331 bdrv_iostatus_disable(bs);
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200332 notifier_list_init(&bs->close_notifiers);
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200333 notifier_with_return_list_init(&bs->before_write_notifiers);
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200334 qemu_co_queue_init(&bs->throttled_reqs[0]);
335 qemu_co_queue_init(&bs->throttled_reqs[1]);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800336 bs->refcnt = 1;
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200337
bellardb3380822004-03-14 21:38:54 +0000338 return bs;
339}
340
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200341void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
342{
343 notifier_list_add(&bs->close_notifiers, notify);
344}
345
bellardea2384d2004-08-01 21:59:26 +0000346BlockDriver *bdrv_find_format(const char *format_name)
347{
348 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100349 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
350 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000351 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100352 }
bellardea2384d2004-08-01 21:59:26 +0000353 }
354 return NULL;
355}
356
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800357static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100358{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800359 static const char *whitelist_rw[] = {
360 CONFIG_BDRV_RW_WHITELIST
361 };
362 static const char *whitelist_ro[] = {
363 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100364 };
365 const char **p;
366
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800367 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100368 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800369 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100370
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800371 for (p = whitelist_rw; *p; p++) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100372 if (!strcmp(drv->format_name, *p)) {
373 return 1;
374 }
375 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800376 if (read_only) {
377 for (p = whitelist_ro; *p; p++) {
378 if (!strcmp(drv->format_name, *p)) {
379 return 1;
380 }
381 }
382 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100383 return 0;
384}
385
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800386BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
387 bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100388{
389 BlockDriver *drv = bdrv_find_format(format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800390 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
Markus Armbrustereb852012009-10-27 18:41:44 +0100391}
392
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800393typedef struct CreateCo {
394 BlockDriver *drv;
395 char *filename;
396 QEMUOptionParameter *options;
397 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200398 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800399} CreateCo;
400
401static void coroutine_fn bdrv_create_co_entry(void *opaque)
402{
Max Reitzcc84d902013-09-06 17:14:26 +0200403 Error *local_err = NULL;
404 int ret;
405
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800406 CreateCo *cco = opaque;
407 assert(cco->drv);
408
Max Reitzcc84d902013-09-06 17:14:26 +0200409 ret = cco->drv->bdrv_create(cco->filename, cco->options, &local_err);
410 if (error_is_set(&local_err)) {
411 error_propagate(&cco->err, local_err);
412 }
413 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800414}
415
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200416int bdrv_create(BlockDriver *drv, const char* filename,
Max Reitzcc84d902013-09-06 17:14:26 +0200417 QEMUOptionParameter *options, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000418{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800419 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200420
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800421 Coroutine *co;
422 CreateCo cco = {
423 .drv = drv,
424 .filename = g_strdup(filename),
425 .options = options,
426 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200427 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800428 };
429
430 if (!drv->bdrv_create) {
Max Reitzcc84d902013-09-06 17:14:26 +0200431 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300432 ret = -ENOTSUP;
433 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800434 }
435
436 if (qemu_in_coroutine()) {
437 /* Fast-path if already in coroutine context */
438 bdrv_create_co_entry(&cco);
439 } else {
440 co = qemu_coroutine_create(bdrv_create_co_entry);
441 qemu_coroutine_enter(co, &cco);
442 while (cco.ret == NOT_DONE) {
443 qemu_aio_wait();
444 }
445 }
446
447 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200448 if (ret < 0) {
449 if (error_is_set(&cco.err)) {
450 error_propagate(errp, cco.err);
451 } else {
452 error_setg_errno(errp, -ret, "Could not create image");
453 }
454 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800455
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300456out:
457 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800458 return ret;
bellardea2384d2004-08-01 21:59:26 +0000459}
460
Max Reitzcc84d902013-09-06 17:14:26 +0200461int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
462 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200463{
464 BlockDriver *drv;
Max Reitzcc84d902013-09-06 17:14:26 +0200465 Error *local_err = NULL;
466 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200467
Kevin Wolf98289622013-07-10 15:47:39 +0200468 drv = bdrv_find_protocol(filename, true);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200469 if (drv == NULL) {
Max Reitzcc84d902013-09-06 17:14:26 +0200470 error_setg(errp, "Could not find protocol for file '%s'", filename);
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000471 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200472 }
473
Max Reitzcc84d902013-09-06 17:14:26 +0200474 ret = bdrv_create(drv, filename, options, &local_err);
475 if (error_is_set(&local_err)) {
476 error_propagate(errp, local_err);
477 }
478 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200479}
480
Jim Meyeringeba25052012-05-28 09:27:54 +0200481/*
482 * Create a uniquely-named empty temporary file.
483 * Return 0 upon success, otherwise a negative errno value.
484 */
485int get_tmp_filename(char *filename, int size)
486{
bellardd5249392004-08-03 21:14:23 +0000487#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000488 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200489 /* GetTempFileName requires that its output buffer (4th param)
490 have length MAX_PATH or greater. */
491 assert(size >= MAX_PATH);
492 return (GetTempPath(MAX_PATH, temp_dir)
493 && GetTempFileName(temp_dir, "qem", 0, filename)
494 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000495#else
bellardea2384d2004-08-01 21:59:26 +0000496 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000497 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000498 tmpdir = getenv("TMPDIR");
499 if (!tmpdir)
500 tmpdir = "/tmp";
Jim Meyeringeba25052012-05-28 09:27:54 +0200501 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
502 return -EOVERFLOW;
503 }
bellardea2384d2004-08-01 21:59:26 +0000504 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800505 if (fd < 0) {
506 return -errno;
507 }
508 if (close(fd) != 0) {
509 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200510 return -errno;
511 }
512 return 0;
bellardd5249392004-08-03 21:14:23 +0000513#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200514}
bellardea2384d2004-08-01 21:59:26 +0000515
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200516/*
517 * Detect host devices. By convention, /dev/cdrom[N] is always
518 * recognized as a host CDROM.
519 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200520static BlockDriver *find_hdev_driver(const char *filename)
521{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200522 int score_max = 0, score;
523 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200524
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100525 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200526 if (d->bdrv_probe_device) {
527 score = d->bdrv_probe_device(filename);
528 if (score > score_max) {
529 score_max = score;
530 drv = d;
531 }
532 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200533 }
534
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200535 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200536}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200537
Kevin Wolf98289622013-07-10 15:47:39 +0200538BlockDriver *bdrv_find_protocol(const char *filename,
539 bool allow_protocol_prefix)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200540{
541 BlockDriver *drv1;
542 char protocol[128];
543 int len;
544 const char *p;
545
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200546 /* TODO Drivers without bdrv_file_open must be specified explicitly */
547
Christoph Hellwig39508e72010-06-23 12:25:17 +0200548 /*
549 * XXX(hch): we really should not let host device detection
550 * override an explicit protocol specification, but moving this
551 * later breaks access to device names with colons in them.
552 * Thanks to the brain-dead persistent naming schemes on udev-
553 * based Linux systems those actually are quite common.
554 */
555 drv1 = find_hdev_driver(filename);
556 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200557 return drv1;
558 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200559
Kevin Wolf98289622013-07-10 15:47:39 +0200560 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Christoph Hellwig39508e72010-06-23 12:25:17 +0200561 return bdrv_find_format("file");
562 }
Kevin Wolf98289622013-07-10 15:47:39 +0200563
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000564 p = strchr(filename, ':');
565 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200566 len = p - filename;
567 if (len > sizeof(protocol) - 1)
568 len = sizeof(protocol) - 1;
569 memcpy(protocol, filename, len);
570 protocol[len] = '\0';
571 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
572 if (drv1->protocol_name &&
573 !strcmp(drv1->protocol_name, protocol)) {
574 return drv1;
575 }
576 }
577 return NULL;
578}
579
Kevin Wolff500a6d2012-11-12 17:35:27 +0100580static int find_image_format(BlockDriverState *bs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200581 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000582{
Kevin Wolff500a6d2012-11-12 17:35:27 +0100583 int score, score_max;
bellardea2384d2004-08-01 21:59:26 +0000584 BlockDriver *drv1, *drv;
bellard83f64092006-08-01 16:21:11 +0000585 uint8_t buf[2048];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100586 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700587
Kevin Wolf08a00552010-06-01 18:37:31 +0200588 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Paolo Bonzini8e895592013-01-10 15:39:27 +0100589 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Stefan Weilc98ac352010-07-21 21:51:51 +0200590 drv = bdrv_find_format("raw");
591 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200592 error_setg(errp, "Could not find raw image format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200593 ret = -ENOENT;
594 }
595 *pdrv = drv;
596 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700597 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700598
bellard83f64092006-08-01 16:21:11 +0000599 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000600 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200601 error_setg_errno(errp, -ret, "Could not read image for determining its "
602 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200603 *pdrv = NULL;
604 return ret;
bellard83f64092006-08-01 16:21:11 +0000605 }
606
bellardea2384d2004-08-01 21:59:26 +0000607 score_max = 0;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200608 drv = NULL;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100609 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
bellard83f64092006-08-01 16:21:11 +0000610 if (drv1->bdrv_probe) {
611 score = drv1->bdrv_probe(buf, ret, filename);
612 if (score > score_max) {
613 score_max = score;
614 drv = drv1;
615 }
bellardea2384d2004-08-01 21:59:26 +0000616 }
617 }
Stefan Weilc98ac352010-07-21 21:51:51 +0200618 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200619 error_setg(errp, "Could not determine image format: No compatible "
620 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200621 ret = -ENOENT;
622 }
623 *pdrv = drv;
624 return ret;
bellardea2384d2004-08-01 21:59:26 +0000625}
626
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100627/**
628 * Set the current 'total_sectors' value
629 */
630static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
631{
632 BlockDriver *drv = bs->drv;
633
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700634 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
635 if (bs->sg)
636 return 0;
637
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100638 /* query actual device if possible, otherwise just trust the hint */
639 if (drv->bdrv_getlength) {
640 int64_t length = drv->bdrv_getlength(bs);
641 if (length < 0) {
642 return length;
643 }
Fam Zheng7e382002013-11-06 19:48:06 +0800644 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100645 }
646
647 bs->total_sectors = hint;
648 return 0;
649}
650
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100651/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100652 * Set open flags for a given discard mode
653 *
654 * Return 0 on success, -1 if the discard mode was invalid.
655 */
656int bdrv_parse_discard_flags(const char *mode, int *flags)
657{
658 *flags &= ~BDRV_O_UNMAP;
659
660 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
661 /* do nothing */
662 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
663 *flags |= BDRV_O_UNMAP;
664 } else {
665 return -1;
666 }
667
668 return 0;
669}
670
671/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100672 * Set open flags for a given cache mode
673 *
674 * Return 0 on success, -1 if the cache mode was invalid.
675 */
676int bdrv_parse_cache_flags(const char *mode, int *flags)
677{
678 *flags &= ~BDRV_O_CACHE_MASK;
679
680 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
681 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100682 } else if (!strcmp(mode, "directsync")) {
683 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100684 } else if (!strcmp(mode, "writeback")) {
685 *flags |= BDRV_O_CACHE_WB;
686 } else if (!strcmp(mode, "unsafe")) {
687 *flags |= BDRV_O_CACHE_WB;
688 *flags |= BDRV_O_NO_FLUSH;
689 } else if (!strcmp(mode, "writethrough")) {
690 /* this is the default */
691 } else {
692 return -1;
693 }
694
695 return 0;
696}
697
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000698/**
699 * The copy-on-read flag is actually a reference count so multiple users may
700 * use the feature without worrying about clobbering its previous state.
701 * Copy-on-read stays enabled until all users have called to disable it.
702 */
703void bdrv_enable_copy_on_read(BlockDriverState *bs)
704{
705 bs->copy_on_read++;
706}
707
708void bdrv_disable_copy_on_read(BlockDriverState *bs)
709{
710 assert(bs->copy_on_read > 0);
711 bs->copy_on_read--;
712}
713
Kevin Wolf7b272452012-11-12 17:05:39 +0100714static int bdrv_open_flags(BlockDriverState *bs, int flags)
715{
716 int open_flags = flags | BDRV_O_CACHE_WB;
717
718 /*
719 * Clear flags that are internal to the block layer before opening the
720 * image.
721 */
722 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
723
724 /*
725 * Snapshots should be writable.
726 */
727 if (bs->is_temporary) {
728 open_flags |= BDRV_O_RDWR;
729 }
730
731 return open_flags;
732}
733
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200734/*
Kevin Wolf57915332010-04-14 15:24:50 +0200735 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +0100736 *
737 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +0200738 */
Kevin Wolff500a6d2012-11-12 17:35:27 +0100739static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200740 QDict *options, int flags, BlockDriver *drv, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +0200741{
742 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200743 const char *filename;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200744 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +0200745
746 assert(drv != NULL);
Paolo Bonzini64058752012-05-08 16:51:49 +0200747 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +0100748 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +0200749
Kevin Wolf45673672013-04-22 17:48:40 +0200750 if (file != NULL) {
751 filename = file->filename;
752 } else {
753 filename = qdict_get_try_str(options, "filename");
754 }
755
756 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
Stefan Hajnoczi28dcee12011-09-22 20:14:12 +0100757
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100758 /* bdrv_open() with directly using a protocol as drv. This layer is already
759 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
760 * and return immediately. */
761 if (file != NULL && drv->bdrv_file_open) {
762 bdrv_swap(file, bs);
763 return 0;
764 }
765
Kevin Wolf57915332010-04-14 15:24:50 +0200766 bs->open_flags = flags;
Kevin Wolf57915332010-04-14 15:24:50 +0200767 bs->buffer_alignment = 512;
Asias He0d51b4d2013-08-22 15:24:14 +0800768 bs->zero_beyond_eof = true;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800769 open_flags = bdrv_open_flags(bs, flags);
770 bs->read_only = !(open_flags & BDRV_O_RDWR);
771
772 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200773 error_setg(errp,
774 !bs->read_only && bdrv_is_whitelisted(drv, true)
775 ? "Driver '%s' can only be used for read-only devices"
776 : "Driver '%s' is not whitelisted",
777 drv->format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800778 return -ENOTSUP;
779 }
Kevin Wolf57915332010-04-14 15:24:50 +0200780
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000781 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200782 if (flags & BDRV_O_COPY_ON_READ) {
783 if (!bs->read_only) {
784 bdrv_enable_copy_on_read(bs);
785 } else {
786 error_setg(errp, "Can't use copy-on-read on read-only device");
787 return -EINVAL;
788 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000789 }
790
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100791 if (filename != NULL) {
792 pstrcpy(bs->filename, sizeof(bs->filename), filename);
793 } else {
794 bs->filename[0] = '\0';
795 }
Kevin Wolf57915332010-04-14 15:24:50 +0200796
Kevin Wolf57915332010-04-14 15:24:50 +0200797 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500798 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200799
Stefan Hajnoczi03f541b2011-10-27 10:54:28 +0100800 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100801
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200802 /* Open the image, either directly or using a protocol */
803 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100804 assert(file == NULL);
BenoƮt Canet030be322013-09-24 17:07:04 +0200805 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200806 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +0100807 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200808 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200809 error_setg(errp, "Can't use '%s' as a block driver for the "
810 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200811 ret = -EINVAL;
812 goto free_and_fail;
813 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100814 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200815 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200816 }
817
Kevin Wolf57915332010-04-14 15:24:50 +0200818 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200819 if (error_is_set(&local_err)) {
820 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +0800821 } else if (bs->filename[0]) {
822 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200823 } else {
824 error_setg_errno(errp, -ret, "Could not open image");
825 }
Kevin Wolf57915332010-04-14 15:24:50 +0200826 goto free_and_fail;
827 }
828
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100829 ret = refresh_total_sectors(bs, bs->total_sectors);
830 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200831 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100832 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200833 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100834
Kevin Wolf57915332010-04-14 15:24:50 +0200835#ifndef _WIN32
836 if (bs->is_temporary) {
Dunrong Huangd4cea8d2013-10-03 01:31:27 +0800837 assert(bs->filename[0] != '\0');
838 unlink(bs->filename);
Kevin Wolf57915332010-04-14 15:24:50 +0200839 }
840#endif
841 return 0;
842
843free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +0100844 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -0500845 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +0200846 bs->opaque = NULL;
847 bs->drv = NULL;
848 return ret;
849}
850
851/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200852 * Opens a file using a protocol (file, host_device, nbd, ...)
Kevin Wolf787e4a82013-03-06 11:52:48 +0100853 *
854 * options is a QDict of options to pass to the block drivers, or NULL for an
855 * empty set of options. The reference to the QDict belongs to the block layer
856 * after the call (even on failure), so if the caller intends to reuse the
857 * dictionary, it needs to use QINCREF() before calling bdrv_file_open.
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200858 */
Kevin Wolf787e4a82013-03-06 11:52:48 +0100859int bdrv_file_open(BlockDriverState **pbs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200860 QDict *options, int flags, Error **errp)
bellardb3380822004-03-14 21:38:54 +0000861{
bellard83f64092006-08-01 16:21:11 +0000862 BlockDriverState *bs;
Christoph Hellwig6db95602010-04-05 16:53:57 +0200863 BlockDriver *drv;
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100864 const char *drvname;
Kevin Wolf98289622013-07-10 15:47:39 +0200865 bool allow_protocol_prefix = false;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200866 Error *local_err = NULL;
bellard83f64092006-08-01 16:21:11 +0000867 int ret;
868
Kevin Wolf707ff822013-03-06 12:20:31 +0100869 /* NULL means an empty set of options */
870 if (options == NULL) {
871 options = qdict_new();
bellard3b0d4f62005-10-30 18:30:10 +0000872 }
Kevin Wolf707ff822013-03-06 12:20:31 +0100873
874 bs = bdrv_new("");
875 bs->options = options;
876 options = qdict_clone_shallow(options);
877
Kevin Wolf035fccd2013-04-09 14:34:19 +0200878 /* Fetch the file name from the options QDict if necessary */
879 if (!filename) {
880 filename = qdict_get_try_str(options, "filename");
881 } else if (filename && !qdict_haskey(options, "filename")) {
882 qdict_put(options, "filename", qstring_from_str(filename));
Kevin Wolf98289622013-07-10 15:47:39 +0200883 allow_protocol_prefix = true;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200884 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200885 error_setg(errp, "Can't specify 'file' and 'filename' options at the "
886 "same time");
Kevin Wolf035fccd2013-04-09 14:34:19 +0200887 ret = -EINVAL;
888 goto fail;
889 }
890
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100891 /* Find the right block driver */
892 drvname = qdict_get_try_str(options, "driver");
893 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200894 drv = bdrv_find_format(drvname);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200895 if (!drv) {
896 error_setg(errp, "Unknown driver '%s'", drvname);
897 }
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100898 qdict_del(options, "driver");
899 } else if (filename) {
Kevin Wolf98289622013-07-10 15:47:39 +0200900 drv = bdrv_find_protocol(filename, allow_protocol_prefix);
901 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200902 error_setg(errp, "Unknown protocol");
Kevin Wolf98289622013-07-10 15:47:39 +0200903 }
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100904 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200905 error_setg(errp, "Must specify either driver or file");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100906 drv = NULL;
907 }
908
909 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200910 /* errp has been set already */
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100911 ret = -ENOENT;
912 goto fail;
913 }
914
915 /* Parse the filename and open it */
916 if (drv->bdrv_parse_filename && filename) {
Kevin Wolf6963a302013-03-15 18:47:22 +0100917 drv->bdrv_parse_filename(filename, options, &local_err);
918 if (error_is_set(&local_err)) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200919 error_propagate(errp, local_err);
Kevin Wolf6963a302013-03-15 18:47:22 +0100920 ret = -EINVAL;
921 goto fail;
922 }
Kevin Wolf56d1b4d2013-04-12 20:02:37 +0200923 qdict_del(options, "filename");
BenoƮt Canet030be322013-09-24 17:07:04 +0200924 } else if (drv->bdrv_needs_filename && !filename) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200925 error_setg(errp, "The '%s' block driver requires a file name",
926 drv->format_name);
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100927 ret = -EINVAL;
928 goto fail;
Kevin Wolf6963a302013-03-15 18:47:22 +0100929 }
930
Max Reitz34b5d2c2013-09-05 14:45:29 +0200931 ret = bdrv_open_common(bs, NULL, options, flags, drv, &local_err);
Kevin Wolf707ff822013-03-06 12:20:31 +0100932 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200933 error_propagate(errp, local_err);
Kevin Wolf707ff822013-03-06 12:20:31 +0100934 goto fail;
935 }
936
937 /* Check if any unknown options were used */
938 if (qdict_size(options) != 0) {
939 const QDictEntry *entry = qdict_first(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200940 error_setg(errp, "Block protocol '%s' doesn't support the option '%s'",
941 drv->format_name, entry->key);
Kevin Wolf707ff822013-03-06 12:20:31 +0100942 ret = -EINVAL;
943 goto fail;
944 }
945 QDECREF(options);
946
aliguori71d07702009-03-03 17:37:16 +0000947 bs->growable = 1;
bellard83f64092006-08-01 16:21:11 +0000948 *pbs = bs;
949 return 0;
Kevin Wolf707ff822013-03-06 12:20:31 +0100950
951fail:
952 QDECREF(options);
953 if (!bs->drv) {
954 QDECREF(bs->options);
955 }
Fam Zheng4f6fd342013-08-23 09:14:47 +0800956 bdrv_unref(bs);
Kevin Wolf707ff822013-03-06 12:20:31 +0100957 return ret;
bellardea2384d2004-08-01 21:59:26 +0000958}
bellardfc01f7e2003-06-30 10:03:06 +0000959
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100960/*
961 * Opens the backing file for a BlockDriverState if not yet open
962 *
963 * options is a QDict of options to pass to the block drivers, or NULL for an
964 * empty set of options. The reference to the QDict is transferred to this
965 * function (even on failure), so if the caller intends to reuse the dictionary,
966 * it needs to use QINCREF() before calling bdrv_file_open.
967 */
Max Reitz34b5d2c2013-09-05 14:45:29 +0200968int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +0200969{
970 char backing_filename[PATH_MAX];
971 int back_flags, ret;
972 BlockDriver *back_drv = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200973 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +0200974
975 if (bs->backing_hd != NULL) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100976 QDECREF(options);
Paolo Bonzini9156df12012-10-18 16:49:17 +0200977 return 0;
978 }
979
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100980 /* NULL means an empty set of options */
981 if (options == NULL) {
982 options = qdict_new();
983 }
984
Paolo Bonzini9156df12012-10-18 16:49:17 +0200985 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolf1cb6f502013-04-12 20:27:07 +0200986 if (qdict_haskey(options, "file.filename")) {
987 backing_filename[0] = '\0';
988 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100989 QDECREF(options);
Paolo Bonzini9156df12012-10-18 16:49:17 +0200990 return 0;
Fam Zhengdbecebd2013-09-22 20:05:06 +0800991 } else {
992 bdrv_get_full_backing_filename(bs, backing_filename,
993 sizeof(backing_filename));
Paolo Bonzini9156df12012-10-18 16:49:17 +0200994 }
995
996 bs->backing_hd = bdrv_new("");
Paolo Bonzini9156df12012-10-18 16:49:17 +0200997
998 if (bs->backing_format[0] != '\0') {
999 back_drv = bdrv_find_format(bs->backing_format);
1000 }
1001
1002 /* backing files always opened read-only */
Thibaut LAURENT87a5deb2013-10-25 02:15:07 +02001003 back_flags = bs->open_flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT |
1004 BDRV_O_COPY_ON_READ);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001005
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001006 ret = bdrv_open(bs->backing_hd,
1007 *backing_filename ? backing_filename : NULL, options,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001008 back_flags, back_drv, &local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001009 if (ret < 0) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001010 bdrv_unref(bs->backing_hd);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001011 bs->backing_hd = NULL;
1012 bs->open_flags |= BDRV_O_NO_BACKING;
Fam Zhengb04b6b62013-11-08 11:26:49 +08001013 error_setg(errp, "Could not open backing file: %s",
1014 error_get_pretty(local_err));
1015 error_free(local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001016 return ret;
1017 }
Max Reitz61ed2682013-10-26 15:44:43 +02001018 pstrcpy(bs->backing_file, sizeof(bs->backing_file),
1019 bs->backing_hd->file->filename);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001020 return 0;
1021}
1022
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001023/*
1024 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001025 *
1026 * options is a QDict of options to pass to the block drivers, or NULL for an
1027 * empty set of options. The reference to the QDict belongs to the block layer
1028 * after the call (even on failure), so if the caller intends to reuse the
1029 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001030 */
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001031int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001032 int flags, BlockDriver *drv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001033{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001034 int ret;
Stefan Weil89c9bc32012-11-22 07:25:48 +01001035 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1036 char tmp_filename[PATH_MAX + 1];
Kevin Wolff500a6d2012-11-12 17:35:27 +01001037 BlockDriverState *file = NULL;
Kevin Wolf707ff822013-03-06 12:20:31 +01001038 QDict *file_options = NULL;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001039 const char *drvname;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001040 Error *local_err = NULL;
bellard712e7872005-04-28 21:09:32 +00001041
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001042 /* NULL means an empty set of options */
1043 if (options == NULL) {
1044 options = qdict_new();
1045 }
1046
1047 bs->options = options;
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001048 options = qdict_clone_shallow(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001049
1050 /* For snapshot=on, create a temporary qcow2 overlay */
bellard83f64092006-08-01 16:21:11 +00001051 if (flags & BDRV_O_SNAPSHOT) {
bellardea2384d2004-08-01 21:59:26 +00001052 BlockDriverState *bs1;
1053 int64_t total_size;
Kevin Wolf91a073a2009-05-27 14:48:06 +02001054 BlockDriver *bdrv_qcow2;
Kevin Wolf08b392e2013-03-18 16:17:44 +01001055 QEMUOptionParameter *create_options;
Kevin Wolf9fd31712013-11-14 15:37:12 +01001056 QDict *snapshot_options;
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001057
bellardea2384d2004-08-01 21:59:26 +00001058 /* if snapshot, we create a temporary backing file and open it
1059 instead of opening 'filename' directly */
1060
Kevin Wolf9fd31712013-11-14 15:37:12 +01001061 /* Get the required size from the image */
bellardea2384d2004-08-01 21:59:26 +00001062 bs1 = bdrv_new("");
Kevin Wolf9fd31712013-11-14 15:37:12 +01001063 QINCREF(options);
Kevin Wolfc9fbb992013-11-28 11:58:02 +01001064 ret = bdrv_open(bs1, filename, options, BDRV_O_NO_BACKING,
1065 drv, &local_err);
aliguori51d7c002009-03-05 23:00:29 +00001066 if (ret < 0) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001067 bdrv_unref(bs1);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001068 goto fail;
bellardea2384d2004-08-01 21:59:26 +00001069 }
Jes Sorensen3e829902010-05-27 16:20:30 +02001070 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
aliguori7c96d462008-09-12 17:54:13 +00001071
Fam Zheng4f6fd342013-08-23 09:14:47 +08001072 bdrv_unref(bs1);
ths3b46e622007-09-17 08:09:54 +00001073
Kevin Wolf9fd31712013-11-14 15:37:12 +01001074 /* Create the temporary image */
Jim Meyeringeba25052012-05-28 09:27:54 +02001075 ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));
1076 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001077 error_setg_errno(errp, -ret, "Could not get temporary filename");
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001078 goto fail;
Jim Meyeringeba25052012-05-28 09:27:54 +02001079 }
aliguori7c96d462008-09-12 17:54:13 +00001080
Kevin Wolf91a073a2009-05-27 14:48:06 +02001081 bdrv_qcow2 = bdrv_find_format("qcow2");
Kevin Wolf08b392e2013-03-18 16:17:44 +01001082 create_options = parse_option_parameters("", bdrv_qcow2->create_options,
1083 NULL);
Kevin Wolf91a073a2009-05-27 14:48:06 +02001084
Kevin Wolf08b392e2013-03-18 16:17:44 +01001085 set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
Kevin Wolf91a073a2009-05-27 14:48:06 +02001086
Max Reitzcc84d902013-09-06 17:14:26 +02001087 ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);
Kevin Wolf08b392e2013-03-18 16:17:44 +01001088 free_option_parameters(create_options);
aliguori51d7c002009-03-05 23:00:29 +00001089 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001090 error_setg_errno(errp, -ret, "Could not create temporary overlay "
Max Reitzcc84d902013-09-06 17:14:26 +02001091 "'%s': %s", tmp_filename,
1092 error_get_pretty(local_err));
1093 error_free(local_err);
1094 local_err = NULL;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001095 goto fail;
bellardea2384d2004-08-01 21:59:26 +00001096 }
Kevin Wolf91a073a2009-05-27 14:48:06 +02001097
Kevin Wolf9fd31712013-11-14 15:37:12 +01001098 /* Prepare a new options QDict for the temporary file, where user
1099 * options refer to the backing file */
1100 if (filename) {
1101 qdict_put(options, "file.filename", qstring_from_str(filename));
1102 }
1103 if (drv) {
1104 qdict_put(options, "driver", qstring_from_str(drv->format_name));
1105 }
1106
1107 snapshot_options = qdict_new();
1108 qdict_put(snapshot_options, "backing", options);
1109 qdict_flatten(snapshot_options);
1110
1111 bs->options = snapshot_options;
1112 options = qdict_clone_shallow(bs->options);
1113
bellardea2384d2004-08-01 21:59:26 +00001114 filename = tmp_filename;
Kevin Wolf91a073a2009-05-27 14:48:06 +02001115 drv = bdrv_qcow2;
bellardea2384d2004-08-01 21:59:26 +00001116 bs->is_temporary = 1;
1117 }
bellard712e7872005-04-28 21:09:32 +00001118
Kevin Wolff500a6d2012-11-12 17:35:27 +01001119 /* Open image file without format layer */
Jeff Codybe028ad2012-09-20 15:13:17 -04001120 if (flags & BDRV_O_RDWR) {
1121 flags |= BDRV_O_ALLOW_RDWR;
1122 }
1123
BenoƮt Canet5726d872013-09-25 13:30:01 +02001124 qdict_extract_subqdict(options, &file_options, "file.");
Kevin Wolf707ff822013-03-06 12:20:31 +01001125
1126 ret = bdrv_file_open(&file, filename, file_options,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001127 bdrv_open_flags(bs, flags | BDRV_O_UNMAP), &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001128 if (ret < 0) {
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001129 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001130 }
1131
1132 /* Find the right image format driver */
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001133 drvname = qdict_get_try_str(options, "driver");
1134 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +02001135 drv = bdrv_find_format(drvname);
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001136 qdict_del(options, "driver");
Kevin Wolf06d22aa2013-08-08 17:44:52 +02001137 if (!drv) {
1138 error_setg(errp, "Invalid driver: '%s'", drvname);
1139 ret = -EINVAL;
1140 goto unlink_and_fail;
1141 }
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001142 }
1143
Kevin Wolff500a6d2012-11-12 17:35:27 +01001144 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001145 ret = find_image_format(file, filename, &drv, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001146 }
1147
1148 if (!drv) {
1149 goto unlink_and_fail;
1150 }
1151
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001152 /* Open the image */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001153 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001154 if (ret < 0) {
Christoph Hellwig69873072010-01-20 18:13:25 +01001155 goto unlink_and_fail;
1156 }
1157
Kevin Wolff500a6d2012-11-12 17:35:27 +01001158 if (bs->file != file) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001159 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001160 file = NULL;
1161 }
1162
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001163 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001164 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001165 QDict *backing_options;
1166
BenoƮt Canet5726d872013-09-25 13:30:01 +02001167 qdict_extract_subqdict(options, &backing_options, "backing.");
Max Reitz34b5d2c2013-09-05 14:45:29 +02001168 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001169 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001170 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001171 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001172 }
1173
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001174 /* Check if any unknown options were used */
1175 if (qdict_size(options) != 0) {
1176 const QDictEntry *entry = qdict_first(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001177 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1178 "support the option '%s'", drv->format_name, bs->device_name,
1179 entry->key);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001180
1181 ret = -EINVAL;
1182 goto close_and_fail;
1183 }
1184 QDECREF(options);
1185
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001186 if (!bdrv_key_required(bs)) {
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001187 bdrv_dev_change_media_cb(bs, true);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001188 }
1189
1190 return 0;
1191
1192unlink_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001193 if (file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001194 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001195 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001196 if (bs->is_temporary) {
1197 unlink(filename);
1198 }
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001199fail:
1200 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001201 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001202 bs->options = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001203 if (error_is_set(&local_err)) {
1204 error_propagate(errp, local_err);
1205 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001206 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001207
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001208close_and_fail:
1209 bdrv_close(bs);
1210 QDECREF(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001211 if (error_is_set(&local_err)) {
1212 error_propagate(errp, local_err);
1213 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001214 return ret;
1215}
1216
Jeff Codye971aa12012-09-20 15:13:19 -04001217typedef struct BlockReopenQueueEntry {
1218 bool prepared;
1219 BDRVReopenState state;
1220 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1221} BlockReopenQueueEntry;
1222
1223/*
1224 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1225 * reopen of multiple devices.
1226 *
1227 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1228 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1229 * be created and initialized. This newly created BlockReopenQueue should be
1230 * passed back in for subsequent calls that are intended to be of the same
1231 * atomic 'set'.
1232 *
1233 * bs is the BlockDriverState to add to the reopen queue.
1234 *
1235 * flags contains the open flags for the associated bs
1236 *
1237 * returns a pointer to bs_queue, which is either the newly allocated
1238 * bs_queue, or the existing bs_queue being used.
1239 *
1240 */
1241BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1242 BlockDriverState *bs, int flags)
1243{
1244 assert(bs != NULL);
1245
1246 BlockReopenQueueEntry *bs_entry;
1247 if (bs_queue == NULL) {
1248 bs_queue = g_new0(BlockReopenQueue, 1);
1249 QSIMPLEQ_INIT(bs_queue);
1250 }
1251
1252 if (bs->file) {
1253 bdrv_reopen_queue(bs_queue, bs->file, flags);
1254 }
1255
1256 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1257 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1258
1259 bs_entry->state.bs = bs;
1260 bs_entry->state.flags = flags;
1261
1262 return bs_queue;
1263}
1264
1265/*
1266 * Reopen multiple BlockDriverStates atomically & transactionally.
1267 *
1268 * The queue passed in (bs_queue) must have been built up previous
1269 * via bdrv_reopen_queue().
1270 *
1271 * Reopens all BDS specified in the queue, with the appropriate
1272 * flags. All devices are prepared for reopen, and failure of any
1273 * device will cause all device changes to be abandonded, and intermediate
1274 * data cleaned up.
1275 *
1276 * If all devices prepare successfully, then the changes are committed
1277 * to all devices.
1278 *
1279 */
1280int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1281{
1282 int ret = -1;
1283 BlockReopenQueueEntry *bs_entry, *next;
1284 Error *local_err = NULL;
1285
1286 assert(bs_queue != NULL);
1287
1288 bdrv_drain_all();
1289
1290 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1291 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1292 error_propagate(errp, local_err);
1293 goto cleanup;
1294 }
1295 bs_entry->prepared = true;
1296 }
1297
1298 /* If we reach this point, we have success and just need to apply the
1299 * changes
1300 */
1301 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1302 bdrv_reopen_commit(&bs_entry->state);
1303 }
1304
1305 ret = 0;
1306
1307cleanup:
1308 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1309 if (ret && bs_entry->prepared) {
1310 bdrv_reopen_abort(&bs_entry->state);
1311 }
1312 g_free(bs_entry);
1313 }
1314 g_free(bs_queue);
1315 return ret;
1316}
1317
1318
1319/* Reopen a single BlockDriverState with the specified flags. */
1320int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1321{
1322 int ret = -1;
1323 Error *local_err = NULL;
1324 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1325
1326 ret = bdrv_reopen_multiple(queue, &local_err);
1327 if (local_err != NULL) {
1328 error_propagate(errp, local_err);
1329 }
1330 return ret;
1331}
1332
1333
1334/*
1335 * Prepares a BlockDriverState for reopen. All changes are staged in the
1336 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1337 * the block driver layer .bdrv_reopen_prepare()
1338 *
1339 * bs is the BlockDriverState to reopen
1340 * flags are the new open flags
1341 * queue is the reopen queue
1342 *
1343 * Returns 0 on success, non-zero on error. On error errp will be set
1344 * as well.
1345 *
1346 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1347 * It is the responsibility of the caller to then call the abort() or
1348 * commit() for any other BDS that have been left in a prepare() state
1349 *
1350 */
1351int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1352 Error **errp)
1353{
1354 int ret = -1;
1355 Error *local_err = NULL;
1356 BlockDriver *drv;
1357
1358 assert(reopen_state != NULL);
1359 assert(reopen_state->bs->drv != NULL);
1360 drv = reopen_state->bs->drv;
1361
1362 /* if we are to stay read-only, do not allow permission change
1363 * to r/w */
1364 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1365 reopen_state->flags & BDRV_O_RDWR) {
1366 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1367 reopen_state->bs->device_name);
1368 goto error;
1369 }
1370
1371
1372 ret = bdrv_flush(reopen_state->bs);
1373 if (ret) {
1374 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1375 strerror(-ret));
1376 goto error;
1377 }
1378
1379 if (drv->bdrv_reopen_prepare) {
1380 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1381 if (ret) {
1382 if (local_err != NULL) {
1383 error_propagate(errp, local_err);
1384 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04001385 error_setg(errp, "failed while preparing to reopen image '%s'",
1386 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04001387 }
1388 goto error;
1389 }
1390 } else {
1391 /* It is currently mandatory to have a bdrv_reopen_prepare()
1392 * handler for each supported drv. */
1393 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1394 drv->format_name, reopen_state->bs->device_name,
1395 "reopening of file");
1396 ret = -1;
1397 goto error;
1398 }
1399
1400 ret = 0;
1401
1402error:
1403 return ret;
1404}
1405
1406/*
1407 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1408 * makes them final by swapping the staging BlockDriverState contents into
1409 * the active BlockDriverState contents.
1410 */
1411void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1412{
1413 BlockDriver *drv;
1414
1415 assert(reopen_state != NULL);
1416 drv = reopen_state->bs->drv;
1417 assert(drv != NULL);
1418
1419 /* If there are any driver level actions to take */
1420 if (drv->bdrv_reopen_commit) {
1421 drv->bdrv_reopen_commit(reopen_state);
1422 }
1423
1424 /* set BDS specific flags now */
1425 reopen_state->bs->open_flags = reopen_state->flags;
1426 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1427 BDRV_O_CACHE_WB);
1428 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1429}
1430
1431/*
1432 * Abort the reopen, and delete and free the staged changes in
1433 * reopen_state
1434 */
1435void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1436{
1437 BlockDriver *drv;
1438
1439 assert(reopen_state != NULL);
1440 drv = reopen_state->bs->drv;
1441 assert(drv != NULL);
1442
1443 if (drv->bdrv_reopen_abort) {
1444 drv->bdrv_reopen_abort(reopen_state);
1445 }
1446}
1447
1448
bellardfc01f7e2003-06-30 10:03:06 +00001449void bdrv_close(BlockDriverState *bs)
1450{
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001451 if (bs->job) {
1452 block_job_cancel_sync(bs->job);
1453 }
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02001454 bdrv_drain_all(); /* complete I/O */
1455 bdrv_flush(bs);
1456 bdrv_drain_all(); /* in case flush left pending I/O */
Paolo Bonzinid7d512f2012-08-23 11:20:36 +02001457 notifier_list_notify(&bs->close_notifiers, bs);
Kevin Wolf7094f122012-04-11 11:06:37 +02001458
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001459 if (bs->drv) {
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001460 if (bs->backing_hd) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001461 bdrv_unref(bs->backing_hd);
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001462 bs->backing_hd = NULL;
1463 }
bellardea2384d2004-08-01 21:59:26 +00001464 bs->drv->bdrv_close(bs);
Anthony Liguori7267c092011-08-20 22:09:37 -05001465 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00001466#ifdef _WIN32
1467 if (bs->is_temporary) {
1468 unlink(bs->filename);
1469 }
bellard67b915a2004-03-31 23:37:16 +00001470#endif
bellardea2384d2004-08-01 21:59:26 +00001471 bs->opaque = NULL;
1472 bs->drv = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001473 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02001474 bs->backing_file[0] = '\0';
1475 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02001476 bs->total_sectors = 0;
1477 bs->encrypted = 0;
1478 bs->valid_key = 0;
1479 bs->sg = 0;
1480 bs->growable = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08001481 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001482 QDECREF(bs->options);
1483 bs->options = NULL;
bellardb3380822004-03-14 21:38:54 +00001484
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001485 if (bs->file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001486 bdrv_unref(bs->file);
Paolo Bonzini0ac93772012-05-08 16:51:44 +02001487 bs->file = NULL;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001488 }
bellardb3380822004-03-14 21:38:54 +00001489 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001490
Pavel Hrdina9ca11152012-08-09 12:44:48 +02001491 bdrv_dev_change_media_cb(bs, false);
1492
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001493 /*throttling disk I/O limits*/
1494 if (bs->io_limits_enabled) {
1495 bdrv_io_limits_disable(bs);
1496 }
bellardb3380822004-03-14 21:38:54 +00001497}
1498
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001499void bdrv_close_all(void)
1500{
1501 BlockDriverState *bs;
1502
1503 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1504 bdrv_close(bs);
1505 }
1506}
1507
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001508/* Check if any requests are in-flight (including throttled requests) */
1509static bool bdrv_requests_pending(BlockDriverState *bs)
1510{
1511 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1512 return true;
1513 }
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001514 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1515 return true;
1516 }
1517 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001518 return true;
1519 }
1520 if (bs->file && bdrv_requests_pending(bs->file)) {
1521 return true;
1522 }
1523 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1524 return true;
1525 }
1526 return false;
1527}
1528
1529static bool bdrv_requests_pending_all(void)
1530{
1531 BlockDriverState *bs;
1532 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1533 if (bdrv_requests_pending(bs)) {
1534 return true;
1535 }
1536 }
1537 return false;
1538}
1539
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001540/*
1541 * Wait for pending requests to complete across all BlockDriverStates
1542 *
1543 * This function does not flush data to disk, use bdrv_flush_all() for that
1544 * after calling this function.
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001545 *
1546 * Note that completion of an asynchronous I/O operation can trigger any
1547 * number of other I/O operations on other devices---for example a coroutine
1548 * can be arbitrarily complex and a constant flow of I/O can come until the
1549 * coroutine is complete. Because of this, it is not possible to have a
1550 * function to drain a single device's I/O queue.
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001551 */
1552void bdrv_drain_all(void)
1553{
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001554 /* Always run first iteration so any pending completion BHs run */
1555 bool busy = true;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001556 BlockDriverState *bs;
1557
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001558 while (busy) {
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001559 /* FIXME: We do not have timer support here, so this is effectively
1560 * a busy wait.
1561 */
1562 QTAILQ_FOREACH(bs, &bdrv_states, list) {
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001563 if (bdrv_start_throttled_reqs(bs)) {
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001564 busy = true;
1565 }
1566 }
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001567
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001568 busy = bdrv_requests_pending_all();
1569 busy |= aio_poll(qemu_get_aio_context(), busy);
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001570 }
1571}
1572
Ryan Harperd22b2f42011-03-29 20:51:47 -05001573/* make a BlockDriverState anonymous by removing from bdrv_state list.
1574 Also, NULL terminate the device_name to prevent double remove */
1575void bdrv_make_anon(BlockDriverState *bs)
1576{
1577 if (bs->device_name[0] != '\0') {
1578 QTAILQ_REMOVE(&bdrv_states, bs, list);
1579 }
1580 bs->device_name[0] = '\0';
1581}
1582
Paolo Bonzinie023b2e2012-05-08 16:51:41 +02001583static void bdrv_rebind(BlockDriverState *bs)
1584{
1585 if (bs->drv && bs->drv->bdrv_rebind) {
1586 bs->drv->bdrv_rebind(bs);
1587 }
1588}
1589
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001590static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1591 BlockDriverState *bs_src)
1592{
1593 /* move some fields that need to stay attached to the device */
1594 bs_dest->open_flags = bs_src->open_flags;
1595
1596 /* dev info */
1597 bs_dest->dev_ops = bs_src->dev_ops;
1598 bs_dest->dev_opaque = bs_src->dev_opaque;
1599 bs_dest->dev = bs_src->dev;
1600 bs_dest->buffer_alignment = bs_src->buffer_alignment;
1601 bs_dest->copy_on_read = bs_src->copy_on_read;
1602
1603 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1604
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001605 /* i/o throttled req */
1606 memcpy(&bs_dest->throttle_state,
1607 &bs_src->throttle_state,
1608 sizeof(ThrottleState));
1609 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1610 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001611 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1612
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001613 /* r/w error */
1614 bs_dest->on_read_error = bs_src->on_read_error;
1615 bs_dest->on_write_error = bs_src->on_write_error;
1616
1617 /* i/o status */
1618 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1619 bs_dest->iostatus = bs_src->iostatus;
1620
1621 /* dirty bitmap */
Fam Zhenge4654d22013-11-13 18:29:43 +08001622 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001623
Fam Zheng9fcb0252013-08-23 09:14:46 +08001624 /* reference count */
1625 bs_dest->refcnt = bs_src->refcnt;
1626
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001627 /* job */
1628 bs_dest->in_use = bs_src->in_use;
1629 bs_dest->job = bs_src->job;
1630
1631 /* keep the same entry in bdrv_states */
1632 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1633 bs_src->device_name);
1634 bs_dest->list = bs_src->list;
1635}
1636
1637/*
1638 * Swap bs contents for two image chains while they are live,
1639 * while keeping required fields on the BlockDriverState that is
1640 * actually attached to a device.
1641 *
1642 * This will modify the BlockDriverState fields, and swap contents
1643 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1644 *
1645 * bs_new is required to be anonymous.
1646 *
1647 * This function does not create any image files.
1648 */
1649void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
1650{
1651 BlockDriverState tmp;
1652
1653 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1654 assert(bs_new->device_name[0] == '\0');
Fam Zhenge4654d22013-11-13 18:29:43 +08001655 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001656 assert(bs_new->job == NULL);
1657 assert(bs_new->dev == NULL);
1658 assert(bs_new->in_use == 0);
1659 assert(bs_new->io_limits_enabled == false);
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001660 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001661
1662 tmp = *bs_new;
1663 *bs_new = *bs_old;
1664 *bs_old = tmp;
1665
1666 /* there are some fields that should not be swapped, move them back */
1667 bdrv_move_feature_fields(&tmp, bs_old);
1668 bdrv_move_feature_fields(bs_old, bs_new);
1669 bdrv_move_feature_fields(bs_new, &tmp);
1670
1671 /* bs_new shouldn't be in bdrv_states even after the swap! */
1672 assert(bs_new->device_name[0] == '\0');
1673
1674 /* Check a few fields that should remain attached to the device */
1675 assert(bs_new->dev == NULL);
1676 assert(bs_new->job == NULL);
1677 assert(bs_new->in_use == 0);
1678 assert(bs_new->io_limits_enabled == false);
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001679 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001680
1681 bdrv_rebind(bs_new);
1682 bdrv_rebind(bs_old);
1683}
1684
Jeff Cody8802d1f2012-02-28 15:54:06 -05001685/*
1686 * Add new bs contents at the top of an image chain while the chain is
1687 * live, while keeping required fields on the top layer.
1688 *
1689 * This will modify the BlockDriverState fields, and swap contents
1690 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1691 *
Jeff Codyf6801b82012-03-27 16:30:19 -04001692 * bs_new is required to be anonymous.
1693 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05001694 * This function does not create any image files.
1695 */
1696void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
1697{
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001698 bdrv_swap(bs_new, bs_top);
Jeff Cody8802d1f2012-02-28 15:54:06 -05001699
1700 /* The contents of 'tmp' will become bs_top, as we are
1701 * swapping bs_new and bs_top contents. */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001702 bs_top->backing_hd = bs_new;
1703 bs_top->open_flags &= ~BDRV_O_NO_BACKING;
1704 pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
1705 bs_new->filename);
1706 pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
1707 bs_new->drv ? bs_new->drv->format_name : "");
Jeff Cody8802d1f2012-02-28 15:54:06 -05001708}
1709
Fam Zheng4f6fd342013-08-23 09:14:47 +08001710static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00001711{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001712 assert(!bs->dev);
Paolo Bonzini3e914652012-03-30 13:17:11 +02001713 assert(!bs->job);
1714 assert(!bs->in_use);
Fam Zheng4f6fd342013-08-23 09:14:47 +08001715 assert(!bs->refcnt);
Fam Zhenge4654d22013-11-13 18:29:43 +08001716 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Markus Armbruster18846de2010-06-29 16:58:30 +02001717
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02001718 bdrv_close(bs);
1719
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01001720 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05001721 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00001722
Anthony Liguori7267c092011-08-20 22:09:37 -05001723 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00001724}
1725
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001726int bdrv_attach_dev(BlockDriverState *bs, void *dev)
1727/* TODO change to DeviceState *dev when all users are qdevified */
Markus Armbruster18846de2010-06-29 16:58:30 +02001728{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001729 if (bs->dev) {
Markus Armbruster18846de2010-06-29 16:58:30 +02001730 return -EBUSY;
1731 }
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001732 bs->dev = dev;
Luiz Capitulino28a72822011-09-26 17:43:50 -03001733 bdrv_iostatus_reset(bs);
Markus Armbruster18846de2010-06-29 16:58:30 +02001734 return 0;
1735}
1736
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001737/* TODO qdevified devices don't use this, remove when devices are qdevified */
1738void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
Markus Armbruster18846de2010-06-29 16:58:30 +02001739{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001740 if (bdrv_attach_dev(bs, dev) < 0) {
1741 abort();
1742 }
1743}
1744
1745void bdrv_detach_dev(BlockDriverState *bs, void *dev)
1746/* TODO change to DeviceState *dev when all users are qdevified */
1747{
1748 assert(bs->dev == dev);
1749 bs->dev = NULL;
Markus Armbruster0e49de52011-08-03 15:07:41 +02001750 bs->dev_ops = NULL;
1751 bs->dev_opaque = NULL;
Markus Armbruster29e05f22011-09-06 18:58:57 +02001752 bs->buffer_alignment = 512;
Markus Armbruster18846de2010-06-29 16:58:30 +02001753}
1754
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001755/* TODO change to return DeviceState * when all users are qdevified */
1756void *bdrv_get_attached_dev(BlockDriverState *bs)
Markus Armbruster18846de2010-06-29 16:58:30 +02001757{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001758 return bs->dev;
Markus Armbruster18846de2010-06-29 16:58:30 +02001759}
1760
Markus Armbruster0e49de52011-08-03 15:07:41 +02001761void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
1762 void *opaque)
1763{
1764 bs->dev_ops = ops;
1765 bs->dev_opaque = opaque;
1766}
1767
Paolo Bonzini32c81a42012-09-28 17:22:58 +02001768void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
1769 enum MonitorEvent ev,
1770 BlockErrorAction action, bool is_read)
Luiz Capitulino329c0a42012-01-25 16:59:43 -02001771{
1772 QObject *data;
1773 const char *action_str;
1774
1775 switch (action) {
1776 case BDRV_ACTION_REPORT:
1777 action_str = "report";
1778 break;
1779 case BDRV_ACTION_IGNORE:
1780 action_str = "ignore";
1781 break;
1782 case BDRV_ACTION_STOP:
1783 action_str = "stop";
1784 break;
1785 default:
1786 abort();
1787 }
1788
1789 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1790 bdrv->device_name,
1791 action_str,
1792 is_read ? "read" : "write");
Paolo Bonzini32c81a42012-09-28 17:22:58 +02001793 monitor_protocol_event(ev, data);
Luiz Capitulino329c0a42012-01-25 16:59:43 -02001794
1795 qobject_decref(data);
1796}
1797
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001798static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
1799{
1800 QObject *data;
1801
1802 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1803 bdrv_get_device_name(bs), ejected);
1804 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
1805
1806 qobject_decref(data);
1807}
1808
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001809static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
Markus Armbruster0e49de52011-08-03 15:07:41 +02001810{
Markus Armbruster145feb12011-08-03 15:07:42 +02001811 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001812 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001813 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001814 if (tray_was_closed) {
1815 /* tray open */
1816 bdrv_emit_qmp_eject_event(bs, true);
1817 }
1818 if (load) {
1819 /* tray close */
1820 bdrv_emit_qmp_eject_event(bs, false);
1821 }
Markus Armbruster145feb12011-08-03 15:07:42 +02001822 }
1823}
1824
Markus Armbruster2c6942f2011-09-06 18:58:51 +02001825bool bdrv_dev_has_removable_media(BlockDriverState *bs)
1826{
1827 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
1828}
1829
Paolo Bonzini025ccaa2011-11-07 17:50:13 +01001830void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
1831{
1832 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
1833 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
1834 }
1835}
1836
Markus Armbrustere4def802011-09-06 18:58:53 +02001837bool bdrv_dev_is_tray_open(BlockDriverState *bs)
1838{
1839 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
1840 return bs->dev_ops->is_tray_open(bs->dev_opaque);
1841 }
1842 return false;
1843}
1844
Markus Armbruster145feb12011-08-03 15:07:42 +02001845static void bdrv_dev_resize_cb(BlockDriverState *bs)
1846{
1847 if (bs->dev_ops && bs->dev_ops->resize_cb) {
1848 bs->dev_ops->resize_cb(bs->dev_opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +02001849 }
1850}
1851
Markus Armbrusterf1076392011-09-06 18:58:46 +02001852bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
1853{
1854 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
1855 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
1856 }
1857 return false;
1858}
1859
aliguorie97fc192009-04-21 23:11:50 +00001860/*
1861 * Run consistency checks on an image
1862 *
Kevin Wolfe076f332010-06-29 11:43:13 +02001863 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02001864 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02001865 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00001866 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02001867int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00001868{
1869 if (bs->drv->bdrv_check == NULL) {
1870 return -ENOTSUP;
1871 }
1872
Kevin Wolfe076f332010-06-29 11:43:13 +02001873 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02001874 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00001875}
1876
Kevin Wolf8a426612010-07-16 17:17:01 +02001877#define COMMIT_BUF_SECTORS 2048
1878
bellard33e39632003-07-06 17:15:21 +00001879/* commit COW file into the raw image */
1880int bdrv_commit(BlockDriverState *bs)
1881{
bellard19cb3732006-08-19 11:45:59 +00001882 BlockDriver *drv = bs->drv;
Kevin Wolf8a426612010-07-16 17:17:01 +02001883 int64_t sector, total_sectors;
1884 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04001885 int ret = 0;
Kevin Wolf8a426612010-07-16 17:17:01 +02001886 uint8_t *buf;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02001887 char filename[PATH_MAX];
bellard33e39632003-07-06 17:15:21 +00001888
bellard19cb3732006-08-19 11:45:59 +00001889 if (!drv)
1890 return -ENOMEDIUM;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001891
1892 if (!bs->backing_hd) {
1893 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00001894 }
1895
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00001896 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
1897 return -EBUSY;
1898 }
1899
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001900 ro = bs->backing_hd->read_only;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02001901 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1902 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001903 open_flags = bs->backing_hd->open_flags;
1904
1905 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04001906 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
1907 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001908 }
bellard33e39632003-07-06 17:15:21 +00001909 }
bellardea2384d2004-08-01 21:59:26 +00001910
Jan Kiszka6ea44302009-11-30 18:21:19 +01001911 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
Anthony Liguori7267c092011-08-20 22:09:37 -05001912 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
bellardea2384d2004-08-01 21:59:26 +00001913
Kevin Wolf8a426612010-07-16 17:17:01 +02001914 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02001915 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
1916 if (ret < 0) {
1917 goto ro_cleanup;
1918 }
1919 if (ret) {
Kevin Wolf8a426612010-07-16 17:17:01 +02001920 if (bdrv_read(bs, sector, buf, n) != 0) {
1921 ret = -EIO;
1922 goto ro_cleanup;
1923 }
1924
1925 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
1926 ret = -EIO;
1927 goto ro_cleanup;
1928 }
bellardea2384d2004-08-01 21:59:26 +00001929 }
1930 }
bellard95389c82005-12-18 18:28:15 +00001931
Christoph Hellwig1d449522010-01-17 12:32:30 +01001932 if (drv->bdrv_make_empty) {
1933 ret = drv->bdrv_make_empty(bs);
1934 bdrv_flush(bs);
1935 }
bellard95389c82005-12-18 18:28:15 +00001936
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01001937 /*
1938 * Make sure all data we wrote to the backing device is actually
1939 * stable on disk.
1940 */
1941 if (bs->backing_hd)
1942 bdrv_flush(bs->backing_hd);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001943
1944ro_cleanup:
Anthony Liguori7267c092011-08-20 22:09:37 -05001945 g_free(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001946
1947 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04001948 /* ignoring error return here */
1949 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001950 }
1951
Christoph Hellwig1d449522010-01-17 12:32:30 +01001952 return ret;
bellard33e39632003-07-06 17:15:21 +00001953}
1954
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001955int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001956{
1957 BlockDriverState *bs;
1958
1959 QTAILQ_FOREACH(bs, &bdrv_states, list) {
Jeff Cody272d2d82013-02-26 09:55:48 -05001960 if (bs->drv && bs->backing_hd) {
1961 int ret = bdrv_commit(bs);
1962 if (ret < 0) {
1963 return ret;
1964 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001965 }
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001966 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001967 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001968}
1969
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001970/**
1971 * Remove an active request from the tracked requests list
1972 *
1973 * This function should be called when a tracked request is completing.
1974 */
1975static void tracked_request_end(BdrvTrackedRequest *req)
1976{
1977 QLIST_REMOVE(req, list);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001978 qemu_co_queue_restart_all(&req->wait_queue);
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001979}
1980
1981/**
1982 * Add an active request to the tracked requests list
1983 */
1984static void tracked_request_begin(BdrvTrackedRequest *req,
1985 BlockDriverState *bs,
1986 int64_t sector_num,
1987 int nb_sectors, bool is_write)
1988{
1989 *req = (BdrvTrackedRequest){
1990 .bs = bs,
1991 .sector_num = sector_num,
1992 .nb_sectors = nb_sectors,
1993 .is_write = is_write,
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00001994 .co = qemu_coroutine_self(),
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001995 };
1996
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001997 qemu_co_queue_init(&req->wait_queue);
1998
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001999 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2000}
2001
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002002/**
2003 * Round a region to cluster boundaries
2004 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002005void bdrv_round_to_clusters(BlockDriverState *bs,
2006 int64_t sector_num, int nb_sectors,
2007 int64_t *cluster_sector_num,
2008 int *cluster_nb_sectors)
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002009{
2010 BlockDriverInfo bdi;
2011
2012 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2013 *cluster_sector_num = sector_num;
2014 *cluster_nb_sectors = nb_sectors;
2015 } else {
2016 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2017 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2018 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2019 nb_sectors, c);
2020 }
2021}
2022
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002023static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2024 int64_t sector_num, int nb_sectors) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002025 /* aaaa bbbb */
2026 if (sector_num >= req->sector_num + req->nb_sectors) {
2027 return false;
2028 }
2029 /* bbbb aaaa */
2030 if (req->sector_num >= sector_num + nb_sectors) {
2031 return false;
2032 }
2033 return true;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002034}
2035
2036static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
2037 int64_t sector_num, int nb_sectors)
2038{
2039 BdrvTrackedRequest *req;
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002040 int64_t cluster_sector_num;
2041 int cluster_nb_sectors;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002042 bool retry;
2043
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002044 /* If we touch the same cluster it counts as an overlap. This guarantees
2045 * that allocating writes will be serialized and not race with each other
2046 * for the same cluster. For example, in copy-on-read it ensures that the
2047 * CoR read and write operations are atomic and guest writes cannot
2048 * interleave between them.
2049 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002050 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2051 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002052
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002053 do {
2054 retry = false;
2055 QLIST_FOREACH(req, &bs->tracked_requests, list) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002056 if (tracked_request_overlaps(req, cluster_sector_num,
2057 cluster_nb_sectors)) {
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00002058 /* Hitting this means there was a reentrant request, for
2059 * example, a block driver issuing nested requests. This must
2060 * never happen since it means deadlock.
2061 */
2062 assert(qemu_coroutine_self() != req->co);
2063
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002064 qemu_co_queue_wait(&req->wait_queue);
2065 retry = true;
2066 break;
2067 }
2068 }
2069 } while (retry);
2070}
2071
Kevin Wolf756e6732010-01-12 12:55:17 +01002072/*
2073 * Return values:
2074 * 0 - success
2075 * -EINVAL - backing format specified, but no file
2076 * -ENOSPC - can't update the backing file because no space is left in the
2077 * image file header
2078 * -ENOTSUP - format driver doesn't support changing the backing file
2079 */
2080int bdrv_change_backing_file(BlockDriverState *bs,
2081 const char *backing_file, const char *backing_fmt)
2082{
2083 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002084 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002085
Paolo Bonzini5f377792012-04-12 14:01:01 +02002086 /* Backing file format doesn't make sense without a backing file */
2087 if (backing_fmt && !backing_file) {
2088 return -EINVAL;
2089 }
2090
Kevin Wolf756e6732010-01-12 12:55:17 +01002091 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002092 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002093 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002094 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002095 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002096
2097 if (ret == 0) {
2098 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2099 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2100 }
2101 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002102}
2103
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002104/*
2105 * Finds the image layer in the chain that has 'bs' as its backing file.
2106 *
2107 * active is the current topmost image.
2108 *
2109 * Returns NULL if bs is not found in active's image chain,
2110 * or if active == bs.
2111 */
2112BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2113 BlockDriverState *bs)
2114{
2115 BlockDriverState *overlay = NULL;
2116 BlockDriverState *intermediate;
2117
2118 assert(active != NULL);
2119 assert(bs != NULL);
2120
2121 /* if bs is the same as active, then by definition it has no overlay
2122 */
2123 if (active == bs) {
2124 return NULL;
2125 }
2126
2127 intermediate = active;
2128 while (intermediate->backing_hd) {
2129 if (intermediate->backing_hd == bs) {
2130 overlay = intermediate;
2131 break;
2132 }
2133 intermediate = intermediate->backing_hd;
2134 }
2135
2136 return overlay;
2137}
2138
2139typedef struct BlkIntermediateStates {
2140 BlockDriverState *bs;
2141 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2142} BlkIntermediateStates;
2143
2144
2145/*
2146 * Drops images above 'base' up to and including 'top', and sets the image
2147 * above 'top' to have base as its backing file.
2148 *
2149 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2150 * information in 'bs' can be properly updated.
2151 *
2152 * E.g., this will convert the following chain:
2153 * bottom <- base <- intermediate <- top <- active
2154 *
2155 * to
2156 *
2157 * bottom <- base <- active
2158 *
2159 * It is allowed for bottom==base, in which case it converts:
2160 *
2161 * base <- intermediate <- top <- active
2162 *
2163 * to
2164 *
2165 * base <- active
2166 *
2167 * Error conditions:
2168 * if active == top, that is considered an error
2169 *
2170 */
2171int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2172 BlockDriverState *base)
2173{
2174 BlockDriverState *intermediate;
2175 BlockDriverState *base_bs = NULL;
2176 BlockDriverState *new_top_bs = NULL;
2177 BlkIntermediateStates *intermediate_state, *next;
2178 int ret = -EIO;
2179
2180 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2181 QSIMPLEQ_INIT(&states_to_delete);
2182
2183 if (!top->drv || !base->drv) {
2184 goto exit;
2185 }
2186
2187 new_top_bs = bdrv_find_overlay(active, top);
2188
2189 if (new_top_bs == NULL) {
2190 /* we could not find the image above 'top', this is an error */
2191 goto exit;
2192 }
2193
2194 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2195 * to do, no intermediate images */
2196 if (new_top_bs->backing_hd == base) {
2197 ret = 0;
2198 goto exit;
2199 }
2200
2201 intermediate = top;
2202
2203 /* now we will go down through the list, and add each BDS we find
2204 * into our deletion queue, until we hit the 'base'
2205 */
2206 while (intermediate) {
2207 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2208 intermediate_state->bs = intermediate;
2209 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2210
2211 if (intermediate->backing_hd == base) {
2212 base_bs = intermediate->backing_hd;
2213 break;
2214 }
2215 intermediate = intermediate->backing_hd;
2216 }
2217 if (base_bs == NULL) {
2218 /* something went wrong, we did not end at the base. safely
2219 * unravel everything, and exit with error */
2220 goto exit;
2221 }
2222
2223 /* success - we can delete the intermediate states, and link top->base */
2224 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2225 base_bs->drv ? base_bs->drv->format_name : "");
2226 if (ret) {
2227 goto exit;
2228 }
2229 new_top_bs->backing_hd = base_bs;
2230
2231
2232 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2233 /* so that bdrv_close() does not recursively close the chain */
2234 intermediate_state->bs->backing_hd = NULL;
Fam Zheng4f6fd342013-08-23 09:14:47 +08002235 bdrv_unref(intermediate_state->bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002236 }
2237 ret = 0;
2238
2239exit:
2240 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2241 g_free(intermediate_state);
2242 }
2243 return ret;
2244}
2245
2246
aliguori71d07702009-03-03 17:37:16 +00002247static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2248 size_t size)
2249{
2250 int64_t len;
2251
2252 if (!bdrv_is_inserted(bs))
2253 return -ENOMEDIUM;
2254
2255 if (bs->growable)
2256 return 0;
2257
2258 len = bdrv_getlength(bs);
2259
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02002260 if (offset < 0)
2261 return -EIO;
2262
2263 if ((offset > len) || (len - offset < size))
aliguori71d07702009-03-03 17:37:16 +00002264 return -EIO;
2265
2266 return 0;
2267}
2268
2269static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2270 int nb_sectors)
2271{
Jes Sorenseneb5a3162010-05-27 16:20:31 +02002272 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2273 nb_sectors * BDRV_SECTOR_SIZE);
aliguori71d07702009-03-03 17:37:16 +00002274}
2275
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002276typedef struct RwCo {
2277 BlockDriverState *bs;
2278 int64_t sector_num;
2279 int nb_sectors;
2280 QEMUIOVector *qiov;
2281 bool is_write;
2282 int ret;
Peter Lieven4105eaa2013-07-11 14:16:22 +02002283 BdrvRequestFlags flags;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002284} RwCo;
2285
2286static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2287{
2288 RwCo *rwco = opaque;
2289
2290 if (!rwco->is_write) {
2291 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002292 rwco->nb_sectors, rwco->qiov,
2293 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002294 } else {
2295 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002296 rwco->nb_sectors, rwco->qiov,
2297 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002298 }
2299}
2300
2301/*
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002302 * Process a vectored synchronous request using coroutines
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002303 */
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002304static int bdrv_rwv_co(BlockDriverState *bs, int64_t sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002305 QEMUIOVector *qiov, bool is_write,
2306 BdrvRequestFlags flags)
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002307{
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002308 Coroutine *co;
2309 RwCo rwco = {
2310 .bs = bs,
2311 .sector_num = sector_num,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002312 .nb_sectors = qiov->size >> BDRV_SECTOR_BITS,
2313 .qiov = qiov,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002314 .is_write = is_write,
2315 .ret = NOT_DONE,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002316 .flags = flags,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002317 };
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002318 assert((qiov->size & (BDRV_SECTOR_SIZE - 1)) == 0);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002319
Zhi Yong Wu498e3862012-04-02 18:59:34 +08002320 /**
2321 * In sync call context, when the vcpu is blocked, this throttling timer
2322 * will not fire; so the I/O throttling function has to be disabled here
2323 * if it has been enabled.
2324 */
2325 if (bs->io_limits_enabled) {
2326 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2327 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2328 bdrv_io_limits_disable(bs);
2329 }
2330
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002331 if (qemu_in_coroutine()) {
2332 /* Fast-path if already in coroutine context */
2333 bdrv_rw_co_entry(&rwco);
2334 } else {
2335 co = qemu_coroutine_create(bdrv_rw_co_entry);
2336 qemu_coroutine_enter(co, &rwco);
2337 while (rwco.ret == NOT_DONE) {
2338 qemu_aio_wait();
2339 }
2340 }
2341 return rwco.ret;
2342}
2343
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002344/*
2345 * Process a synchronous request using coroutines
2346 */
2347static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002348 int nb_sectors, bool is_write, BdrvRequestFlags flags)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002349{
2350 QEMUIOVector qiov;
2351 struct iovec iov = {
2352 .iov_base = (void *)buf,
2353 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2354 };
2355
2356 qemu_iovec_init_external(&qiov, &iov, 1);
Peter Lieven4105eaa2013-07-11 14:16:22 +02002357 return bdrv_rwv_co(bs, sector_num, &qiov, is_write, flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002358}
2359
bellard19cb3732006-08-19 11:45:59 +00002360/* return < 0 if error. See bdrv_write() for the return codes */
ths5fafdf22007-09-16 21:08:06 +00002361int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002362 uint8_t *buf, int nb_sectors)
2363{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002364 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
bellardfc01f7e2003-06-30 10:03:06 +00002365}
2366
Markus Armbruster07d27a42012-06-29 17:34:29 +02002367/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2368int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2369 uint8_t *buf, int nb_sectors)
2370{
2371 bool enabled;
2372 int ret;
2373
2374 enabled = bs->io_limits_enabled;
2375 bs->io_limits_enabled = false;
Peter Lieven4e7395e2013-07-18 10:37:32 +02002376 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
Markus Armbruster07d27a42012-06-29 17:34:29 +02002377 bs->io_limits_enabled = enabled;
2378 return ret;
2379}
2380
ths5fafdf22007-09-16 21:08:06 +00002381/* Return < 0 if error. Important errors are:
bellard19cb3732006-08-19 11:45:59 +00002382 -EIO generic I/O error (may happen for all errors)
2383 -ENOMEDIUM No media inserted.
2384 -EINVAL Invalid sector number or nb_sectors
2385 -EACCES Trying to write a read-only device
2386*/
ths5fafdf22007-09-16 21:08:06 +00002387int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002388 const uint8_t *buf, int nb_sectors)
2389{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002390 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
bellard83f64092006-08-01 16:21:11 +00002391}
2392
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002393int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov)
2394{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002395 return bdrv_rwv_co(bs, sector_num, qiov, true, 0);
2396}
2397
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002398int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2399 int nb_sectors, BdrvRequestFlags flags)
Peter Lieven4105eaa2013-07-11 14:16:22 +02002400{
2401 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002402 BDRV_REQ_ZERO_WRITE | flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002403}
2404
Peter Lievend75cbb52013-10-24 12:07:03 +02002405/*
2406 * Completely zero out a block device with the help of bdrv_write_zeroes.
2407 * The operation is sped up by checking the block status and only writing
2408 * zeroes to the device if they currently do not return zeroes. Optional
2409 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2410 *
2411 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2412 */
2413int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2414{
2415 int64_t target_size = bdrv_getlength(bs) / BDRV_SECTOR_SIZE;
2416 int64_t ret, nb_sectors, sector_num = 0;
2417 int n;
2418
2419 for (;;) {
2420 nb_sectors = target_size - sector_num;
2421 if (nb_sectors <= 0) {
2422 return 0;
2423 }
2424 if (nb_sectors > INT_MAX) {
2425 nb_sectors = INT_MAX;
2426 }
2427 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
2428 if (ret & BDRV_BLOCK_ZERO) {
2429 sector_num += n;
2430 continue;
2431 }
2432 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2433 if (ret < 0) {
2434 error_report("error writing zeroes at sector %" PRId64 ": %s",
2435 sector_num, strerror(-ret));
2436 return ret;
2437 }
2438 sector_num += n;
2439 }
2440}
2441
aliguorieda578e2009-03-12 19:57:16 +00002442int bdrv_pread(BlockDriverState *bs, int64_t offset,
2443 void *buf, int count1)
bellard83f64092006-08-01 16:21:11 +00002444{
Jan Kiszka6ea44302009-11-30 18:21:19 +01002445 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
bellard83f64092006-08-01 16:21:11 +00002446 int len, nb_sectors, count;
2447 int64_t sector_num;
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002448 int ret;
bellard83f64092006-08-01 16:21:11 +00002449
2450 count = count1;
2451 /* first read to align to sector start */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002452 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
bellard83f64092006-08-01 16:21:11 +00002453 if (len > count)
2454 len = count;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002455 sector_num = offset >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002456 if (len > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002457 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2458 return ret;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002459 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
bellard83f64092006-08-01 16:21:11 +00002460 count -= len;
2461 if (count == 0)
2462 return count1;
2463 sector_num++;
2464 buf += len;
2465 }
2466
2467 /* read the sectors "in place" */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002468 nb_sectors = count >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002469 if (nb_sectors > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002470 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
2471 return ret;
bellard83f64092006-08-01 16:21:11 +00002472 sector_num += nb_sectors;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002473 len = nb_sectors << BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002474 buf += len;
2475 count -= len;
2476 }
2477
2478 /* add data from the last sector */
2479 if (count > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002480 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2481 return ret;
bellard83f64092006-08-01 16:21:11 +00002482 memcpy(buf, tmp_buf, count);
2483 }
2484 return count1;
2485}
2486
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002487int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
bellard83f64092006-08-01 16:21:11 +00002488{
Jan Kiszka6ea44302009-11-30 18:21:19 +01002489 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
bellard83f64092006-08-01 16:21:11 +00002490 int len, nb_sectors, count;
2491 int64_t sector_num;
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002492 int ret;
bellard83f64092006-08-01 16:21:11 +00002493
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002494 count = qiov->size;
2495
bellard83f64092006-08-01 16:21:11 +00002496 /* first write to align to sector start */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002497 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
bellard83f64092006-08-01 16:21:11 +00002498 if (len > count)
2499 len = count;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002500 sector_num = offset >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002501 if (len > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002502 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2503 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002504 qemu_iovec_to_buf(qiov, 0, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)),
2505 len);
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002506 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2507 return ret;
bellard83f64092006-08-01 16:21:11 +00002508 count -= len;
2509 if (count == 0)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002510 return qiov->size;
bellard83f64092006-08-01 16:21:11 +00002511 sector_num++;
bellard83f64092006-08-01 16:21:11 +00002512 }
2513
2514 /* write the sectors "in place" */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002515 nb_sectors = count >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002516 if (nb_sectors > 0) {
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002517 QEMUIOVector qiov_inplace;
2518
2519 qemu_iovec_init(&qiov_inplace, qiov->niov);
2520 qemu_iovec_concat(&qiov_inplace, qiov, len,
2521 nb_sectors << BDRV_SECTOR_BITS);
2522 ret = bdrv_writev(bs, sector_num, &qiov_inplace);
2523 qemu_iovec_destroy(&qiov_inplace);
2524 if (ret < 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002525 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002526 }
2527
bellard83f64092006-08-01 16:21:11 +00002528 sector_num += nb_sectors;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002529 len = nb_sectors << BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002530 count -= len;
2531 }
2532
2533 /* add data from the last sector */
2534 if (count > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002535 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2536 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002537 qemu_iovec_to_buf(qiov, qiov->size - count, tmp_buf, count);
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002538 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2539 return ret;
bellard83f64092006-08-01 16:21:11 +00002540 }
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002541 return qiov->size;
2542}
2543
2544int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2545 const void *buf, int count1)
2546{
2547 QEMUIOVector qiov;
2548 struct iovec iov = {
2549 .iov_base = (void *) buf,
2550 .iov_len = count1,
2551 };
2552
2553 qemu_iovec_init_external(&qiov, &iov, 1);
2554 return bdrv_pwritev(bs, offset, &qiov);
bellard83f64092006-08-01 16:21:11 +00002555}
bellard83f64092006-08-01 16:21:11 +00002556
Kevin Wolff08145f2010-06-16 16:38:15 +02002557/*
2558 * Writes to the file and ensures that no writes are reordered across this
2559 * request (acts as a barrier)
2560 *
2561 * Returns 0 on success, -errno in error cases.
2562 */
2563int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2564 const void *buf, int count)
2565{
2566 int ret;
2567
2568 ret = bdrv_pwrite(bs, offset, buf, count);
2569 if (ret < 0) {
2570 return ret;
2571 }
2572
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002573 /* No flush needed for cache modes that already do it */
2574 if (bs->enable_write_cache) {
Kevin Wolff08145f2010-06-16 16:38:15 +02002575 bdrv_flush(bs);
2576 }
2577
2578 return 0;
2579}
2580
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002581static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002582 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2583{
2584 /* Perform I/O through a temporary buffer so that users who scribble over
2585 * their read buffer while the operation is in progress do not end up
2586 * modifying the image file. This is critical for zero-copy guest I/O
2587 * where anything might happen inside guest memory.
2588 */
2589 void *bounce_buffer;
2590
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002591 BlockDriver *drv = bs->drv;
Stefan Hajnocziab185922011-11-17 13:40:31 +00002592 struct iovec iov;
2593 QEMUIOVector bounce_qiov;
2594 int64_t cluster_sector_num;
2595 int cluster_nb_sectors;
2596 size_t skip_bytes;
2597 int ret;
2598
2599 /* Cover entire cluster so no additional backing file I/O is required when
2600 * allocating cluster in the image file.
2601 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002602 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2603 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002604
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002605 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2606 cluster_sector_num, cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002607
2608 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2609 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2610 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2611
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002612 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2613 &bounce_qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002614 if (ret < 0) {
2615 goto err;
2616 }
2617
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002618 if (drv->bdrv_co_write_zeroes &&
2619 buffer_is_zero(bounce_buffer, iov.iov_len)) {
Kevin Wolf621f0582012-03-20 15:12:58 +01002620 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002621 cluster_nb_sectors, 0);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002622 } else {
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002623 /* This does not change the data on the disk, it is not necessary
2624 * to flush even in cache=writethrough mode.
2625 */
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002626 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002627 &bounce_qiov);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002628 }
2629
Stefan Hajnocziab185922011-11-17 13:40:31 +00002630 if (ret < 0) {
2631 /* It might be okay to ignore write errors for guest requests. If this
2632 * is a deliberate copy-on-read then we don't want to ignore the error.
2633 * Simply report it in all cases.
2634 */
2635 goto err;
2636 }
2637
2638 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
Michael Tokarev03396142012-06-07 20:17:55 +04002639 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2640 nb_sectors * BDRV_SECTOR_SIZE);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002641
2642err:
2643 qemu_vfree(bounce_buffer);
2644 return ret;
2645}
2646
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002647/*
2648 * Handle a read request in coroutine context
2649 */
2650static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002651 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2652 BdrvRequestFlags flags)
Kevin Wolfda1fa912011-07-14 17:27:13 +02002653{
2654 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002655 BdrvTrackedRequest req;
2656 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002657
Kevin Wolfda1fa912011-07-14 17:27:13 +02002658 if (!drv) {
2659 return -ENOMEDIUM;
2660 }
2661 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2662 return -EIO;
2663 }
2664
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002665 if (bs->copy_on_read) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002666 flags |= BDRV_REQ_COPY_ON_READ;
2667 }
2668 if (flags & BDRV_REQ_COPY_ON_READ) {
2669 bs->copy_on_read_in_flight++;
2670 }
2671
2672 if (bs->copy_on_read_in_flight) {
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002673 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2674 }
2675
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02002676 /* throttling disk I/O */
2677 if (bs->io_limits_enabled) {
2678 bdrv_io_limits_intercept(bs, nb_sectors, false);
2679 }
2680
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002681 tracked_request_begin(&req, bs, sector_num, nb_sectors, false);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002682
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002683 if (flags & BDRV_REQ_COPY_ON_READ) {
Stefan Hajnocziab185922011-11-17 13:40:31 +00002684 int pnum;
2685
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02002686 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002687 if (ret < 0) {
2688 goto out;
2689 }
2690
2691 if (!ret || pnum != nb_sectors) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002692 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002693 goto out;
2694 }
2695 }
2696
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08002697 if (!(bs->zero_beyond_eof && bs->growable)) {
2698 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
2699 } else {
2700 /* Read zeros after EOF of growable BDSes */
2701 int64_t len, total_sectors, max_nb_sectors;
2702
2703 len = bdrv_getlength(bs);
2704 if (len < 0) {
2705 ret = len;
2706 goto out;
2707 }
2708
Fam Zhengd055a1f2013-09-26 19:55:33 +08002709 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08002710 max_nb_sectors = MAX(0, total_sectors - sector_num);
2711 if (max_nb_sectors > 0) {
2712 ret = drv->bdrv_co_readv(bs, sector_num,
2713 MIN(nb_sectors, max_nb_sectors), qiov);
2714 } else {
2715 ret = 0;
2716 }
2717
2718 /* Reading beyond end of file is supposed to produce zeroes */
2719 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
2720 uint64_t offset = MAX(0, total_sectors - sector_num);
2721 uint64_t bytes = (sector_num + nb_sectors - offset) *
2722 BDRV_SECTOR_SIZE;
2723 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
2724 }
2725 }
Stefan Hajnocziab185922011-11-17 13:40:31 +00002726
2727out:
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002728 tracked_request_end(&req);
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002729
2730 if (flags & BDRV_REQ_COPY_ON_READ) {
2731 bs->copy_on_read_in_flight--;
2732 }
2733
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002734 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002735}
2736
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002737int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
Kevin Wolfda1fa912011-07-14 17:27:13 +02002738 int nb_sectors, QEMUIOVector *qiov)
2739{
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002740 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02002741
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002742 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
2743}
2744
2745int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
2746 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2747{
2748 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
2749
2750 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
2751 BDRV_REQ_COPY_ON_READ);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002752}
2753
Peter Lievenc31cb702013-10-24 12:06:58 +02002754/* if no limit is specified in the BlockLimits use a default
2755 * of 32768 512-byte sectors (16 MiB) per request.
2756 */
2757#define MAX_WRITE_ZEROES_DEFAULT 32768
2758
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002759static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002760 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002761{
2762 BlockDriver *drv = bs->drv;
2763 QEMUIOVector qiov;
Peter Lievenc31cb702013-10-24 12:06:58 +02002764 struct iovec iov = {0};
2765 int ret = 0;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002766
Peter Lievenc31cb702013-10-24 12:06:58 +02002767 int max_write_zeroes = bs->bl.max_write_zeroes ?
2768 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
Kevin Wolf621f0582012-03-20 15:12:58 +01002769
Peter Lievenc31cb702013-10-24 12:06:58 +02002770 while (nb_sectors > 0 && !ret) {
2771 int num = nb_sectors;
2772
2773 /* align request */
2774 if (bs->bl.write_zeroes_alignment &&
2775 num >= bs->bl.write_zeroes_alignment &&
2776 sector_num % bs->bl.write_zeroes_alignment) {
2777 if (num > bs->bl.write_zeroes_alignment) {
2778 num = bs->bl.write_zeroes_alignment;
2779 }
2780 num -= sector_num % bs->bl.write_zeroes_alignment;
Kevin Wolf621f0582012-03-20 15:12:58 +01002781 }
Peter Lievenc31cb702013-10-24 12:06:58 +02002782
2783 /* limit request size */
2784 if (num > max_write_zeroes) {
2785 num = max_write_zeroes;
2786 }
2787
2788 ret = -ENOTSUP;
2789 /* First try the efficient write zeroes operation */
2790 if (drv->bdrv_co_write_zeroes) {
2791 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
2792 }
2793
2794 if (ret == -ENOTSUP) {
2795 /* Fall back to bounce buffer if write zeroes is unsupported */
2796 iov.iov_len = num * BDRV_SECTOR_SIZE;
2797 if (iov.iov_base == NULL) {
2798 /* allocate bounce buffer only once and ensure that it
2799 * is big enough for this and all future requests.
2800 */
2801 size_t bufsize = num <= nb_sectors ? num : max_write_zeroes;
2802 iov.iov_base = qemu_blockalign(bs, bufsize * BDRV_SECTOR_SIZE);
2803 memset(iov.iov_base, 0, bufsize * BDRV_SECTOR_SIZE);
2804 }
2805 qemu_iovec_init_external(&qiov, &iov, 1);
2806
2807 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
2808 }
2809
2810 sector_num += num;
2811 nb_sectors -= num;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002812 }
2813
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002814 qemu_vfree(iov.iov_base);
2815 return ret;
2816}
2817
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002818/*
2819 * Handle a write request in coroutine context
2820 */
2821static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002822 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2823 BdrvRequestFlags flags)
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002824{
2825 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002826 BdrvTrackedRequest req;
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002827 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002828
2829 if (!bs->drv) {
2830 return -ENOMEDIUM;
2831 }
2832 if (bs->read_only) {
2833 return -EACCES;
2834 }
2835 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2836 return -EIO;
2837 }
2838
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002839 if (bs->copy_on_read_in_flight) {
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002840 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2841 }
2842
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02002843 /* throttling disk I/O */
2844 if (bs->io_limits_enabled) {
2845 bdrv_io_limits_intercept(bs, nb_sectors, true);
2846 }
2847
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002848 tracked_request_begin(&req, bs, sector_num, nb_sectors, true);
2849
Stefan Hajnoczid616b222013-06-24 17:13:10 +02002850 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, &req);
2851
2852 if (ret < 0) {
2853 /* Do nothing, write notifier decided to fail this request */
2854 } else if (flags & BDRV_REQ_ZERO_WRITE) {
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002855 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002856 } else {
2857 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
2858 }
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002859
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002860 if (ret == 0 && !bs->enable_write_cache) {
2861 ret = bdrv_co_flush(bs);
2862 }
2863
Fam Zhenge4654d22013-11-13 18:29:43 +08002864 bdrv_set_dirty(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02002865
2866 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2867 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2868 }
Paolo Bonzinidf2a6f22013-09-04 19:00:21 +02002869 if (bs->growable && ret >= 0) {
2870 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
2871 }
Kevin Wolfda1fa912011-07-14 17:27:13 +02002872
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002873 tracked_request_end(&req);
2874
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002875 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002876}
2877
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002878int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
2879 int nb_sectors, QEMUIOVector *qiov)
2880{
2881 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
2882
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002883 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
2884}
2885
2886int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002887 int64_t sector_num, int nb_sectors,
2888 BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002889{
2890 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2891
Peter Lievend32f35c2013-10-24 12:06:52 +02002892 if (!(bs->open_flags & BDRV_O_UNMAP)) {
2893 flags &= ~BDRV_REQ_MAY_UNMAP;
2894 }
2895
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002896 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002897 BDRV_REQ_ZERO_WRITE | flags);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002898}
2899
bellard83f64092006-08-01 16:21:11 +00002900/**
bellard83f64092006-08-01 16:21:11 +00002901 * Truncate file to 'offset' bytes (needed only for file protocols)
2902 */
2903int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2904{
2905 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002906 int ret;
bellard83f64092006-08-01 16:21:11 +00002907 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002908 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00002909 if (!drv->bdrv_truncate)
2910 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02002911 if (bs->read_only)
2912 return -EACCES;
Marcelo Tosatti85916752011-01-26 12:12:35 -02002913 if (bdrv_in_use(bs))
2914 return -EBUSY;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002915 ret = drv->bdrv_truncate(bs, offset);
2916 if (ret == 0) {
2917 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
Markus Armbruster145feb12011-08-03 15:07:42 +02002918 bdrv_dev_resize_cb(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002919 }
2920 return ret;
bellard83f64092006-08-01 16:21:11 +00002921}
2922
2923/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002924 * Length of a allocated file in bytes. Sparse files are counted by actual
2925 * allocated space. Return < 0 if error or unknown.
2926 */
2927int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2928{
2929 BlockDriver *drv = bs->drv;
2930 if (!drv) {
2931 return -ENOMEDIUM;
2932 }
2933 if (drv->bdrv_get_allocated_file_size) {
2934 return drv->bdrv_get_allocated_file_size(bs);
2935 }
2936 if (bs->file) {
2937 return bdrv_get_allocated_file_size(bs->file);
2938 }
2939 return -ENOTSUP;
2940}
2941
2942/**
bellard83f64092006-08-01 16:21:11 +00002943 * Length of a file in bytes. Return < 0 if error or unknown.
2944 */
2945int64_t bdrv_getlength(BlockDriverState *bs)
2946{
2947 BlockDriver *drv = bs->drv;
2948 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002949 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002950
Kevin Wolfb94a2612013-10-29 12:18:58 +01002951 if (drv->has_variable_length) {
2952 int ret = refresh_total_sectors(bs, bs->total_sectors);
2953 if (ret < 0) {
2954 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002955 }
bellard83f64092006-08-01 16:21:11 +00002956 }
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002957 return bs->total_sectors * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00002958}
2959
bellard19cb3732006-08-19 11:45:59 +00002960/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00002961void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00002962{
bellard19cb3732006-08-19 11:45:59 +00002963 int64_t length;
2964 length = bdrv_getlength(bs);
2965 if (length < 0)
2966 length = 0;
2967 else
Jan Kiszka6ea44302009-11-30 18:21:19 +01002968 length = length >> BDRV_SECTOR_BITS;
bellard19cb3732006-08-19 11:45:59 +00002969 *nb_sectors_ptr = length;
bellardfc01f7e2003-06-30 10:03:06 +00002970}
bellardcf989512004-02-16 21:56:36 +00002971
Paolo Bonziniff06f5f2012-09-28 17:22:54 +02002972void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2973 BlockdevOnError on_write_error)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02002974{
2975 bs->on_read_error = on_read_error;
2976 bs->on_write_error = on_write_error;
2977}
2978
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +02002979BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02002980{
2981 return is_read ? bs->on_read_error : bs->on_write_error;
2982}
2983
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002984BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2985{
2986 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2987
2988 switch (on_err) {
2989 case BLOCKDEV_ON_ERROR_ENOSPC:
2990 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
2991 case BLOCKDEV_ON_ERROR_STOP:
2992 return BDRV_ACTION_STOP;
2993 case BLOCKDEV_ON_ERROR_REPORT:
2994 return BDRV_ACTION_REPORT;
2995 case BLOCKDEV_ON_ERROR_IGNORE:
2996 return BDRV_ACTION_IGNORE;
2997 default:
2998 abort();
2999 }
3000}
3001
3002/* This is done by device models because, while the block layer knows
3003 * about the error, it does not know whether an operation comes from
3004 * the device or the block layer (from a job, for example).
3005 */
3006void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3007 bool is_read, int error)
3008{
3009 assert(error >= 0);
Paolo Bonzini32c81a42012-09-28 17:22:58 +02003010 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003011 if (action == BDRV_ACTION_STOP) {
3012 vm_stop(RUN_STATE_IO_ERROR);
3013 bdrv_iostatus_set_err(bs, error);
3014 }
3015}
3016
bellardb3380822004-03-14 21:38:54 +00003017int bdrv_is_read_only(BlockDriverState *bs)
3018{
3019 return bs->read_only;
3020}
3021
ths985a03b2007-12-24 16:10:43 +00003022int bdrv_is_sg(BlockDriverState *bs)
3023{
3024 return bs->sg;
3025}
3026
Christoph Hellwige900a7b2009-09-04 19:01:15 +02003027int bdrv_enable_write_cache(BlockDriverState *bs)
3028{
3029 return bs->enable_write_cache;
3030}
3031
Paolo Bonzini425b0142012-06-06 00:04:52 +02003032void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3033{
3034 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04003035
3036 /* so a reopen() will preserve wce */
3037 if (wce) {
3038 bs->open_flags |= BDRV_O_CACHE_WB;
3039 } else {
3040 bs->open_flags &= ~BDRV_O_CACHE_WB;
3041 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02003042}
3043
bellardea2384d2004-08-01 21:59:26 +00003044int bdrv_is_encrypted(BlockDriverState *bs)
3045{
3046 if (bs->backing_hd && bs->backing_hd->encrypted)
3047 return 1;
3048 return bs->encrypted;
3049}
3050
aliguoric0f4ce72009-03-05 23:01:01 +00003051int bdrv_key_required(BlockDriverState *bs)
3052{
3053 BlockDriverState *backing_hd = bs->backing_hd;
3054
3055 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3056 return 1;
3057 return (bs->encrypted && !bs->valid_key);
3058}
3059
bellardea2384d2004-08-01 21:59:26 +00003060int bdrv_set_key(BlockDriverState *bs, const char *key)
3061{
3062 int ret;
3063 if (bs->backing_hd && bs->backing_hd->encrypted) {
3064 ret = bdrv_set_key(bs->backing_hd, key);
3065 if (ret < 0)
3066 return ret;
3067 if (!bs->encrypted)
3068 return 0;
3069 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02003070 if (!bs->encrypted) {
3071 return -EINVAL;
3072 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3073 return -ENOMEDIUM;
3074 }
aliguoric0f4ce72009-03-05 23:01:01 +00003075 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00003076 if (ret < 0) {
3077 bs->valid_key = 0;
3078 } else if (!bs->valid_key) {
3079 bs->valid_key = 1;
3080 /* call the change callback now, we skipped it on open */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02003081 bdrv_dev_change_media_cb(bs, true);
aliguoribb5fc202009-03-05 23:01:15 +00003082 }
aliguoric0f4ce72009-03-05 23:01:01 +00003083 return ret;
bellardea2384d2004-08-01 21:59:26 +00003084}
3085
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003086const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00003087{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003088 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00003089}
3090
ths5fafdf22007-09-16 21:08:06 +00003091void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00003092 void *opaque)
3093{
3094 BlockDriver *drv;
3095
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01003096 QLIST_FOREACH(drv, &bdrv_drivers, list) {
bellardea2384d2004-08-01 21:59:26 +00003097 it(opaque, drv->format_name);
3098 }
3099}
3100
bellardb3380822004-03-14 21:38:54 +00003101BlockDriverState *bdrv_find(const char *name)
3102{
3103 BlockDriverState *bs;
3104
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003105 QTAILQ_FOREACH(bs, &bdrv_states, list) {
3106 if (!strcmp(name, bs->device_name)) {
bellardb3380822004-03-14 21:38:54 +00003107 return bs;
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003108 }
bellardb3380822004-03-14 21:38:54 +00003109 }
3110 return NULL;
3111}
3112
Markus Armbruster2f399b02010-06-02 18:55:20 +02003113BlockDriverState *bdrv_next(BlockDriverState *bs)
3114{
3115 if (!bs) {
3116 return QTAILQ_FIRST(&bdrv_states);
3117 }
3118 return QTAILQ_NEXT(bs, list);
3119}
3120
aliguori51de9762009-03-05 23:00:43 +00003121void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
bellard81d09122004-07-14 17:21:37 +00003122{
3123 BlockDriverState *bs;
3124
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003125 QTAILQ_FOREACH(bs, &bdrv_states, list) {
aliguori51de9762009-03-05 23:00:43 +00003126 it(opaque, bs);
bellard81d09122004-07-14 17:21:37 +00003127 }
3128}
3129
bellardea2384d2004-08-01 21:59:26 +00003130const char *bdrv_get_device_name(BlockDriverState *bs)
3131{
3132 return bs->device_name;
3133}
3134
Markus Armbrusterc8433282012-06-05 16:49:24 +02003135int bdrv_get_flags(BlockDriverState *bs)
3136{
3137 return bs->open_flags;
3138}
3139
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003140int bdrv_flush_all(void)
aliguoric6ca28d2008-10-06 13:55:43 +00003141{
3142 BlockDriverState *bs;
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003143 int result = 0;
aliguoric6ca28d2008-10-06 13:55:43 +00003144
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003145 QTAILQ_FOREACH(bs, &bdrv_states, list) {
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003146 int ret = bdrv_flush(bs);
3147 if (ret < 0 && !result) {
3148 result = ret;
3149 }
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003150 }
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003151
3152 return result;
aliguoric6ca28d2008-10-06 13:55:43 +00003153}
3154
Peter Lieven3ac21622013-06-28 12:47:42 +02003155int bdrv_has_zero_init_1(BlockDriverState *bs)
3156{
3157 return 1;
3158}
3159
Kevin Wolff2feebb2010-04-14 17:30:35 +02003160int bdrv_has_zero_init(BlockDriverState *bs)
3161{
3162 assert(bs->drv);
3163
Paolo Bonzini11212d82013-09-04 19:00:27 +02003164 /* If BS is a copy on write image, it is initialized to
3165 the contents of the base image, which may not be zeroes. */
3166 if (bs->backing_hd) {
3167 return 0;
3168 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02003169 if (bs->drv->bdrv_has_zero_init) {
3170 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02003171 }
3172
Peter Lieven3ac21622013-06-28 12:47:42 +02003173 /* safe default */
3174 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02003175}
3176
Peter Lieven4ce78692013-10-24 12:06:54 +02003177bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3178{
3179 BlockDriverInfo bdi;
3180
3181 if (bs->backing_hd) {
3182 return false;
3183 }
3184
3185 if (bdrv_get_info(bs, &bdi) == 0) {
3186 return bdi.unallocated_blocks_are_zero;
3187 }
3188
3189 return false;
3190}
3191
3192bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3193{
3194 BlockDriverInfo bdi;
3195
3196 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3197 return false;
3198 }
3199
3200 if (bdrv_get_info(bs, &bdi) == 0) {
3201 return bdi.can_write_zeroes_with_unmap;
3202 }
3203
3204 return false;
3205}
3206
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003207typedef struct BdrvCoGetBlockStatusData {
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003208 BlockDriverState *bs;
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +01003209 BlockDriverState *base;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003210 int64_t sector_num;
3211 int nb_sectors;
3212 int *pnum;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003213 int64_t ret;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003214 bool done;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003215} BdrvCoGetBlockStatusData;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003216
thsf58c7b32008-06-05 21:53:49 +00003217/*
3218 * Returns true iff the specified sector is present in the disk image. Drivers
3219 * not implementing the functionality are assumed to not support backing files,
3220 * hence all their sectors are reported as allocated.
3221 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003222 * If 'sector_num' is beyond the end of the disk image the return value is 0
3223 * and 'pnum' is set to 0.
3224 *
thsf58c7b32008-06-05 21:53:49 +00003225 * 'pnum' is set to the number of sectors (including and immediately following
3226 * the specified sector) that are known to be in the same
3227 * allocated/unallocated state.
3228 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003229 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3230 * beyond the end of the disk image it will be clamped.
thsf58c7b32008-06-05 21:53:49 +00003231 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003232static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3233 int64_t sector_num,
3234 int nb_sectors, int *pnum)
thsf58c7b32008-06-05 21:53:49 +00003235{
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003236 int64_t length;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003237 int64_t n;
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003238 int64_t ret, ret2;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003239
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003240 length = bdrv_getlength(bs);
3241 if (length < 0) {
3242 return length;
3243 }
3244
3245 if (sector_num >= (length >> BDRV_SECTOR_BITS)) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003246 *pnum = 0;
3247 return 0;
3248 }
3249
3250 n = bs->total_sectors - sector_num;
3251 if (n < nb_sectors) {
3252 nb_sectors = n;
3253 }
3254
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003255 if (!bs->drv->bdrv_co_get_block_status) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003256 *pnum = nb_sectors;
Paolo Bonzini918e92d2013-09-04 19:00:37 +02003257 ret = BDRV_BLOCK_DATA;
3258 if (bs->drv->protocol_name) {
3259 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
3260 }
3261 return ret;
thsf58c7b32008-06-05 21:53:49 +00003262 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003263
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003264 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
3265 if (ret < 0) {
Peter Lieven3e0a2332013-09-24 15:35:08 +02003266 *pnum = 0;
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003267 return ret;
3268 }
3269
Peter Lieven92bc50a2013-10-08 14:43:14 +02003270 if (ret & BDRV_BLOCK_RAW) {
3271 assert(ret & BDRV_BLOCK_OFFSET_VALID);
3272 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3273 *pnum, pnum);
3274 }
3275
Peter Lievenc3d86882013-10-24 12:07:04 +02003276 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
3277 if (bdrv_unallocated_blocks_are_zero(bs)) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003278 ret |= BDRV_BLOCK_ZERO;
Peter Lieven1f9db222013-09-24 15:35:09 +02003279 } else if (bs->backing_hd) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003280 BlockDriverState *bs2 = bs->backing_hd;
3281 int64_t length2 = bdrv_getlength(bs2);
3282 if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {
3283 ret |= BDRV_BLOCK_ZERO;
3284 }
3285 }
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003286 }
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003287
3288 if (bs->file &&
3289 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
3290 (ret & BDRV_BLOCK_OFFSET_VALID)) {
3291 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3292 *pnum, pnum);
3293 if (ret2 >= 0) {
3294 /* Ignore errors. This is just providing extra information, it
3295 * is useful but not necessary.
3296 */
3297 ret |= (ret2 & BDRV_BLOCK_ZERO);
3298 }
3299 }
3300
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003301 return ret;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003302}
3303
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003304/* Coroutine wrapper for bdrv_get_block_status() */
3305static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003306{
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003307 BdrvCoGetBlockStatusData *data = opaque;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003308 BlockDriverState *bs = data->bs;
3309
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003310 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
3311 data->pnum);
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003312 data->done = true;
3313}
3314
3315/*
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003316 * Synchronous wrapper around bdrv_co_get_block_status().
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003317 *
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003318 * See bdrv_co_get_block_status() for details.
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003319 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003320int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
3321 int nb_sectors, int *pnum)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003322{
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003323 Coroutine *co;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003324 BdrvCoGetBlockStatusData data = {
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003325 .bs = bs,
3326 .sector_num = sector_num,
3327 .nb_sectors = nb_sectors,
3328 .pnum = pnum,
3329 .done = false,
3330 };
3331
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003332 if (qemu_in_coroutine()) {
3333 /* Fast-path if already in coroutine context */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003334 bdrv_get_block_status_co_entry(&data);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003335 } else {
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003336 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003337 qemu_coroutine_enter(co, &data);
3338 while (!data.done) {
3339 qemu_aio_wait();
3340 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003341 }
3342 return data.ret;
thsf58c7b32008-06-05 21:53:49 +00003343}
3344
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003345int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
3346 int nb_sectors, int *pnum)
3347{
Paolo Bonzini4333bb72013-09-04 19:00:29 +02003348 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
3349 if (ret < 0) {
3350 return ret;
3351 }
3352 return
3353 (ret & BDRV_BLOCK_DATA) ||
3354 ((ret & BDRV_BLOCK_ZERO) && !bdrv_has_zero_init(bs));
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003355}
3356
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003357/*
3358 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
3359 *
3360 * Return true if the given sector is allocated in any image between
3361 * BASE and TOP (inclusive). BASE can be NULL to check if the given
3362 * sector is allocated in any image of the chain. Return false otherwise.
3363 *
3364 * 'pnum' is set to the number of sectors (including and immediately following
3365 * the specified sector) that are known to be in the same
3366 * allocated/unallocated state.
3367 *
3368 */
Paolo Bonzini4f578632013-09-04 19:00:24 +02003369int bdrv_is_allocated_above(BlockDriverState *top,
3370 BlockDriverState *base,
3371 int64_t sector_num,
3372 int nb_sectors, int *pnum)
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003373{
3374 BlockDriverState *intermediate;
3375 int ret, n = nb_sectors;
3376
3377 intermediate = top;
3378 while (intermediate && intermediate != base) {
3379 int pnum_inter;
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003380 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
3381 &pnum_inter);
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003382 if (ret < 0) {
3383 return ret;
3384 } else if (ret) {
3385 *pnum = pnum_inter;
3386 return 1;
3387 }
3388
3389 /*
3390 * [sector_num, nb_sectors] is unallocated on top but intermediate
3391 * might have
3392 *
3393 * [sector_num+x, nr_sectors] allocated.
3394 */
Vishvananda Ishaya63ba17d2013-01-24 10:02:08 -08003395 if (n > pnum_inter &&
3396 (intermediate == top ||
3397 sector_num + pnum_inter < intermediate->total_sectors)) {
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003398 n = pnum_inter;
3399 }
3400
3401 intermediate = intermediate->backing_hd;
3402 }
3403
3404 *pnum = n;
3405 return 0;
3406}
3407
aliguori045df332009-03-05 23:00:48 +00003408const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3409{
3410 if (bs->backing_hd && bs->backing_hd->encrypted)
3411 return bs->backing_file;
3412 else if (bs->encrypted)
3413 return bs->filename;
3414 else
3415 return NULL;
3416}
3417
ths5fafdf22007-09-16 21:08:06 +00003418void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00003419 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00003420{
Kevin Wolf3574c602011-10-26 11:02:11 +02003421 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00003422}
3423
ths5fafdf22007-09-16 21:08:06 +00003424int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellardfaea38e2006-08-05 21:31:00 +00003425 const uint8_t *buf, int nb_sectors)
3426{
3427 BlockDriver *drv = bs->drv;
3428 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003429 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003430 if (!drv->bdrv_write_compressed)
3431 return -ENOTSUP;
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02003432 if (bdrv_check_request(bs, sector_num, nb_sectors))
3433 return -EIO;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003434
Fam Zhenge4654d22013-11-13 18:29:43 +08003435 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003436
bellardfaea38e2006-08-05 21:31:00 +00003437 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
3438}
ths3b46e622007-09-17 08:09:54 +00003439
bellardfaea38e2006-08-05 21:31:00 +00003440int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3441{
3442 BlockDriver *drv = bs->drv;
3443 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003444 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003445 if (!drv->bdrv_get_info)
3446 return -ENOTSUP;
3447 memset(bdi, 0, sizeof(*bdi));
3448 return drv->bdrv_get_info(bs, bdi);
3449}
3450
Max Reitzeae041f2013-10-09 10:46:16 +02003451ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3452{
3453 BlockDriver *drv = bs->drv;
3454 if (drv && drv->bdrv_get_specific_info) {
3455 return drv->bdrv_get_specific_info(bs);
3456 }
3457 return NULL;
3458}
3459
Christoph Hellwig45566e92009-07-10 23:11:57 +02003460int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
3461 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00003462{
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003463 QEMUIOVector qiov;
3464 struct iovec iov = {
3465 .iov_base = (void *) buf,
3466 .iov_len = size,
3467 };
3468
3469 qemu_iovec_init_external(&qiov, &iov, 1);
3470 return bdrv_writev_vmstate(bs, &qiov, pos);
3471}
3472
3473int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
3474{
aliguori178e08a2009-04-05 19:10:55 +00003475 BlockDriver *drv = bs->drv;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003476
3477 if (!drv) {
aliguori178e08a2009-04-05 19:10:55 +00003478 return -ENOMEDIUM;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003479 } else if (drv->bdrv_save_vmstate) {
3480 return drv->bdrv_save_vmstate(bs, qiov, pos);
3481 } else if (bs->file) {
3482 return bdrv_writev_vmstate(bs->file, qiov, pos);
3483 }
3484
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003485 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00003486}
3487
Christoph Hellwig45566e92009-07-10 23:11:57 +02003488int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
3489 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00003490{
3491 BlockDriver *drv = bs->drv;
3492 if (!drv)
3493 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003494 if (drv->bdrv_load_vmstate)
3495 return drv->bdrv_load_vmstate(bs, buf, pos, size);
3496 if (bs->file)
3497 return bdrv_load_vmstate(bs->file, buf, pos, size);
3498 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00003499}
3500
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003501void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3502{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003503 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003504 return;
3505 }
3506
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003507 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01003508}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003509
Kevin Wolf41c695c2012-12-06 14:32:58 +01003510int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3511 const char *tag)
3512{
3513 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3514 bs = bs->file;
3515 }
3516
3517 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3518 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3519 }
3520
3521 return -ENOTSUP;
3522}
3523
Fam Zheng4cc70e92013-11-20 10:01:54 +08003524int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3525{
3526 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3527 bs = bs->file;
3528 }
3529
3530 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3531 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3532 }
3533
3534 return -ENOTSUP;
3535}
3536
Kevin Wolf41c695c2012-12-06 14:32:58 +01003537int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3538{
3539 while (bs && bs->drv && !bs->drv->bdrv_debug_resume) {
3540 bs = bs->file;
3541 }
3542
3543 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3544 return bs->drv->bdrv_debug_resume(bs, tag);
3545 }
3546
3547 return -ENOTSUP;
3548}
3549
3550bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3551{
3552 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3553 bs = bs->file;
3554 }
3555
3556 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3557 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3558 }
3559
3560 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003561}
3562
Blue Swirl199630b2010-07-25 20:49:34 +00003563int bdrv_is_snapshot(BlockDriverState *bs)
3564{
3565 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3566}
3567
Jeff Codyb1b1d782012-10-16 15:49:09 -04003568/* backing_file can either be relative, or absolute, or a protocol. If it is
3569 * relative, it must be relative to the chain. So, passing in bs->filename
3570 * from a BDS as backing_file should not be done, as that may be relative to
3571 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003572BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3573 const char *backing_file)
3574{
Jeff Codyb1b1d782012-10-16 15:49:09 -04003575 char *filename_full = NULL;
3576 char *backing_file_full = NULL;
3577 char *filename_tmp = NULL;
3578 int is_protocol = 0;
3579 BlockDriverState *curr_bs = NULL;
3580 BlockDriverState *retval = NULL;
3581
3582 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003583 return NULL;
3584 }
3585
Jeff Codyb1b1d782012-10-16 15:49:09 -04003586 filename_full = g_malloc(PATH_MAX);
3587 backing_file_full = g_malloc(PATH_MAX);
3588 filename_tmp = g_malloc(PATH_MAX);
3589
3590 is_protocol = path_has_protocol(backing_file);
3591
3592 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3593
3594 /* If either of the filename paths is actually a protocol, then
3595 * compare unmodified paths; otherwise make paths relative */
3596 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3597 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3598 retval = curr_bs->backing_hd;
3599 break;
3600 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003601 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04003602 /* If not an absolute filename path, make it relative to the current
3603 * image's filename path */
3604 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3605 backing_file);
3606
3607 /* We are going to compare absolute pathnames */
3608 if (!realpath(filename_tmp, filename_full)) {
3609 continue;
3610 }
3611
3612 /* We need to make sure the backing filename we are comparing against
3613 * is relative to the current image filename (or absolute) */
3614 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3615 curr_bs->backing_file);
3616
3617 if (!realpath(filename_tmp, backing_file_full)) {
3618 continue;
3619 }
3620
3621 if (strcmp(backing_file_full, filename_full) == 0) {
3622 retval = curr_bs->backing_hd;
3623 break;
3624 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003625 }
3626 }
3627
Jeff Codyb1b1d782012-10-16 15:49:09 -04003628 g_free(filename_full);
3629 g_free(backing_file_full);
3630 g_free(filename_tmp);
3631 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003632}
3633
BenoƮt Canetf198fd12012-08-02 10:22:47 +02003634int bdrv_get_backing_file_depth(BlockDriverState *bs)
3635{
3636 if (!bs->drv) {
3637 return 0;
3638 }
3639
3640 if (!bs->backing_hd) {
3641 return 0;
3642 }
3643
3644 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3645}
3646
Jeff Cody79fac562012-09-27 13:29:15 -04003647BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3648{
3649 BlockDriverState *curr_bs = NULL;
3650
3651 if (!bs) {
3652 return NULL;
3653 }
3654
3655 curr_bs = bs;
3656
3657 while (curr_bs->backing_hd) {
3658 curr_bs = curr_bs->backing_hd;
3659 }
3660 return curr_bs;
3661}
3662
bellard83f64092006-08-01 16:21:11 +00003663/**************************************************************/
3664/* async I/Os */
3665
aliguori3b69e4b2009-01-22 16:59:24 +00003666BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
aliguorif141eaf2009-04-07 18:43:24 +00003667 QEMUIOVector *qiov, int nb_sectors,
aliguori3b69e4b2009-01-22 16:59:24 +00003668 BlockDriverCompletionFunc *cb, void *opaque)
3669{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01003670 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
3671
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003672 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003673 cb, opaque, false);
bellard83f64092006-08-01 16:21:11 +00003674}
3675
aliguorif141eaf2009-04-07 18:43:24 +00003676BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
3677 QEMUIOVector *qiov, int nb_sectors,
3678 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00003679{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01003680 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
3681
Stefan Hajnoczi1a6e1152011-10-13 13:08:25 +01003682 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003683 cb, opaque, true);
bellard83f64092006-08-01 16:21:11 +00003684}
3685
Kevin Wolf40b4f532009-09-09 17:53:37 +02003686
3687typedef struct MultiwriteCB {
3688 int error;
3689 int num_requests;
3690 int num_callbacks;
3691 struct {
3692 BlockDriverCompletionFunc *cb;
3693 void *opaque;
3694 QEMUIOVector *free_qiov;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003695 } callbacks[];
3696} MultiwriteCB;
3697
3698static void multiwrite_user_cb(MultiwriteCB *mcb)
3699{
3700 int i;
3701
3702 for (i = 0; i < mcb->num_callbacks; i++) {
3703 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
Stefan Hajnoczi1e1ea482010-04-21 20:35:45 +01003704 if (mcb->callbacks[i].free_qiov) {
3705 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
3706 }
Anthony Liguori7267c092011-08-20 22:09:37 -05003707 g_free(mcb->callbacks[i].free_qiov);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003708 }
3709}
3710
3711static void multiwrite_cb(void *opaque, int ret)
3712{
3713 MultiwriteCB *mcb = opaque;
3714
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01003715 trace_multiwrite_cb(mcb, ret);
3716
Kevin Wolfcb6d3ca2010-04-01 22:48:44 +02003717 if (ret < 0 && !mcb->error) {
Kevin Wolf40b4f532009-09-09 17:53:37 +02003718 mcb->error = ret;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003719 }
3720
3721 mcb->num_requests--;
3722 if (mcb->num_requests == 0) {
Kevin Wolfde189a12010-07-01 16:08:51 +02003723 multiwrite_user_cb(mcb);
Anthony Liguori7267c092011-08-20 22:09:37 -05003724 g_free(mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003725 }
3726}
3727
3728static int multiwrite_req_compare(const void *a, const void *b)
3729{
Christoph Hellwig77be4362010-05-19 20:53:10 +02003730 const BlockRequest *req1 = a, *req2 = b;
3731
3732 /*
3733 * Note that we can't simply subtract req2->sector from req1->sector
3734 * here as that could overflow the return value.
3735 */
3736 if (req1->sector > req2->sector) {
3737 return 1;
3738 } else if (req1->sector < req2->sector) {
3739 return -1;
3740 } else {
3741 return 0;
3742 }
Kevin Wolf40b4f532009-09-09 17:53:37 +02003743}
3744
3745/*
3746 * Takes a bunch of requests and tries to merge them. Returns the number of
3747 * requests that remain after merging.
3748 */
3749static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
3750 int num_reqs, MultiwriteCB *mcb)
3751{
3752 int i, outidx;
3753
3754 // Sort requests by start sector
3755 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
3756
3757 // Check if adjacent requests touch the same clusters. If so, combine them,
3758 // filling up gaps with zero sectors.
3759 outidx = 0;
3760 for (i = 1; i < num_reqs; i++) {
3761 int merge = 0;
3762 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
3763
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01003764 // Handle exactly sequential writes and overlapping writes.
Kevin Wolf40b4f532009-09-09 17:53:37 +02003765 if (reqs[i].sector <= oldreq_last) {
3766 merge = 1;
3767 }
3768
Christoph Hellwige2a305f2010-01-26 14:49:08 +01003769 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
3770 merge = 0;
3771 }
3772
Kevin Wolf40b4f532009-09-09 17:53:37 +02003773 if (merge) {
3774 size_t size;
Anthony Liguori7267c092011-08-20 22:09:37 -05003775 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
Kevin Wolf40b4f532009-09-09 17:53:37 +02003776 qemu_iovec_init(qiov,
3777 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
3778
3779 // Add the first request to the merged one. If the requests are
3780 // overlapping, drop the last sectors of the first request.
3781 size = (reqs[i].sector - reqs[outidx].sector) << 9;
Michael Tokarev1b093c42012-03-12 21:28:06 +04003782 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003783
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01003784 // We should need to add any zeros between the two requests
3785 assert (reqs[i].sector <= oldreq_last);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003786
3787 // Add the second request
Michael Tokarev1b093c42012-03-12 21:28:06 +04003788 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003789
Kevin Wolfcbf1dff2010-05-21 11:09:42 +02003790 reqs[outidx].nb_sectors = qiov->size >> 9;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003791 reqs[outidx].qiov = qiov;
3792
3793 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
3794 } else {
3795 outidx++;
3796 reqs[outidx].sector = reqs[i].sector;
3797 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
3798 reqs[outidx].qiov = reqs[i].qiov;
3799 }
3800 }
3801
3802 return outidx + 1;
3803}
3804
3805/*
3806 * Submit multiple AIO write requests at once.
3807 *
3808 * On success, the function returns 0 and all requests in the reqs array have
3809 * been submitted. In error case this function returns -1, and any of the
3810 * requests may or may not be submitted yet. In particular, this means that the
3811 * callback will be called for some of the requests, for others it won't. The
3812 * caller must check the error field of the BlockRequest to wait for the right
3813 * callbacks (if error != 0, no callback will be called).
3814 *
3815 * The implementation may modify the contents of the reqs array, e.g. to merge
3816 * requests. However, the fields opaque and error are left unmodified as they
3817 * are used to signal failure for a single request to the caller.
3818 */
3819int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
3820{
Kevin Wolf40b4f532009-09-09 17:53:37 +02003821 MultiwriteCB *mcb;
3822 int i;
3823
Ryan Harper301db7c2011-03-07 10:01:04 -06003824 /* don't submit writes if we don't have a medium */
3825 if (bs->drv == NULL) {
3826 for (i = 0; i < num_reqs; i++) {
3827 reqs[i].error = -ENOMEDIUM;
3828 }
3829 return -1;
3830 }
3831
Kevin Wolf40b4f532009-09-09 17:53:37 +02003832 if (num_reqs == 0) {
3833 return 0;
3834 }
3835
3836 // Create MultiwriteCB structure
Anthony Liguori7267c092011-08-20 22:09:37 -05003837 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
Kevin Wolf40b4f532009-09-09 17:53:37 +02003838 mcb->num_requests = 0;
3839 mcb->num_callbacks = num_reqs;
3840
3841 for (i = 0; i < num_reqs; i++) {
3842 mcb->callbacks[i].cb = reqs[i].cb;
3843 mcb->callbacks[i].opaque = reqs[i].opaque;
3844 }
3845
3846 // Check for mergable requests
3847 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
3848
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01003849 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
3850
Paolo Bonzinidf9309f2011-11-14 17:50:50 +01003851 /* Run the aio requests. */
3852 mcb->num_requests = num_reqs;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003853 for (i = 0; i < num_reqs; i++) {
Paolo Bonziniad54ae82011-11-30 09:12:30 +01003854 bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
Kevin Wolf40b4f532009-09-09 17:53:37 +02003855 reqs[i].nb_sectors, multiwrite_cb, mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003856 }
3857
3858 return 0;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003859}
3860
bellard83f64092006-08-01 16:21:11 +00003861void bdrv_aio_cancel(BlockDriverAIOCB *acb)
pbrookce1a14d2006-08-07 02:38:06 +00003862{
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003863 acb->aiocb_info->cancel(acb);
bellard83f64092006-08-01 16:21:11 +00003864}
3865
3866/**************************************************************/
3867/* async block device emulation */
3868
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003869typedef struct BlockDriverAIOCBSync {
3870 BlockDriverAIOCB common;
3871 QEMUBH *bh;
3872 int ret;
3873 /* vector translation state */
3874 QEMUIOVector *qiov;
3875 uint8_t *bounce;
3876 int is_write;
3877} BlockDriverAIOCBSync;
3878
3879static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
3880{
Kevin Wolfb666d232010-05-05 11:44:39 +02003881 BlockDriverAIOCBSync *acb =
3882 container_of(blockacb, BlockDriverAIOCBSync, common);
Dor Laor6a7ad292009-06-01 12:07:23 +03003883 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03003884 acb->bh = NULL;
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003885 qemu_aio_release(acb);
3886}
3887
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003888static const AIOCBInfo bdrv_em_aiocb_info = {
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003889 .aiocb_size = sizeof(BlockDriverAIOCBSync),
3890 .cancel = bdrv_aio_cancel_em,
3891};
3892
bellard83f64092006-08-01 16:21:11 +00003893static void bdrv_aio_bh_cb(void *opaque)
bellardbeac80c2006-06-26 20:08:57 +00003894{
pbrookce1a14d2006-08-07 02:38:06 +00003895 BlockDriverAIOCBSync *acb = opaque;
aliguorif141eaf2009-04-07 18:43:24 +00003896
aliguorif141eaf2009-04-07 18:43:24 +00003897 if (!acb->is_write)
Michael Tokarev03396142012-06-07 20:17:55 +04003898 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
aliguoriceb42de2009-04-07 18:43:28 +00003899 qemu_vfree(acb->bounce);
pbrookce1a14d2006-08-07 02:38:06 +00003900 acb->common.cb(acb->common.opaque, acb->ret);
Dor Laor6a7ad292009-06-01 12:07:23 +03003901 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03003902 acb->bh = NULL;
pbrookce1a14d2006-08-07 02:38:06 +00003903 qemu_aio_release(acb);
bellardbeac80c2006-06-26 20:08:57 +00003904}
bellardbeac80c2006-06-26 20:08:57 +00003905
aliguorif141eaf2009-04-07 18:43:24 +00003906static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
3907 int64_t sector_num,
3908 QEMUIOVector *qiov,
3909 int nb_sectors,
3910 BlockDriverCompletionFunc *cb,
3911 void *opaque,
3912 int is_write)
3913
bellardea2384d2004-08-01 21:59:26 +00003914{
pbrookce1a14d2006-08-07 02:38:06 +00003915 BlockDriverAIOCBSync *acb;
pbrookce1a14d2006-08-07 02:38:06 +00003916
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003917 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
aliguorif141eaf2009-04-07 18:43:24 +00003918 acb->is_write = is_write;
3919 acb->qiov = qiov;
aliguorie268ca52009-04-22 20:20:00 +00003920 acb->bounce = qemu_blockalign(bs, qiov->size);
Paolo Bonzini3f3aace2011-11-14 17:50:54 +01003921 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
aliguorif141eaf2009-04-07 18:43:24 +00003922
3923 if (is_write) {
Michael Tokarevd5e6b162012-06-07 20:21:06 +04003924 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01003925 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00003926 } else {
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01003927 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00003928 }
3929
pbrookce1a14d2006-08-07 02:38:06 +00003930 qemu_bh_schedule(acb->bh);
aliguorif141eaf2009-04-07 18:43:24 +00003931
pbrookce1a14d2006-08-07 02:38:06 +00003932 return &acb->common;
pbrook7a6cba62006-06-04 11:39:07 +00003933}
3934
aliguorif141eaf2009-04-07 18:43:24 +00003935static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3936 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +00003937 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00003938{
aliguorif141eaf2009-04-07 18:43:24 +00003939 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
bellard83f64092006-08-01 16:21:11 +00003940}
3941
aliguorif141eaf2009-04-07 18:43:24 +00003942static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3943 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3944 BlockDriverCompletionFunc *cb, void *opaque)
3945{
3946 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
3947}
3948
Kevin Wolf68485422011-06-30 10:05:46 +02003949
3950typedef struct BlockDriverAIOCBCoroutine {
3951 BlockDriverAIOCB common;
3952 BlockRequest req;
3953 bool is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01003954 bool *done;
Kevin Wolf68485422011-06-30 10:05:46 +02003955 QEMUBH* bh;
3956} BlockDriverAIOCBCoroutine;
3957
3958static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
3959{
Kevin Wolfd318aea2012-11-13 16:35:08 +01003960 BlockDriverAIOCBCoroutine *acb =
3961 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
3962 bool done = false;
3963
3964 acb->done = &done;
3965 while (!done) {
3966 qemu_aio_wait();
3967 }
Kevin Wolf68485422011-06-30 10:05:46 +02003968}
3969
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003970static const AIOCBInfo bdrv_em_co_aiocb_info = {
Kevin Wolf68485422011-06-30 10:05:46 +02003971 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
3972 .cancel = bdrv_aio_co_cancel_em,
3973};
3974
Paolo Bonzini35246a62011-10-14 10:41:29 +02003975static void bdrv_co_em_bh(void *opaque)
Kevin Wolf68485422011-06-30 10:05:46 +02003976{
3977 BlockDriverAIOCBCoroutine *acb = opaque;
3978
3979 acb->common.cb(acb->common.opaque, acb->req.error);
Kevin Wolfd318aea2012-11-13 16:35:08 +01003980
3981 if (acb->done) {
3982 *acb->done = true;
3983 }
3984
Kevin Wolf68485422011-06-30 10:05:46 +02003985 qemu_bh_delete(acb->bh);
3986 qemu_aio_release(acb);
3987}
3988
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003989/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3990static void coroutine_fn bdrv_co_do_rw(void *opaque)
3991{
3992 BlockDriverAIOCBCoroutine *acb = opaque;
3993 BlockDriverState *bs = acb->common.bs;
3994
3995 if (!acb->is_write) {
3996 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003997 acb->req.nb_sectors, acb->req.qiov, 0);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003998 } else {
3999 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00004000 acb->req.nb_sectors, acb->req.qiov, 0);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004001 }
4002
Paolo Bonzini35246a62011-10-14 10:41:29 +02004003 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004004 qemu_bh_schedule(acb->bh);
4005}
4006
Kevin Wolf68485422011-06-30 10:05:46 +02004007static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4008 int64_t sector_num,
4009 QEMUIOVector *qiov,
4010 int nb_sectors,
4011 BlockDriverCompletionFunc *cb,
4012 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004013 bool is_write)
Kevin Wolf68485422011-06-30 10:05:46 +02004014{
4015 Coroutine *co;
4016 BlockDriverAIOCBCoroutine *acb;
4017
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004018 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolf68485422011-06-30 10:05:46 +02004019 acb->req.sector = sector_num;
4020 acb->req.nb_sectors = nb_sectors;
4021 acb->req.qiov = qiov;
4022 acb->is_write = is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004023 acb->done = NULL;
Kevin Wolf68485422011-06-30 10:05:46 +02004024
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004025 co = qemu_coroutine_create(bdrv_co_do_rw);
Kevin Wolf68485422011-06-30 10:05:46 +02004026 qemu_coroutine_enter(co, acb);
4027
4028 return &acb->common;
4029}
4030
Paolo Bonzini07f07612011-10-17 12:32:12 +02004031static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004032{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004033 BlockDriverAIOCBCoroutine *acb = opaque;
4034 BlockDriverState *bs = acb->common.bs;
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004035
Paolo Bonzini07f07612011-10-17 12:32:12 +02004036 acb->req.error = bdrv_co_flush(bs);
4037 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004038 qemu_bh_schedule(acb->bh);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004039}
4040
Paolo Bonzini07f07612011-10-17 12:32:12 +02004041BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Alexander Graf016f5cf2010-05-26 17:51:49 +02004042 BlockDriverCompletionFunc *cb, void *opaque)
4043{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004044 trace_bdrv_aio_flush(bs, opaque);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004045
Paolo Bonzini07f07612011-10-17 12:32:12 +02004046 Coroutine *co;
4047 BlockDriverAIOCBCoroutine *acb;
Alexander Graf016f5cf2010-05-26 17:51:49 +02004048
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004049 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004050 acb->done = NULL;
4051
Paolo Bonzini07f07612011-10-17 12:32:12 +02004052 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4053 qemu_coroutine_enter(co, acb);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004054
Alexander Graf016f5cf2010-05-26 17:51:49 +02004055 return &acb->common;
4056}
4057
Paolo Bonzini4265d622011-10-17 12:32:14 +02004058static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4059{
4060 BlockDriverAIOCBCoroutine *acb = opaque;
4061 BlockDriverState *bs = acb->common.bs;
4062
4063 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4064 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
4065 qemu_bh_schedule(acb->bh);
4066}
4067
4068BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4069 int64_t sector_num, int nb_sectors,
4070 BlockDriverCompletionFunc *cb, void *opaque)
4071{
4072 Coroutine *co;
4073 BlockDriverAIOCBCoroutine *acb;
4074
4075 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4076
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004077 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +02004078 acb->req.sector = sector_num;
4079 acb->req.nb_sectors = nb_sectors;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004080 acb->done = NULL;
Paolo Bonzini4265d622011-10-17 12:32:14 +02004081 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4082 qemu_coroutine_enter(co, acb);
4083
4084 return &acb->common;
4085}
4086
bellardea2384d2004-08-01 21:59:26 +00004087void bdrv_init(void)
4088{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05004089 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00004090}
pbrookce1a14d2006-08-07 02:38:06 +00004091
Markus Armbrustereb852012009-10-27 18:41:44 +01004092void bdrv_init_with_whitelist(void)
4093{
4094 use_bdrv_whitelist = 1;
4095 bdrv_init();
4096}
4097
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004098void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004099 BlockDriverCompletionFunc *cb, void *opaque)
aliguori6bbff9a2009-03-20 18:25:59 +00004100{
pbrookce1a14d2006-08-07 02:38:06 +00004101 BlockDriverAIOCB *acb;
4102
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004103 acb = g_slice_alloc(aiocb_info->aiocb_size);
4104 acb->aiocb_info = aiocb_info;
pbrookce1a14d2006-08-07 02:38:06 +00004105 acb->bs = bs;
4106 acb->cb = cb;
4107 acb->opaque = opaque;
4108 return acb;
4109}
4110
4111void qemu_aio_release(void *p)
4112{
Stefan Hajnoczid37c9752012-10-31 16:34:36 +01004113 BlockDriverAIOCB *acb = p;
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004114 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
pbrookce1a14d2006-08-07 02:38:06 +00004115}
bellard19cb3732006-08-19 11:45:59 +00004116
4117/**************************************************************/
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004118/* Coroutine block device emulation */
4119
4120typedef struct CoroutineIOCompletion {
4121 Coroutine *coroutine;
4122 int ret;
4123} CoroutineIOCompletion;
4124
4125static void bdrv_co_io_em_complete(void *opaque, int ret)
4126{
4127 CoroutineIOCompletion *co = opaque;
4128
4129 co->ret = ret;
4130 qemu_coroutine_enter(co->coroutine, NULL);
4131}
4132
4133static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4134 int nb_sectors, QEMUIOVector *iov,
4135 bool is_write)
4136{
4137 CoroutineIOCompletion co = {
4138 .coroutine = qemu_coroutine_self(),
4139 };
4140 BlockDriverAIOCB *acb;
4141
4142 if (is_write) {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004143 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4144 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004145 } else {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004146 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4147 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004148 }
4149
Stefan Hajnoczi59370aa2011-09-30 17:34:58 +01004150 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004151 if (!acb) {
4152 return -EIO;
4153 }
4154 qemu_coroutine_yield();
4155
4156 return co.ret;
4157}
4158
4159static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4160 int64_t sector_num, int nb_sectors,
4161 QEMUIOVector *iov)
4162{
4163 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4164}
4165
4166static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4167 int64_t sector_num, int nb_sectors,
4168 QEMUIOVector *iov)
4169{
4170 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4171}
4172
Paolo Bonzini07f07612011-10-17 12:32:12 +02004173static void coroutine_fn bdrv_flush_co_entry(void *opaque)
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004174{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004175 RwCo *rwco = opaque;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004176
Paolo Bonzini07f07612011-10-17 12:32:12 +02004177 rwco->ret = bdrv_co_flush(rwco->bs);
4178}
4179
4180int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4181{
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004182 int ret;
4183
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004184 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Paolo Bonzini07f07612011-10-17 12:32:12 +02004185 return 0;
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004186 }
4187
Kevin Wolfca716362011-11-10 18:13:59 +01004188 /* Write back cached data to the OS even with cache=unsafe */
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004189 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004190 if (bs->drv->bdrv_co_flush_to_os) {
4191 ret = bs->drv->bdrv_co_flush_to_os(bs);
4192 if (ret < 0) {
4193 return ret;
4194 }
4195 }
4196
Kevin Wolfca716362011-11-10 18:13:59 +01004197 /* But don't actually force it to the disk with cache=unsafe */
4198 if (bs->open_flags & BDRV_O_NO_FLUSH) {
Kevin Wolfd4c82322012-08-15 12:52:45 +02004199 goto flush_parent;
Kevin Wolfca716362011-11-10 18:13:59 +01004200 }
4201
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004202 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004203 if (bs->drv->bdrv_co_flush_to_disk) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004204 ret = bs->drv->bdrv_co_flush_to_disk(bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004205 } else if (bs->drv->bdrv_aio_flush) {
4206 BlockDriverAIOCB *acb;
4207 CoroutineIOCompletion co = {
4208 .coroutine = qemu_coroutine_self(),
4209 };
4210
4211 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4212 if (acb == NULL) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004213 ret = -EIO;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004214 } else {
4215 qemu_coroutine_yield();
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004216 ret = co.ret;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004217 }
Paolo Bonzini07f07612011-10-17 12:32:12 +02004218 } else {
4219 /*
4220 * Some block drivers always operate in either writethrough or unsafe
4221 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4222 * know how the server works (because the behaviour is hardcoded or
4223 * depends on server-side configuration), so we can't ensure that
4224 * everything is safe on disk. Returning an error doesn't work because
4225 * that would break guests even if the server operates in writethrough
4226 * mode.
4227 *
4228 * Let's hope the user knows what he's doing.
4229 */
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004230 ret = 0;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004231 }
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004232 if (ret < 0) {
4233 return ret;
4234 }
4235
4236 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4237 * in the case of cache=unsafe, so there are no useless flushes.
4238 */
Kevin Wolfd4c82322012-08-15 12:52:45 +02004239flush_parent:
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004240 return bdrv_co_flush(bs->file);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004241}
4242
Anthony Liguori0f154232011-11-14 15:09:45 -06004243void bdrv_invalidate_cache(BlockDriverState *bs)
4244{
4245 if (bs->drv && bs->drv->bdrv_invalidate_cache) {
4246 bs->drv->bdrv_invalidate_cache(bs);
4247 }
4248}
4249
4250void bdrv_invalidate_cache_all(void)
4251{
4252 BlockDriverState *bs;
4253
4254 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4255 bdrv_invalidate_cache(bs);
4256 }
4257}
4258
BenoƮt Canet07789262012-03-23 08:36:49 +01004259void bdrv_clear_incoming_migration_all(void)
4260{
4261 BlockDriverState *bs;
4262
4263 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4264 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
4265 }
4266}
4267
Paolo Bonzini07f07612011-10-17 12:32:12 +02004268int bdrv_flush(BlockDriverState *bs)
4269{
4270 Coroutine *co;
4271 RwCo rwco = {
4272 .bs = bs,
4273 .ret = NOT_DONE,
4274 };
4275
4276 if (qemu_in_coroutine()) {
4277 /* Fast-path if already in coroutine context */
4278 bdrv_flush_co_entry(&rwco);
4279 } else {
4280 co = qemu_coroutine_create(bdrv_flush_co_entry);
4281 qemu_coroutine_enter(co, &rwco);
4282 while (rwco.ret == NOT_DONE) {
4283 qemu_aio_wait();
4284 }
4285 }
4286
4287 return rwco.ret;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004288}
4289
Paolo Bonzini4265d622011-10-17 12:32:14 +02004290static void coroutine_fn bdrv_discard_co_entry(void *opaque)
4291{
4292 RwCo *rwco = opaque;
4293
4294 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
4295}
4296
Peter Lieven6f14da52013-10-24 12:06:59 +02004297/* if no limit is specified in the BlockLimits use a default
4298 * of 32768 512-byte sectors (16 MiB) per request.
4299 */
4300#define MAX_DISCARD_DEFAULT 32768
4301
Paolo Bonzini4265d622011-10-17 12:32:14 +02004302int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
4303 int nb_sectors)
4304{
4305 if (!bs->drv) {
4306 return -ENOMEDIUM;
4307 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
4308 return -EIO;
4309 } else if (bs->read_only) {
4310 return -EROFS;
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004311 }
4312
Fam Zhenge4654d22013-11-13 18:29:43 +08004313 bdrv_reset_dirty(bs, sector_num, nb_sectors);
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004314
Paolo Bonzini9e8f1832013-02-08 14:06:11 +01004315 /* Do nothing if disabled. */
4316 if (!(bs->open_flags & BDRV_O_UNMAP)) {
4317 return 0;
4318 }
4319
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004320 if (bs->drv->bdrv_co_discard) {
Peter Lieven6f14da52013-10-24 12:06:59 +02004321 int max_discard = bs->bl.max_discard ?
4322 bs->bl.max_discard : MAX_DISCARD_DEFAULT;
4323
4324 while (nb_sectors > 0) {
4325 int ret;
4326 int num = nb_sectors;
4327
4328 /* align request */
4329 if (bs->bl.discard_alignment &&
4330 num >= bs->bl.discard_alignment &&
4331 sector_num % bs->bl.discard_alignment) {
4332 if (num > bs->bl.discard_alignment) {
4333 num = bs->bl.discard_alignment;
4334 }
4335 num -= sector_num % bs->bl.discard_alignment;
4336 }
4337
4338 /* limit request size */
4339 if (num > max_discard) {
4340 num = max_discard;
4341 }
4342
4343 ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
4344 if (ret) {
4345 return ret;
4346 }
4347
4348 sector_num += num;
4349 nb_sectors -= num;
4350 }
4351 return 0;
Paolo Bonzini4265d622011-10-17 12:32:14 +02004352 } else if (bs->drv->bdrv_aio_discard) {
4353 BlockDriverAIOCB *acb;
4354 CoroutineIOCompletion co = {
4355 .coroutine = qemu_coroutine_self(),
4356 };
4357
4358 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
4359 bdrv_co_io_em_complete, &co);
4360 if (acb == NULL) {
4361 return -EIO;
4362 } else {
4363 qemu_coroutine_yield();
4364 return co.ret;
4365 }
Paolo Bonzini4265d622011-10-17 12:32:14 +02004366 } else {
4367 return 0;
4368 }
4369}
4370
4371int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
4372{
4373 Coroutine *co;
4374 RwCo rwco = {
4375 .bs = bs,
4376 .sector_num = sector_num,
4377 .nb_sectors = nb_sectors,
4378 .ret = NOT_DONE,
4379 };
4380
4381 if (qemu_in_coroutine()) {
4382 /* Fast-path if already in coroutine context */
4383 bdrv_discard_co_entry(&rwco);
4384 } else {
4385 co = qemu_coroutine_create(bdrv_discard_co_entry);
4386 qemu_coroutine_enter(co, &rwco);
4387 while (rwco.ret == NOT_DONE) {
4388 qemu_aio_wait();
4389 }
4390 }
4391
4392 return rwco.ret;
4393}
4394
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004395/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00004396/* removable device support */
4397
4398/**
4399 * Return TRUE if the media is present
4400 */
4401int bdrv_is_inserted(BlockDriverState *bs)
4402{
4403 BlockDriver *drv = bs->drv;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02004404
bellard19cb3732006-08-19 11:45:59 +00004405 if (!drv)
4406 return 0;
4407 if (!drv->bdrv_is_inserted)
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02004408 return 1;
4409 return drv->bdrv_is_inserted(bs);
bellard19cb3732006-08-19 11:45:59 +00004410}
4411
4412/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02004413 * Return whether the media changed since the last call to this
4414 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00004415 */
4416int bdrv_media_changed(BlockDriverState *bs)
4417{
4418 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00004419
Markus Armbruster8e49ca42011-08-03 15:08:08 +02004420 if (drv && drv->bdrv_media_changed) {
4421 return drv->bdrv_media_changed(bs);
4422 }
4423 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00004424}
4425
4426/**
4427 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4428 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02004429void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00004430{
4431 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00004432
Markus Armbruster822e1cd2011-07-20 18:23:42 +02004433 if (drv && drv->bdrv_eject) {
4434 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00004435 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02004436
4437 if (bs->device_name[0] != '\0') {
4438 bdrv_emit_qmp_eject_event(bs, eject_flag);
4439 }
bellard19cb3732006-08-19 11:45:59 +00004440}
4441
bellard19cb3732006-08-19 11:45:59 +00004442/**
4443 * Lock or unlock the media (if it is locked, the user won't be able
4444 * to eject it manually).
4445 */
Markus Armbruster025e8492011-09-06 18:58:47 +02004446void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00004447{
4448 BlockDriver *drv = bs->drv;
4449
Markus Armbruster025e8492011-09-06 18:58:47 +02004450 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01004451
Markus Armbruster025e8492011-09-06 18:58:47 +02004452 if (drv && drv->bdrv_lock_medium) {
4453 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00004454 }
4455}
ths985a03b2007-12-24 16:10:43 +00004456
4457/* needed for generic scsi interface */
4458
4459int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
4460{
4461 BlockDriver *drv = bs->drv;
4462
4463 if (drv && drv->bdrv_ioctl)
4464 return drv->bdrv_ioctl(bs, req, buf);
4465 return -ENOTSUP;
4466}
aliguori7d780662009-03-12 19:57:08 +00004467
aliguori221f7152009-03-28 17:28:41 +00004468BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
4469 unsigned long int req, void *buf,
4470 BlockDriverCompletionFunc *cb, void *opaque)
aliguori7d780662009-03-12 19:57:08 +00004471{
aliguori221f7152009-03-28 17:28:41 +00004472 BlockDriver *drv = bs->drv;
aliguori7d780662009-03-12 19:57:08 +00004473
aliguori221f7152009-03-28 17:28:41 +00004474 if (drv && drv->bdrv_aio_ioctl)
4475 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
4476 return NULL;
aliguori7d780662009-03-12 19:57:08 +00004477}
aliguorie268ca52009-04-22 20:20:00 +00004478
Markus Armbruster7b6f9302011-09-06 18:58:56 +02004479void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
4480{
4481 bs->buffer_alignment = align;
4482}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004483
aliguorie268ca52009-04-22 20:20:00 +00004484void *qemu_blockalign(BlockDriverState *bs, size_t size)
4485{
4486 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
4487}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004488
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01004489/*
4490 * Check if all memory in this vector is sector aligned.
4491 */
4492bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
4493{
4494 int i;
4495
4496 for (i = 0; i < qiov->niov; i++) {
4497 if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {
4498 return false;
4499 }
4500 }
4501
4502 return true;
4503}
4504
Fam Zhenge4654d22013-11-13 18:29:43 +08004505BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004506{
4507 int64_t bitmap_size;
Fam Zhenge4654d22013-11-13 18:29:43 +08004508 BdrvDirtyBitmap *bitmap;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004509
Paolo Bonzini50717e92013-01-21 17:09:45 +01004510 assert((granularity & (granularity - 1)) == 0);
4511
Fam Zhenge4654d22013-11-13 18:29:43 +08004512 granularity >>= BDRV_SECTOR_BITS;
4513 assert(granularity);
4514 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS);
4515 bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
4516 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
4517 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
4518 return bitmap;
4519}
4520
4521void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
4522{
4523 BdrvDirtyBitmap *bm, *next;
4524 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
4525 if (bm == bitmap) {
4526 QLIST_REMOVE(bitmap, list);
4527 hbitmap_free(bitmap->bitmap);
4528 g_free(bitmap);
4529 return;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004530 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004531 }
4532}
4533
Fam Zheng21b56832013-11-13 18:29:44 +08004534BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
4535{
4536 BdrvDirtyBitmap *bm;
4537 BlockDirtyInfoList *list = NULL;
4538 BlockDirtyInfoList **plist = &list;
4539
4540 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
4541 BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
4542 BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
4543 info->count = bdrv_get_dirty_count(bs, bm);
4544 info->granularity =
4545 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
4546 entry->value = info;
4547 *plist = entry;
4548 plist = &entry->next;
4549 }
4550
4551 return list;
4552}
4553
Fam Zhenge4654d22013-11-13 18:29:43 +08004554int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004555{
Fam Zhenge4654d22013-11-13 18:29:43 +08004556 if (bitmap) {
4557 return hbitmap_get(bitmap->bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004558 } else {
4559 return 0;
4560 }
4561}
4562
Fam Zhenge4654d22013-11-13 18:29:43 +08004563void bdrv_dirty_iter_init(BlockDriverState *bs,
4564 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02004565{
Fam Zhenge4654d22013-11-13 18:29:43 +08004566 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02004567}
4568
4569void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
4570 int nr_sectors)
4571{
Fam Zhenge4654d22013-11-13 18:29:43 +08004572 BdrvDirtyBitmap *bitmap;
4573 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
4574 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004575 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02004576}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004577
Fam Zhenge4654d22013-11-13 18:29:43 +08004578void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
4579{
4580 BdrvDirtyBitmap *bitmap;
4581 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
4582 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
4583 }
4584}
4585
4586int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
4587{
4588 return hbitmap_count(bitmap->bitmap);
4589}
4590
Fam Zheng9fcb0252013-08-23 09:14:46 +08004591/* Get a reference to bs */
4592void bdrv_ref(BlockDriverState *bs)
4593{
4594 bs->refcnt++;
4595}
4596
4597/* Release a previously grabbed reference to bs.
4598 * If after releasing, reference count is zero, the BlockDriverState is
4599 * deleted. */
4600void bdrv_unref(BlockDriverState *bs)
4601{
4602 assert(bs->refcnt > 0);
4603 if (--bs->refcnt == 0) {
4604 bdrv_delete(bs);
4605 }
4606}
4607
Marcelo Tosattidb593f22011-01-26 12:12:34 -02004608void bdrv_set_in_use(BlockDriverState *bs, int in_use)
4609{
4610 assert(bs->in_use != in_use);
4611 bs->in_use = in_use;
4612}
4613
4614int bdrv_in_use(BlockDriverState *bs)
4615{
4616 return bs->in_use;
4617}
4618
Luiz Capitulino28a72822011-09-26 17:43:50 -03004619void bdrv_iostatus_enable(BlockDriverState *bs)
4620{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004621 bs->iostatus_enabled = true;
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004622 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004623}
4624
4625/* The I/O status is only enabled if the drive explicitly
4626 * enables it _and_ the VM is configured to stop on errors */
4627bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
4628{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004629 return (bs->iostatus_enabled &&
Paolo Bonzini92aa5c62012-09-28 17:22:55 +02004630 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
4631 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
4632 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
Luiz Capitulino28a72822011-09-26 17:43:50 -03004633}
4634
4635void bdrv_iostatus_disable(BlockDriverState *bs)
4636{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004637 bs->iostatus_enabled = false;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004638}
4639
4640void bdrv_iostatus_reset(BlockDriverState *bs)
4641{
4642 if (bdrv_iostatus_is_enabled(bs)) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004643 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Paolo Bonzini3bd293c2012-10-18 16:49:27 +02004644 if (bs->job) {
4645 block_job_iostatus_reset(bs->job);
4646 }
Luiz Capitulino28a72822011-09-26 17:43:50 -03004647 }
4648}
4649
Luiz Capitulino28a72822011-09-26 17:43:50 -03004650void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
4651{
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02004652 assert(bdrv_iostatus_is_enabled(bs));
4653 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004654 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
4655 BLOCK_DEVICE_IO_STATUS_FAILED;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004656 }
4657}
4658
Christoph Hellwiga597e792011-08-25 08:26:01 +02004659void
4660bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
4661 enum BlockAcctType type)
4662{
4663 assert(type < BDRV_MAX_IOTYPE);
4664
4665 cookie->bytes = bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02004666 cookie->start_time_ns = get_clock();
Christoph Hellwiga597e792011-08-25 08:26:01 +02004667 cookie->type = type;
4668}
4669
4670void
4671bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
4672{
4673 assert(cookie->type < BDRV_MAX_IOTYPE);
4674
4675 bs->nr_bytes[cookie->type] += cookie->bytes;
4676 bs->nr_ops[cookie->type]++;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02004677 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +02004678}
4679
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004680void bdrv_img_create(const char *filename, const char *fmt,
4681 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01004682 char *options, uint64_t img_size, int flags,
4683 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004684{
4685 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolfd2208942011-06-01 14:03:31 +02004686 QEMUOptionParameter *backing_fmt, *backing_file, *size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004687 BlockDriverState *bs = NULL;
4688 BlockDriver *drv, *proto_drv;
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00004689 BlockDriver *backing_drv = NULL;
Max Reitzcc84d902013-09-06 17:14:26 +02004690 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004691 int ret = 0;
4692
4693 /* Find driver and parse its options */
4694 drv = bdrv_find_format(fmt);
4695 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004696 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004697 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004698 }
4699
Kevin Wolf98289622013-07-10 15:47:39 +02004700 proto_drv = bdrv_find_protocol(filename, true);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004701 if (!proto_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004702 error_setg(errp, "Unknown protocol '%s'", filename);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004703 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004704 }
4705
4706 create_options = append_option_parameters(create_options,
4707 drv->create_options);
4708 create_options = append_option_parameters(create_options,
4709 proto_drv->create_options);
4710
4711 /* Create parameter list with default values */
4712 param = parse_option_parameters("", create_options, param);
4713
4714 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
4715
4716 /* Parse -o options */
4717 if (options) {
4718 param = parse_option_parameters(options, create_options, param);
4719 if (param == NULL) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004720 error_setg(errp, "Invalid options for file format '%s'.", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004721 goto out;
4722 }
4723 }
4724
4725 if (base_filename) {
4726 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
4727 base_filename)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004728 error_setg(errp, "Backing file not supported for file format '%s'",
4729 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004730 goto out;
4731 }
4732 }
4733
4734 if (base_fmt) {
4735 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004736 error_setg(errp, "Backing file format not supported for file "
4737 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004738 goto out;
4739 }
4740 }
4741
Jes Sorensen792da932010-12-16 13:52:17 +01004742 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
4743 if (backing_file && backing_file->value.s) {
4744 if (!strcmp(filename, backing_file->value.s)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004745 error_setg(errp, "Error: Trying to create an image with the "
4746 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01004747 goto out;
4748 }
4749 }
4750
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004751 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
4752 if (backing_fmt && backing_fmt->value.s) {
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00004753 backing_drv = bdrv_find_format(backing_fmt->value.s);
4754 if (!backing_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004755 error_setg(errp, "Unknown backing file format '%s'",
4756 backing_fmt->value.s);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004757 goto out;
4758 }
4759 }
4760
4761 // The size for the image must always be specified, with one exception:
4762 // If we are using a backing file, we can obtain the size from there
Kevin Wolfd2208942011-06-01 14:03:31 +02004763 size = get_option_parameter(param, BLOCK_OPT_SIZE);
4764 if (size && size->value.n == -1) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004765 if (backing_file && backing_file->value.s) {
4766 uint64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004767 char buf[32];
Paolo Bonzini63090da2012-04-12 14:01:03 +02004768 int back_flags;
4769
4770 /* backing files always opened read-only */
4771 back_flags =
4772 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004773
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004774 bs = bdrv_new("");
4775
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01004776 ret = bdrv_open(bs, backing_file->value.s, NULL, back_flags,
Max Reitzcc84d902013-09-06 17:14:26 +02004777 backing_drv, &local_err);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004778 if (ret < 0) {
Max Reitzcc84d902013-09-06 17:14:26 +02004779 error_setg_errno(errp, -ret, "Could not open '%s': %s",
4780 backing_file->value.s,
4781 error_get_pretty(local_err));
4782 error_free(local_err);
4783 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004784 goto out;
4785 }
4786 bdrv_get_geometry(bs, &size);
4787 size *= 512;
4788
4789 snprintf(buf, sizeof(buf), "%" PRId64, size);
4790 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
4791 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004792 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004793 goto out;
4794 }
4795 }
4796
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01004797 if (!quiet) {
4798 printf("Formatting '%s', fmt=%s ", filename, fmt);
4799 print_option_parameters(param);
4800 puts("");
4801 }
Max Reitzcc84d902013-09-06 17:14:26 +02004802 ret = bdrv_create(drv, filename, param, &local_err);
4803 if (ret == -EFBIG) {
4804 /* This is generally a better message than whatever the driver would
4805 * deliver (especially because of the cluster_size_hint), since that
4806 * is most probably not much different from "image too large". */
4807 const char *cluster_size_hint = "";
4808 if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
4809 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004810 }
Max Reitzcc84d902013-09-06 17:14:26 +02004811 error_setg(errp, "The image size is too large for file format '%s'"
4812 "%s", fmt, cluster_size_hint);
4813 error_free(local_err);
4814 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004815 }
4816
4817out:
4818 free_option_parameters(create_options);
4819 free_option_parameters(param);
4820
4821 if (bs) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08004822 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004823 }
Max Reitzcc84d902013-09-06 17:14:26 +02004824 if (error_is_set(&local_err)) {
4825 error_propagate(errp, local_err);
4826 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004827}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01004828
4829AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4830{
4831 /* Currently BlockDriverState always uses the main loop AioContext */
4832 return qemu_get_aio_context();
4833}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02004834
4835void bdrv_add_before_write_notifier(BlockDriverState *bs,
4836 NotifierWithReturn *notifier)
4837{
4838 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
4839}
Max Reitz6f176b42013-09-03 10:09:50 +02004840
4841int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options)
4842{
4843 if (bs->drv->bdrv_amend_options == NULL) {
4844 return -ENOTSUP;
4845 }
4846 return bs->drv->bdrv_amend_options(bs, options);
4847}
BenoƮt Canetf6186f42013-10-02 14:33:48 +02004848
4849ExtSnapshotPerm bdrv_check_ext_snapshot(BlockDriverState *bs)
4850{
4851 if (bs->drv->bdrv_check_ext_snapshot) {
4852 return bs->drv->bdrv_check_ext_snapshot(bs);
4853 }
4854
4855 if (bs->file && bs->file->drv && bs->file->drv->bdrv_check_ext_snapshot) {
4856 return bs->file->drv->bdrv_check_ext_snapshot(bs);
4857 }
4858
4859 /* external snapshots are allowed by default */
4860 return EXT_SNAPSHOT_ALLOWED;
4861}
4862
4863ExtSnapshotPerm bdrv_check_ext_snapshot_forbidden(BlockDriverState *bs)
4864{
4865 return EXT_SNAPSHOT_FORBIDDEN;
4866}