blob: 382ea71f4b8c28550d4a798377fd1e6c4bae04ae [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
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010052#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
53
Stefan Hajnoczi470c0502012-01-18 14:40:42 +000054typedef enum {
55 BDRV_REQ_COPY_ON_READ = 0x1,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +000056 BDRV_REQ_ZERO_WRITE = 0x2,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +000057} BdrvRequestFlags;
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,
87 int64_t sector_num, int nb_sectors);
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));
bellardb3380822004-03-14 21:38:54 +0000326 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
bellardea2384d2004-08-01 21:59:26 +0000327 if (device_name[0] != '\0') {
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +0100328 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
bellardea2384d2004-08-01 21:59:26 +0000329 }
Luiz Capitulino28a72822011-09-26 17:43:50 -0300330 bdrv_iostatus_disable(bs);
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200331 notifier_list_init(&bs->close_notifiers);
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200332 notifier_with_return_list_init(&bs->before_write_notifiers);
BenoƮt Canetcc0681c2013-09-02 14:14:39 +0200333 qemu_co_queue_init(&bs->throttled_reqs[0]);
334 qemu_co_queue_init(&bs->throttled_reqs[1]);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800335 bs->refcnt = 1;
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200336
bellardb3380822004-03-14 21:38:54 +0000337 return bs;
338}
339
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200340void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
341{
342 notifier_list_add(&bs->close_notifiers, notify);
343}
344
bellardea2384d2004-08-01 21:59:26 +0000345BlockDriver *bdrv_find_format(const char *format_name)
346{
347 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100348 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
349 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000350 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100351 }
bellardea2384d2004-08-01 21:59:26 +0000352 }
353 return NULL;
354}
355
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800356static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100357{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800358 static const char *whitelist_rw[] = {
359 CONFIG_BDRV_RW_WHITELIST
360 };
361 static const char *whitelist_ro[] = {
362 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100363 };
364 const char **p;
365
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800366 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100367 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800368 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100369
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800370 for (p = whitelist_rw; *p; p++) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100371 if (!strcmp(drv->format_name, *p)) {
372 return 1;
373 }
374 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800375 if (read_only) {
376 for (p = whitelist_ro; *p; p++) {
377 if (!strcmp(drv->format_name, *p)) {
378 return 1;
379 }
380 }
381 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100382 return 0;
383}
384
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800385BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
386 bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100387{
388 BlockDriver *drv = bdrv_find_format(format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800389 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
Markus Armbrustereb852012009-10-27 18:41:44 +0100390}
391
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800392typedef struct CreateCo {
393 BlockDriver *drv;
394 char *filename;
395 QEMUOptionParameter *options;
396 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200397 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800398} CreateCo;
399
400static void coroutine_fn bdrv_create_co_entry(void *opaque)
401{
Max Reitzcc84d902013-09-06 17:14:26 +0200402 Error *local_err = NULL;
403 int ret;
404
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800405 CreateCo *cco = opaque;
406 assert(cco->drv);
407
Max Reitzcc84d902013-09-06 17:14:26 +0200408 ret = cco->drv->bdrv_create(cco->filename, cco->options, &local_err);
409 if (error_is_set(&local_err)) {
410 error_propagate(&cco->err, local_err);
411 }
412 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800413}
414
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200415int bdrv_create(BlockDriver *drv, const char* filename,
Max Reitzcc84d902013-09-06 17:14:26 +0200416 QEMUOptionParameter *options, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000417{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800418 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200419
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800420 Coroutine *co;
421 CreateCo cco = {
422 .drv = drv,
423 .filename = g_strdup(filename),
424 .options = options,
425 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200426 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800427 };
428
429 if (!drv->bdrv_create) {
Max Reitzcc84d902013-09-06 17:14:26 +0200430 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300431 ret = -ENOTSUP;
432 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800433 }
434
435 if (qemu_in_coroutine()) {
436 /* Fast-path if already in coroutine context */
437 bdrv_create_co_entry(&cco);
438 } else {
439 co = qemu_coroutine_create(bdrv_create_co_entry);
440 qemu_coroutine_enter(co, &cco);
441 while (cco.ret == NOT_DONE) {
442 qemu_aio_wait();
443 }
444 }
445
446 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200447 if (ret < 0) {
448 if (error_is_set(&cco.err)) {
449 error_propagate(errp, cco.err);
450 } else {
451 error_setg_errno(errp, -ret, "Could not create image");
452 }
453 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800454
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300455out:
456 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800457 return ret;
bellardea2384d2004-08-01 21:59:26 +0000458}
459
Max Reitzcc84d902013-09-06 17:14:26 +0200460int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
461 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200462{
463 BlockDriver *drv;
Max Reitzcc84d902013-09-06 17:14:26 +0200464 Error *local_err = NULL;
465 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200466
Kevin Wolf98289622013-07-10 15:47:39 +0200467 drv = bdrv_find_protocol(filename, true);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200468 if (drv == NULL) {
Max Reitzcc84d902013-09-06 17:14:26 +0200469 error_setg(errp, "Could not find protocol for file '%s'", filename);
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000470 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200471 }
472
Max Reitzcc84d902013-09-06 17:14:26 +0200473 ret = bdrv_create(drv, filename, options, &local_err);
474 if (error_is_set(&local_err)) {
475 error_propagate(errp, local_err);
476 }
477 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200478}
479
Jim Meyeringeba25052012-05-28 09:27:54 +0200480/*
481 * Create a uniquely-named empty temporary file.
482 * Return 0 upon success, otherwise a negative errno value.
483 */
484int get_tmp_filename(char *filename, int size)
485{
bellardd5249392004-08-03 21:14:23 +0000486#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000487 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200488 /* GetTempFileName requires that its output buffer (4th param)
489 have length MAX_PATH or greater. */
490 assert(size >= MAX_PATH);
491 return (GetTempPath(MAX_PATH, temp_dir)
492 && GetTempFileName(temp_dir, "qem", 0, filename)
493 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000494#else
bellardea2384d2004-08-01 21:59:26 +0000495 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000496 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000497 tmpdir = getenv("TMPDIR");
498 if (!tmpdir)
499 tmpdir = "/tmp";
Jim Meyeringeba25052012-05-28 09:27:54 +0200500 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
501 return -EOVERFLOW;
502 }
bellardea2384d2004-08-01 21:59:26 +0000503 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800504 if (fd < 0) {
505 return -errno;
506 }
507 if (close(fd) != 0) {
508 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200509 return -errno;
510 }
511 return 0;
bellardd5249392004-08-03 21:14:23 +0000512#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200513}
bellardea2384d2004-08-01 21:59:26 +0000514
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200515/*
516 * Detect host devices. By convention, /dev/cdrom[N] is always
517 * recognized as a host CDROM.
518 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200519static BlockDriver *find_hdev_driver(const char *filename)
520{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200521 int score_max = 0, score;
522 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200523
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100524 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200525 if (d->bdrv_probe_device) {
526 score = d->bdrv_probe_device(filename);
527 if (score > score_max) {
528 score_max = score;
529 drv = d;
530 }
531 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200532 }
533
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200534 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200535}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200536
Kevin Wolf98289622013-07-10 15:47:39 +0200537BlockDriver *bdrv_find_protocol(const char *filename,
538 bool allow_protocol_prefix)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200539{
540 BlockDriver *drv1;
541 char protocol[128];
542 int len;
543 const char *p;
544
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200545 /* TODO Drivers without bdrv_file_open must be specified explicitly */
546
Christoph Hellwig39508e72010-06-23 12:25:17 +0200547 /*
548 * XXX(hch): we really should not let host device detection
549 * override an explicit protocol specification, but moving this
550 * later breaks access to device names with colons in them.
551 * Thanks to the brain-dead persistent naming schemes on udev-
552 * based Linux systems those actually are quite common.
553 */
554 drv1 = find_hdev_driver(filename);
555 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200556 return drv1;
557 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200558
Kevin Wolf98289622013-07-10 15:47:39 +0200559 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Christoph Hellwig39508e72010-06-23 12:25:17 +0200560 return bdrv_find_format("file");
561 }
Kevin Wolf98289622013-07-10 15:47:39 +0200562
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000563 p = strchr(filename, ':');
564 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200565 len = p - filename;
566 if (len > sizeof(protocol) - 1)
567 len = sizeof(protocol) - 1;
568 memcpy(protocol, filename, len);
569 protocol[len] = '\0';
570 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
571 if (drv1->protocol_name &&
572 !strcmp(drv1->protocol_name, protocol)) {
573 return drv1;
574 }
575 }
576 return NULL;
577}
578
Kevin Wolff500a6d2012-11-12 17:35:27 +0100579static int find_image_format(BlockDriverState *bs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200580 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000581{
Kevin Wolff500a6d2012-11-12 17:35:27 +0100582 int score, score_max;
bellardea2384d2004-08-01 21:59:26 +0000583 BlockDriver *drv1, *drv;
bellard83f64092006-08-01 16:21:11 +0000584 uint8_t buf[2048];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100585 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700586
Kevin Wolf08a00552010-06-01 18:37:31 +0200587 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Paolo Bonzini8e895592013-01-10 15:39:27 +0100588 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Stefan Weilc98ac352010-07-21 21:51:51 +0200589 drv = bdrv_find_format("raw");
590 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200591 error_setg(errp, "Could not find raw image format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200592 ret = -ENOENT;
593 }
594 *pdrv = drv;
595 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700596 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700597
bellard83f64092006-08-01 16:21:11 +0000598 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000599 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200600 error_setg_errno(errp, -ret, "Could not read image for determining its "
601 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200602 *pdrv = NULL;
603 return ret;
bellard83f64092006-08-01 16:21:11 +0000604 }
605
bellardea2384d2004-08-01 21:59:26 +0000606 score_max = 0;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200607 drv = NULL;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100608 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
bellard83f64092006-08-01 16:21:11 +0000609 if (drv1->bdrv_probe) {
610 score = drv1->bdrv_probe(buf, ret, filename);
611 if (score > score_max) {
612 score_max = score;
613 drv = drv1;
614 }
bellardea2384d2004-08-01 21:59:26 +0000615 }
616 }
Stefan Weilc98ac352010-07-21 21:51:51 +0200617 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200618 error_setg(errp, "Could not determine image format: No compatible "
619 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200620 ret = -ENOENT;
621 }
622 *pdrv = drv;
623 return ret;
bellardea2384d2004-08-01 21:59:26 +0000624}
625
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100626/**
627 * Set the current 'total_sectors' value
628 */
629static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
630{
631 BlockDriver *drv = bs->drv;
632
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700633 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
634 if (bs->sg)
635 return 0;
636
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100637 /* query actual device if possible, otherwise just trust the hint */
638 if (drv->bdrv_getlength) {
639 int64_t length = drv->bdrv_getlength(bs);
640 if (length < 0) {
641 return length;
642 }
Fam Zheng7e382002013-11-06 19:48:06 +0800643 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100644 }
645
646 bs->total_sectors = hint;
647 return 0;
648}
649
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100650/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100651 * Set open flags for a given discard mode
652 *
653 * Return 0 on success, -1 if the discard mode was invalid.
654 */
655int bdrv_parse_discard_flags(const char *mode, int *flags)
656{
657 *flags &= ~BDRV_O_UNMAP;
658
659 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
660 /* do nothing */
661 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
662 *flags |= BDRV_O_UNMAP;
663 } else {
664 return -1;
665 }
666
667 return 0;
668}
669
670/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100671 * Set open flags for a given cache mode
672 *
673 * Return 0 on success, -1 if the cache mode was invalid.
674 */
675int bdrv_parse_cache_flags(const char *mode, int *flags)
676{
677 *flags &= ~BDRV_O_CACHE_MASK;
678
679 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
680 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100681 } else if (!strcmp(mode, "directsync")) {
682 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100683 } else if (!strcmp(mode, "writeback")) {
684 *flags |= BDRV_O_CACHE_WB;
685 } else if (!strcmp(mode, "unsafe")) {
686 *flags |= BDRV_O_CACHE_WB;
687 *flags |= BDRV_O_NO_FLUSH;
688 } else if (!strcmp(mode, "writethrough")) {
689 /* this is the default */
690 } else {
691 return -1;
692 }
693
694 return 0;
695}
696
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000697/**
698 * The copy-on-read flag is actually a reference count so multiple users may
699 * use the feature without worrying about clobbering its previous state.
700 * Copy-on-read stays enabled until all users have called to disable it.
701 */
702void bdrv_enable_copy_on_read(BlockDriverState *bs)
703{
704 bs->copy_on_read++;
705}
706
707void bdrv_disable_copy_on_read(BlockDriverState *bs)
708{
709 assert(bs->copy_on_read > 0);
710 bs->copy_on_read--;
711}
712
Kevin Wolf7b272452012-11-12 17:05:39 +0100713static int bdrv_open_flags(BlockDriverState *bs, int flags)
714{
715 int open_flags = flags | BDRV_O_CACHE_WB;
716
717 /*
718 * Clear flags that are internal to the block layer before opening the
719 * image.
720 */
721 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
722
723 /*
724 * Snapshots should be writable.
725 */
726 if (bs->is_temporary) {
727 open_flags |= BDRV_O_RDWR;
728 }
729
730 return open_flags;
731}
732
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200733/*
Kevin Wolf57915332010-04-14 15:24:50 +0200734 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +0100735 *
736 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +0200737 */
Kevin Wolff500a6d2012-11-12 17:35:27 +0100738static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200739 QDict *options, int flags, BlockDriver *drv, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +0200740{
741 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200742 const char *filename;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200743 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +0200744
745 assert(drv != NULL);
Paolo Bonzini64058752012-05-08 16:51:49 +0200746 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +0100747 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +0200748
Kevin Wolf45673672013-04-22 17:48:40 +0200749 if (file != NULL) {
750 filename = file->filename;
751 } else {
752 filename = qdict_get_try_str(options, "filename");
753 }
754
755 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
Stefan Hajnoczi28dcee12011-09-22 20:14:12 +0100756
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100757 /* bdrv_open() with directly using a protocol as drv. This layer is already
758 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
759 * and return immediately. */
760 if (file != NULL && drv->bdrv_file_open) {
761 bdrv_swap(file, bs);
762 return 0;
763 }
764
Kevin Wolf57915332010-04-14 15:24:50 +0200765 bs->open_flags = flags;
Kevin Wolf57915332010-04-14 15:24:50 +0200766 bs->buffer_alignment = 512;
Asias He0d51b4d2013-08-22 15:24:14 +0800767 bs->zero_beyond_eof = true;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800768 open_flags = bdrv_open_flags(bs, flags);
769 bs->read_only = !(open_flags & BDRV_O_RDWR);
770
771 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200772 error_setg(errp,
773 !bs->read_only && bdrv_is_whitelisted(drv, true)
774 ? "Driver '%s' can only be used for read-only devices"
775 : "Driver '%s' is not whitelisted",
776 drv->format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800777 return -ENOTSUP;
778 }
Kevin Wolf57915332010-04-14 15:24:50 +0200779
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000780 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200781 if (flags & BDRV_O_COPY_ON_READ) {
782 if (!bs->read_only) {
783 bdrv_enable_copy_on_read(bs);
784 } else {
785 error_setg(errp, "Can't use copy-on-read on read-only device");
786 return -EINVAL;
787 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000788 }
789
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100790 if (filename != NULL) {
791 pstrcpy(bs->filename, sizeof(bs->filename), filename);
792 } else {
793 bs->filename[0] = '\0';
794 }
Kevin Wolf57915332010-04-14 15:24:50 +0200795
Kevin Wolf57915332010-04-14 15:24:50 +0200796 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500797 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200798
Stefan Hajnoczi03f541b2011-10-27 10:54:28 +0100799 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100800
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200801 /* Open the image, either directly or using a protocol */
802 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100803 assert(file == NULL);
BenoƮt Canet030be322013-09-24 17:07:04 +0200804 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200805 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +0100806 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200807 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200808 error_setg(errp, "Can't use '%s' as a block driver for the "
809 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200810 ret = -EINVAL;
811 goto free_and_fail;
812 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100813 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200814 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200815 }
816
Kevin Wolf57915332010-04-14 15:24:50 +0200817 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200818 if (error_is_set(&local_err)) {
819 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +0800820 } else if (bs->filename[0]) {
821 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200822 } else {
823 error_setg_errno(errp, -ret, "Could not open image");
824 }
Kevin Wolf57915332010-04-14 15:24:50 +0200825 goto free_and_fail;
826 }
827
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100828 ret = refresh_total_sectors(bs, bs->total_sectors);
829 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200830 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100831 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200832 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100833
Kevin Wolf57915332010-04-14 15:24:50 +0200834#ifndef _WIN32
835 if (bs->is_temporary) {
Dunrong Huangd4cea8d2013-10-03 01:31:27 +0800836 assert(bs->filename[0] != '\0');
837 unlink(bs->filename);
Kevin Wolf57915332010-04-14 15:24:50 +0200838 }
839#endif
840 return 0;
841
842free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +0100843 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -0500844 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +0200845 bs->opaque = NULL;
846 bs->drv = NULL;
847 return ret;
848}
849
850/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200851 * Opens a file using a protocol (file, host_device, nbd, ...)
Kevin Wolf787e4a82013-03-06 11:52:48 +0100852 *
853 * options is a QDict of options to pass to the block drivers, or NULL for an
854 * empty set of options. The reference to the QDict belongs to the block layer
855 * after the call (even on failure), so if the caller intends to reuse the
856 * dictionary, it needs to use QINCREF() before calling bdrv_file_open.
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200857 */
Kevin Wolf787e4a82013-03-06 11:52:48 +0100858int bdrv_file_open(BlockDriverState **pbs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200859 QDict *options, int flags, Error **errp)
bellardb3380822004-03-14 21:38:54 +0000860{
bellard83f64092006-08-01 16:21:11 +0000861 BlockDriverState *bs;
Christoph Hellwig6db95602010-04-05 16:53:57 +0200862 BlockDriver *drv;
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100863 const char *drvname;
Kevin Wolf98289622013-07-10 15:47:39 +0200864 bool allow_protocol_prefix = false;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200865 Error *local_err = NULL;
bellard83f64092006-08-01 16:21:11 +0000866 int ret;
867
Kevin Wolf707ff822013-03-06 12:20:31 +0100868 /* NULL means an empty set of options */
869 if (options == NULL) {
870 options = qdict_new();
bellard3b0d4f62005-10-30 18:30:10 +0000871 }
Kevin Wolf707ff822013-03-06 12:20:31 +0100872
873 bs = bdrv_new("");
874 bs->options = options;
875 options = qdict_clone_shallow(options);
876
Kevin Wolf035fccd2013-04-09 14:34:19 +0200877 /* Fetch the file name from the options QDict if necessary */
878 if (!filename) {
879 filename = qdict_get_try_str(options, "filename");
880 } else if (filename && !qdict_haskey(options, "filename")) {
881 qdict_put(options, "filename", qstring_from_str(filename));
Kevin Wolf98289622013-07-10 15:47:39 +0200882 allow_protocol_prefix = true;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200883 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200884 error_setg(errp, "Can't specify 'file' and 'filename' options at the "
885 "same time");
Kevin Wolf035fccd2013-04-09 14:34:19 +0200886 ret = -EINVAL;
887 goto fail;
888 }
889
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100890 /* Find the right block driver */
891 drvname = qdict_get_try_str(options, "driver");
892 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200893 drv = bdrv_find_format(drvname);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200894 if (!drv) {
895 error_setg(errp, "Unknown driver '%s'", drvname);
896 }
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100897 qdict_del(options, "driver");
898 } else if (filename) {
Kevin Wolf98289622013-07-10 15:47:39 +0200899 drv = bdrv_find_protocol(filename, allow_protocol_prefix);
900 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200901 error_setg(errp, "Unknown protocol");
Kevin Wolf98289622013-07-10 15:47:39 +0200902 }
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100903 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200904 error_setg(errp, "Must specify either driver or file");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100905 drv = NULL;
906 }
907
908 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200909 /* errp has been set already */
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100910 ret = -ENOENT;
911 goto fail;
912 }
913
914 /* Parse the filename and open it */
915 if (drv->bdrv_parse_filename && filename) {
Kevin Wolf6963a302013-03-15 18:47:22 +0100916 drv->bdrv_parse_filename(filename, options, &local_err);
917 if (error_is_set(&local_err)) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200918 error_propagate(errp, local_err);
Kevin Wolf6963a302013-03-15 18:47:22 +0100919 ret = -EINVAL;
920 goto fail;
921 }
Kevin Wolf56d1b4d2013-04-12 20:02:37 +0200922 qdict_del(options, "filename");
BenoƮt Canet030be322013-09-24 17:07:04 +0200923 } else if (drv->bdrv_needs_filename && !filename) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200924 error_setg(errp, "The '%s' block driver requires a file name",
925 drv->format_name);
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100926 ret = -EINVAL;
927 goto fail;
Kevin Wolf6963a302013-03-15 18:47:22 +0100928 }
929
Max Reitz34b5d2c2013-09-05 14:45:29 +0200930 ret = bdrv_open_common(bs, NULL, options, flags, drv, &local_err);
Kevin Wolf707ff822013-03-06 12:20:31 +0100931 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200932 error_propagate(errp, local_err);
Kevin Wolf707ff822013-03-06 12:20:31 +0100933 goto fail;
934 }
935
936 /* Check if any unknown options were used */
937 if (qdict_size(options) != 0) {
938 const QDictEntry *entry = qdict_first(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200939 error_setg(errp, "Block protocol '%s' doesn't support the option '%s'",
940 drv->format_name, entry->key);
Kevin Wolf707ff822013-03-06 12:20:31 +0100941 ret = -EINVAL;
942 goto fail;
943 }
944 QDECREF(options);
945
aliguori71d07702009-03-03 17:37:16 +0000946 bs->growable = 1;
bellard83f64092006-08-01 16:21:11 +0000947 *pbs = bs;
948 return 0;
Kevin Wolf707ff822013-03-06 12:20:31 +0100949
950fail:
951 QDECREF(options);
952 if (!bs->drv) {
953 QDECREF(bs->options);
954 }
Fam Zheng4f6fd342013-08-23 09:14:47 +0800955 bdrv_unref(bs);
Kevin Wolf707ff822013-03-06 12:20:31 +0100956 return ret;
bellardea2384d2004-08-01 21:59:26 +0000957}
bellardfc01f7e2003-06-30 10:03:06 +0000958
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100959/*
960 * Opens the backing file for a BlockDriverState if not yet open
961 *
962 * options is a QDict of options to pass to the block drivers, or NULL for an
963 * empty set of options. The reference to the QDict is transferred to this
964 * function (even on failure), so if the caller intends to reuse the dictionary,
965 * it needs to use QINCREF() before calling bdrv_file_open.
966 */
Max Reitz34b5d2c2013-09-05 14:45:29 +0200967int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +0200968{
969 char backing_filename[PATH_MAX];
970 int back_flags, ret;
971 BlockDriver *back_drv = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200972 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +0200973
974 if (bs->backing_hd != NULL) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100975 QDECREF(options);
Paolo Bonzini9156df12012-10-18 16:49:17 +0200976 return 0;
977 }
978
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100979 /* NULL means an empty set of options */
980 if (options == NULL) {
981 options = qdict_new();
982 }
983
Paolo Bonzini9156df12012-10-18 16:49:17 +0200984 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolf1cb6f502013-04-12 20:27:07 +0200985 if (qdict_haskey(options, "file.filename")) {
986 backing_filename[0] = '\0';
987 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +0100988 QDECREF(options);
Paolo Bonzini9156df12012-10-18 16:49:17 +0200989 return 0;
Fam Zhengdbecebd2013-09-22 20:05:06 +0800990 } else {
991 bdrv_get_full_backing_filename(bs, backing_filename,
992 sizeof(backing_filename));
Paolo Bonzini9156df12012-10-18 16:49:17 +0200993 }
994
995 bs->backing_hd = bdrv_new("");
Paolo Bonzini9156df12012-10-18 16:49:17 +0200996
997 if (bs->backing_format[0] != '\0') {
998 back_drv = bdrv_find_format(bs->backing_format);
999 }
1000
1001 /* backing files always opened read-only */
Thibaut LAURENT87a5deb2013-10-25 02:15:07 +02001002 back_flags = bs->open_flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT |
1003 BDRV_O_COPY_ON_READ);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001004
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001005 ret = bdrv_open(bs->backing_hd,
1006 *backing_filename ? backing_filename : NULL, options,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001007 back_flags, back_drv, &local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001008 if (ret < 0) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001009 bdrv_unref(bs->backing_hd);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001010 bs->backing_hd = NULL;
1011 bs->open_flags |= BDRV_O_NO_BACKING;
Fam Zhengb04b6b62013-11-08 11:26:49 +08001012 error_setg(errp, "Could not open backing file: %s",
1013 error_get_pretty(local_err));
1014 error_free(local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001015 return ret;
1016 }
Max Reitz61ed2682013-10-26 15:44:43 +02001017 pstrcpy(bs->backing_file, sizeof(bs->backing_file),
1018 bs->backing_hd->file->filename);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001019 return 0;
1020}
1021
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001022/*
1023 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001024 *
1025 * options is a QDict of options to pass to the block drivers, or NULL for an
1026 * empty set of options. The reference to the QDict belongs to the block layer
1027 * after the call (even on failure), so if the caller intends to reuse the
1028 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001029 */
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001030int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001031 int flags, BlockDriver *drv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001032{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001033 int ret;
Stefan Weil89c9bc32012-11-22 07:25:48 +01001034 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1035 char tmp_filename[PATH_MAX + 1];
Kevin Wolff500a6d2012-11-12 17:35:27 +01001036 BlockDriverState *file = NULL;
Kevin Wolf707ff822013-03-06 12:20:31 +01001037 QDict *file_options = NULL;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001038 const char *drvname;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001039 Error *local_err = NULL;
bellard712e7872005-04-28 21:09:32 +00001040
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001041 /* NULL means an empty set of options */
1042 if (options == NULL) {
1043 options = qdict_new();
1044 }
1045
1046 bs->options = options;
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001047 options = qdict_clone_shallow(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001048
1049 /* For snapshot=on, create a temporary qcow2 overlay */
bellard83f64092006-08-01 16:21:11 +00001050 if (flags & BDRV_O_SNAPSHOT) {
bellardea2384d2004-08-01 21:59:26 +00001051 BlockDriverState *bs1;
1052 int64_t total_size;
Kevin Wolf91a073a2009-05-27 14:48:06 +02001053 BlockDriver *bdrv_qcow2;
Kevin Wolf08b392e2013-03-18 16:17:44 +01001054 QEMUOptionParameter *create_options;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001055 char backing_filename[PATH_MAX];
ths3b46e622007-09-17 08:09:54 +00001056
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001057 if (qdict_size(options) != 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001058 error_setg(errp, "Can't use snapshot=on with driver-specific options");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001059 ret = -EINVAL;
1060 goto fail;
1061 }
1062 assert(filename != NULL);
1063
bellardea2384d2004-08-01 21:59:26 +00001064 /* if snapshot, we create a temporary backing file and open it
1065 instead of opening 'filename' directly */
1066
1067 /* if there is a backing file, use it */
1068 bs1 = bdrv_new("");
Max Reitz34b5d2c2013-09-05 14:45:29 +02001069 ret = bdrv_open(bs1, filename, NULL, 0, drv, &local_err);
aliguori51d7c002009-03-05 23:00:29 +00001070 if (ret < 0) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001071 bdrv_unref(bs1);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001072 goto fail;
bellardea2384d2004-08-01 21:59:26 +00001073 }
Jes Sorensen3e829902010-05-27 16:20:30 +02001074 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
aliguori7c96d462008-09-12 17:54:13 +00001075
Fam Zheng4f6fd342013-08-23 09:14:47 +08001076 bdrv_unref(bs1);
ths3b46e622007-09-17 08:09:54 +00001077
Jim Meyeringeba25052012-05-28 09:27:54 +02001078 ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));
1079 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001080 error_setg_errno(errp, -ret, "Could not get temporary filename");
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001081 goto fail;
Jim Meyeringeba25052012-05-28 09:27:54 +02001082 }
aliguori7c96d462008-09-12 17:54:13 +00001083
1084 /* Real path is meaningless for protocols */
Stefan Hajnoczi4d706552013-03-18 17:58:53 +01001085 if (path_has_protocol(filename)) {
aliguori7c96d462008-09-12 17:54:13 +00001086 snprintf(backing_filename, sizeof(backing_filename),
1087 "%s", filename);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001088 } else if (!realpath(filename, backing_filename)) {
1089 ret = -errno;
Max Reitz17826bc2013-11-05 20:03:33 +01001090 error_setg_errno(errp, errno, "Could not resolve path '%s'", filename);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001091 goto fail;
1092 }
aliguori7c96d462008-09-12 17:54:13 +00001093
Kevin Wolf91a073a2009-05-27 14:48:06 +02001094 bdrv_qcow2 = bdrv_find_format("qcow2");
Kevin Wolf08b392e2013-03-18 16:17:44 +01001095 create_options = parse_option_parameters("", bdrv_qcow2->create_options,
1096 NULL);
Kevin Wolf91a073a2009-05-27 14:48:06 +02001097
Kevin Wolf08b392e2013-03-18 16:17:44 +01001098 set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
1099 set_option_parameter(create_options, BLOCK_OPT_BACKING_FILE,
1100 backing_filename);
Kevin Wolf91a073a2009-05-27 14:48:06 +02001101 if (drv) {
Kevin Wolf08b392e2013-03-18 16:17:44 +01001102 set_option_parameter(create_options, BLOCK_OPT_BACKING_FMT,
Kevin Wolf91a073a2009-05-27 14:48:06 +02001103 drv->format_name);
1104 }
1105
Max Reitzcc84d902013-09-06 17:14:26 +02001106 ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);
Kevin Wolf08b392e2013-03-18 16:17:44 +01001107 free_option_parameters(create_options);
aliguori51d7c002009-03-05 23:00:29 +00001108 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001109 error_setg_errno(errp, -ret, "Could not create temporary overlay "
Max Reitzcc84d902013-09-06 17:14:26 +02001110 "'%s': %s", tmp_filename,
1111 error_get_pretty(local_err));
1112 error_free(local_err);
1113 local_err = NULL;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001114 goto fail;
bellardea2384d2004-08-01 21:59:26 +00001115 }
Kevin Wolf91a073a2009-05-27 14:48:06 +02001116
bellardea2384d2004-08-01 21:59:26 +00001117 filename = tmp_filename;
Kevin Wolf91a073a2009-05-27 14:48:06 +02001118 drv = bdrv_qcow2;
bellardea2384d2004-08-01 21:59:26 +00001119 bs->is_temporary = 1;
1120 }
bellard712e7872005-04-28 21:09:32 +00001121
Kevin Wolff500a6d2012-11-12 17:35:27 +01001122 /* Open image file without format layer */
Jeff Codybe028ad2012-09-20 15:13:17 -04001123 if (flags & BDRV_O_RDWR) {
1124 flags |= BDRV_O_ALLOW_RDWR;
1125 }
1126
BenoƮt Canet5726d872013-09-25 13:30:01 +02001127 qdict_extract_subqdict(options, &file_options, "file.");
Kevin Wolf707ff822013-03-06 12:20:31 +01001128
1129 ret = bdrv_file_open(&file, filename, file_options,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001130 bdrv_open_flags(bs, flags | BDRV_O_UNMAP), &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001131 if (ret < 0) {
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001132 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001133 }
1134
1135 /* Find the right image format driver */
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001136 drvname = qdict_get_try_str(options, "driver");
1137 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +02001138 drv = bdrv_find_format(drvname);
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001139 qdict_del(options, "driver");
Kevin Wolf06d22aa2013-08-08 17:44:52 +02001140 if (!drv) {
1141 error_setg(errp, "Invalid driver: '%s'", drvname);
1142 ret = -EINVAL;
1143 goto unlink_and_fail;
1144 }
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001145 }
1146
Kevin Wolff500a6d2012-11-12 17:35:27 +01001147 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001148 ret = find_image_format(file, filename, &drv, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001149 }
1150
1151 if (!drv) {
1152 goto unlink_and_fail;
1153 }
1154
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001155 /* Open the image */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001156 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001157 if (ret < 0) {
Christoph Hellwig69873072010-01-20 18:13:25 +01001158 goto unlink_and_fail;
1159 }
1160
Kevin Wolff500a6d2012-11-12 17:35:27 +01001161 if (bs->file != file) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001162 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001163 file = NULL;
1164 }
1165
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001166 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001167 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001168 QDict *backing_options;
1169
BenoƮt Canet5726d872013-09-25 13:30:01 +02001170 qdict_extract_subqdict(options, &backing_options, "backing.");
Max Reitz34b5d2c2013-09-05 14:45:29 +02001171 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001172 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001173 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001174 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001175 }
1176
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001177 /* Check if any unknown options were used */
1178 if (qdict_size(options) != 0) {
1179 const QDictEntry *entry = qdict_first(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001180 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1181 "support the option '%s'", drv->format_name, bs->device_name,
1182 entry->key);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001183
1184 ret = -EINVAL;
1185 goto close_and_fail;
1186 }
1187 QDECREF(options);
1188
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001189 if (!bdrv_key_required(bs)) {
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001190 bdrv_dev_change_media_cb(bs, true);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001191 }
1192
1193 return 0;
1194
1195unlink_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001196 if (file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001197 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001198 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001199 if (bs->is_temporary) {
1200 unlink(filename);
1201 }
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001202fail:
1203 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001204 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001205 bs->options = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001206 if (error_is_set(&local_err)) {
1207 error_propagate(errp, local_err);
1208 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001209 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001210
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001211close_and_fail:
1212 bdrv_close(bs);
1213 QDECREF(options);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001214 if (error_is_set(&local_err)) {
1215 error_propagate(errp, local_err);
1216 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001217 return ret;
1218}
1219
Jeff Codye971aa12012-09-20 15:13:19 -04001220typedef struct BlockReopenQueueEntry {
1221 bool prepared;
1222 BDRVReopenState state;
1223 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1224} BlockReopenQueueEntry;
1225
1226/*
1227 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1228 * reopen of multiple devices.
1229 *
1230 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1231 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1232 * be created and initialized. This newly created BlockReopenQueue should be
1233 * passed back in for subsequent calls that are intended to be of the same
1234 * atomic 'set'.
1235 *
1236 * bs is the BlockDriverState to add to the reopen queue.
1237 *
1238 * flags contains the open flags for the associated bs
1239 *
1240 * returns a pointer to bs_queue, which is either the newly allocated
1241 * bs_queue, or the existing bs_queue being used.
1242 *
1243 */
1244BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1245 BlockDriverState *bs, int flags)
1246{
1247 assert(bs != NULL);
1248
1249 BlockReopenQueueEntry *bs_entry;
1250 if (bs_queue == NULL) {
1251 bs_queue = g_new0(BlockReopenQueue, 1);
1252 QSIMPLEQ_INIT(bs_queue);
1253 }
1254
1255 if (bs->file) {
1256 bdrv_reopen_queue(bs_queue, bs->file, flags);
1257 }
1258
1259 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1260 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1261
1262 bs_entry->state.bs = bs;
1263 bs_entry->state.flags = flags;
1264
1265 return bs_queue;
1266}
1267
1268/*
1269 * Reopen multiple BlockDriverStates atomically & transactionally.
1270 *
1271 * The queue passed in (bs_queue) must have been built up previous
1272 * via bdrv_reopen_queue().
1273 *
1274 * Reopens all BDS specified in the queue, with the appropriate
1275 * flags. All devices are prepared for reopen, and failure of any
1276 * device will cause all device changes to be abandonded, and intermediate
1277 * data cleaned up.
1278 *
1279 * If all devices prepare successfully, then the changes are committed
1280 * to all devices.
1281 *
1282 */
1283int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1284{
1285 int ret = -1;
1286 BlockReopenQueueEntry *bs_entry, *next;
1287 Error *local_err = NULL;
1288
1289 assert(bs_queue != NULL);
1290
1291 bdrv_drain_all();
1292
1293 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1294 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1295 error_propagate(errp, local_err);
1296 goto cleanup;
1297 }
1298 bs_entry->prepared = true;
1299 }
1300
1301 /* If we reach this point, we have success and just need to apply the
1302 * changes
1303 */
1304 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1305 bdrv_reopen_commit(&bs_entry->state);
1306 }
1307
1308 ret = 0;
1309
1310cleanup:
1311 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1312 if (ret && bs_entry->prepared) {
1313 bdrv_reopen_abort(&bs_entry->state);
1314 }
1315 g_free(bs_entry);
1316 }
1317 g_free(bs_queue);
1318 return ret;
1319}
1320
1321
1322/* Reopen a single BlockDriverState with the specified flags. */
1323int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1324{
1325 int ret = -1;
1326 Error *local_err = NULL;
1327 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1328
1329 ret = bdrv_reopen_multiple(queue, &local_err);
1330 if (local_err != NULL) {
1331 error_propagate(errp, local_err);
1332 }
1333 return ret;
1334}
1335
1336
1337/*
1338 * Prepares a BlockDriverState for reopen. All changes are staged in the
1339 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1340 * the block driver layer .bdrv_reopen_prepare()
1341 *
1342 * bs is the BlockDriverState to reopen
1343 * flags are the new open flags
1344 * queue is the reopen queue
1345 *
1346 * Returns 0 on success, non-zero on error. On error errp will be set
1347 * as well.
1348 *
1349 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1350 * It is the responsibility of the caller to then call the abort() or
1351 * commit() for any other BDS that have been left in a prepare() state
1352 *
1353 */
1354int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1355 Error **errp)
1356{
1357 int ret = -1;
1358 Error *local_err = NULL;
1359 BlockDriver *drv;
1360
1361 assert(reopen_state != NULL);
1362 assert(reopen_state->bs->drv != NULL);
1363 drv = reopen_state->bs->drv;
1364
1365 /* if we are to stay read-only, do not allow permission change
1366 * to r/w */
1367 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1368 reopen_state->flags & BDRV_O_RDWR) {
1369 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1370 reopen_state->bs->device_name);
1371 goto error;
1372 }
1373
1374
1375 ret = bdrv_flush(reopen_state->bs);
1376 if (ret) {
1377 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1378 strerror(-ret));
1379 goto error;
1380 }
1381
1382 if (drv->bdrv_reopen_prepare) {
1383 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1384 if (ret) {
1385 if (local_err != NULL) {
1386 error_propagate(errp, local_err);
1387 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04001388 error_setg(errp, "failed while preparing to reopen image '%s'",
1389 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04001390 }
1391 goto error;
1392 }
1393 } else {
1394 /* It is currently mandatory to have a bdrv_reopen_prepare()
1395 * handler for each supported drv. */
1396 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1397 drv->format_name, reopen_state->bs->device_name,
1398 "reopening of file");
1399 ret = -1;
1400 goto error;
1401 }
1402
1403 ret = 0;
1404
1405error:
1406 return ret;
1407}
1408
1409/*
1410 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1411 * makes them final by swapping the staging BlockDriverState contents into
1412 * the active BlockDriverState contents.
1413 */
1414void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1415{
1416 BlockDriver *drv;
1417
1418 assert(reopen_state != NULL);
1419 drv = reopen_state->bs->drv;
1420 assert(drv != NULL);
1421
1422 /* If there are any driver level actions to take */
1423 if (drv->bdrv_reopen_commit) {
1424 drv->bdrv_reopen_commit(reopen_state);
1425 }
1426
1427 /* set BDS specific flags now */
1428 reopen_state->bs->open_flags = reopen_state->flags;
1429 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1430 BDRV_O_CACHE_WB);
1431 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1432}
1433
1434/*
1435 * Abort the reopen, and delete and free the staged changes in
1436 * reopen_state
1437 */
1438void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1439{
1440 BlockDriver *drv;
1441
1442 assert(reopen_state != NULL);
1443 drv = reopen_state->bs->drv;
1444 assert(drv != NULL);
1445
1446 if (drv->bdrv_reopen_abort) {
1447 drv->bdrv_reopen_abort(reopen_state);
1448 }
1449}
1450
1451
bellardfc01f7e2003-06-30 10:03:06 +00001452void bdrv_close(BlockDriverState *bs)
1453{
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001454 if (bs->job) {
1455 block_job_cancel_sync(bs->job);
1456 }
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02001457 bdrv_drain_all(); /* complete I/O */
1458 bdrv_flush(bs);
1459 bdrv_drain_all(); /* in case flush left pending I/O */
Paolo Bonzinid7d512f2012-08-23 11:20:36 +02001460 notifier_list_notify(&bs->close_notifiers, bs);
Kevin Wolf7094f122012-04-11 11:06:37 +02001461
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001462 if (bs->drv) {
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001463 if (bs->backing_hd) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001464 bdrv_unref(bs->backing_hd);
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001465 bs->backing_hd = NULL;
1466 }
bellardea2384d2004-08-01 21:59:26 +00001467 bs->drv->bdrv_close(bs);
Anthony Liguori7267c092011-08-20 22:09:37 -05001468 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00001469#ifdef _WIN32
1470 if (bs->is_temporary) {
1471 unlink(bs->filename);
1472 }
bellard67b915a2004-03-31 23:37:16 +00001473#endif
bellardea2384d2004-08-01 21:59:26 +00001474 bs->opaque = NULL;
1475 bs->drv = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001476 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02001477 bs->backing_file[0] = '\0';
1478 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02001479 bs->total_sectors = 0;
1480 bs->encrypted = 0;
1481 bs->valid_key = 0;
1482 bs->sg = 0;
1483 bs->growable = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08001484 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001485 QDECREF(bs->options);
1486 bs->options = NULL;
bellardb3380822004-03-14 21:38:54 +00001487
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001488 if (bs->file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001489 bdrv_unref(bs->file);
Paolo Bonzini0ac93772012-05-08 16:51:44 +02001490 bs->file = NULL;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001491 }
bellardb3380822004-03-14 21:38:54 +00001492 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001493
Pavel Hrdina9ca11152012-08-09 12:44:48 +02001494 bdrv_dev_change_media_cb(bs, false);
1495
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001496 /*throttling disk I/O limits*/
1497 if (bs->io_limits_enabled) {
1498 bdrv_io_limits_disable(bs);
1499 }
bellardb3380822004-03-14 21:38:54 +00001500}
1501
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001502void bdrv_close_all(void)
1503{
1504 BlockDriverState *bs;
1505
1506 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1507 bdrv_close(bs);
1508 }
1509}
1510
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001511/* Check if any requests are in-flight (including throttled requests) */
1512static bool bdrv_requests_pending(BlockDriverState *bs)
1513{
1514 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1515 return true;
1516 }
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001517 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1518 return true;
1519 }
1520 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001521 return true;
1522 }
1523 if (bs->file && bdrv_requests_pending(bs->file)) {
1524 return true;
1525 }
1526 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1527 return true;
1528 }
1529 return false;
1530}
1531
1532static bool bdrv_requests_pending_all(void)
1533{
1534 BlockDriverState *bs;
1535 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1536 if (bdrv_requests_pending(bs)) {
1537 return true;
1538 }
1539 }
1540 return false;
1541}
1542
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001543/*
1544 * Wait for pending requests to complete across all BlockDriverStates
1545 *
1546 * This function does not flush data to disk, use bdrv_flush_all() for that
1547 * after calling this function.
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001548 *
1549 * Note that completion of an asynchronous I/O operation can trigger any
1550 * number of other I/O operations on other devices---for example a coroutine
1551 * can be arbitrarily complex and a constant flow of I/O can come until the
1552 * coroutine is complete. Because of this, it is not possible to have a
1553 * function to drain a single device's I/O queue.
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001554 */
1555void bdrv_drain_all(void)
1556{
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001557 /* Always run first iteration so any pending completion BHs run */
1558 bool busy = true;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001559 BlockDriverState *bs;
1560
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001561 while (busy) {
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001562 /* FIXME: We do not have timer support here, so this is effectively
1563 * a busy wait.
1564 */
1565 QTAILQ_FOREACH(bs, &bdrv_states, list) {
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001566 if (bdrv_start_throttled_reqs(bs)) {
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001567 busy = true;
1568 }
1569 }
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001570
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001571 busy = bdrv_requests_pending_all();
1572 busy |= aio_poll(qemu_get_aio_context(), busy);
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001573 }
1574}
1575
Ryan Harperd22b2f42011-03-29 20:51:47 -05001576/* make a BlockDriverState anonymous by removing from bdrv_state list.
1577 Also, NULL terminate the device_name to prevent double remove */
1578void bdrv_make_anon(BlockDriverState *bs)
1579{
1580 if (bs->device_name[0] != '\0') {
1581 QTAILQ_REMOVE(&bdrv_states, bs, list);
1582 }
1583 bs->device_name[0] = '\0';
1584}
1585
Paolo Bonzinie023b2e2012-05-08 16:51:41 +02001586static void bdrv_rebind(BlockDriverState *bs)
1587{
1588 if (bs->drv && bs->drv->bdrv_rebind) {
1589 bs->drv->bdrv_rebind(bs);
1590 }
1591}
1592
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001593static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1594 BlockDriverState *bs_src)
1595{
1596 /* move some fields that need to stay attached to the device */
1597 bs_dest->open_flags = bs_src->open_flags;
1598
1599 /* dev info */
1600 bs_dest->dev_ops = bs_src->dev_ops;
1601 bs_dest->dev_opaque = bs_src->dev_opaque;
1602 bs_dest->dev = bs_src->dev;
1603 bs_dest->buffer_alignment = bs_src->buffer_alignment;
1604 bs_dest->copy_on_read = bs_src->copy_on_read;
1605
1606 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1607
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001608 /* i/o throttled req */
1609 memcpy(&bs_dest->throttle_state,
1610 &bs_src->throttle_state,
1611 sizeof(ThrottleState));
1612 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1613 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001614 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1615
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001616 /* r/w error */
1617 bs_dest->on_read_error = bs_src->on_read_error;
1618 bs_dest->on_write_error = bs_src->on_write_error;
1619
1620 /* i/o status */
1621 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1622 bs_dest->iostatus = bs_src->iostatus;
1623
1624 /* dirty bitmap */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001625 bs_dest->dirty_bitmap = bs_src->dirty_bitmap;
1626
Fam Zheng9fcb0252013-08-23 09:14:46 +08001627 /* reference count */
1628 bs_dest->refcnt = bs_src->refcnt;
1629
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001630 /* job */
1631 bs_dest->in_use = bs_src->in_use;
1632 bs_dest->job = bs_src->job;
1633
1634 /* keep the same entry in bdrv_states */
1635 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1636 bs_src->device_name);
1637 bs_dest->list = bs_src->list;
1638}
1639
1640/*
1641 * Swap bs contents for two image chains while they are live,
1642 * while keeping required fields on the BlockDriverState that is
1643 * actually attached to a device.
1644 *
1645 * This will modify the BlockDriverState fields, and swap contents
1646 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1647 *
1648 * bs_new is required to be anonymous.
1649 *
1650 * This function does not create any image files.
1651 */
1652void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
1653{
1654 BlockDriverState tmp;
1655
1656 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1657 assert(bs_new->device_name[0] == '\0');
1658 assert(bs_new->dirty_bitmap == NULL);
1659 assert(bs_new->job == NULL);
1660 assert(bs_new->dev == NULL);
1661 assert(bs_new->in_use == 0);
1662 assert(bs_new->io_limits_enabled == false);
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001663 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001664
1665 tmp = *bs_new;
1666 *bs_new = *bs_old;
1667 *bs_old = tmp;
1668
1669 /* there are some fields that should not be swapped, move them back */
1670 bdrv_move_feature_fields(&tmp, bs_old);
1671 bdrv_move_feature_fields(bs_old, bs_new);
1672 bdrv_move_feature_fields(bs_new, &tmp);
1673
1674 /* bs_new shouldn't be in bdrv_states even after the swap! */
1675 assert(bs_new->device_name[0] == '\0');
1676
1677 /* Check a few fields that should remain attached to the device */
1678 assert(bs_new->dev == NULL);
1679 assert(bs_new->job == NULL);
1680 assert(bs_new->in_use == 0);
1681 assert(bs_new->io_limits_enabled == false);
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02001682 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001683
1684 bdrv_rebind(bs_new);
1685 bdrv_rebind(bs_old);
1686}
1687
Jeff Cody8802d1f2012-02-28 15:54:06 -05001688/*
1689 * Add new bs contents at the top of an image chain while the chain is
1690 * live, while keeping required fields on the top layer.
1691 *
1692 * This will modify the BlockDriverState fields, and swap contents
1693 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1694 *
Jeff Codyf6801b82012-03-27 16:30:19 -04001695 * bs_new is required to be anonymous.
1696 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05001697 * This function does not create any image files.
1698 */
1699void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
1700{
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001701 bdrv_swap(bs_new, bs_top);
Jeff Cody8802d1f2012-02-28 15:54:06 -05001702
1703 /* The contents of 'tmp' will become bs_top, as we are
1704 * swapping bs_new and bs_top contents. */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001705 bs_top->backing_hd = bs_new;
1706 bs_top->open_flags &= ~BDRV_O_NO_BACKING;
1707 pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
1708 bs_new->filename);
1709 pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
1710 bs_new->drv ? bs_new->drv->format_name : "");
Jeff Cody8802d1f2012-02-28 15:54:06 -05001711}
1712
Fam Zheng4f6fd342013-08-23 09:14:47 +08001713static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00001714{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001715 assert(!bs->dev);
Paolo Bonzini3e914652012-03-30 13:17:11 +02001716 assert(!bs->job);
1717 assert(!bs->in_use);
Fam Zheng4f6fd342013-08-23 09:14:47 +08001718 assert(!bs->refcnt);
Markus Armbruster18846de2010-06-29 16:58:30 +02001719
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02001720 bdrv_close(bs);
1721
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01001722 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05001723 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00001724
Anthony Liguori7267c092011-08-20 22:09:37 -05001725 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00001726}
1727
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001728int bdrv_attach_dev(BlockDriverState *bs, void *dev)
1729/* TODO change to DeviceState *dev when all users are qdevified */
Markus Armbruster18846de2010-06-29 16:58:30 +02001730{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001731 if (bs->dev) {
Markus Armbruster18846de2010-06-29 16:58:30 +02001732 return -EBUSY;
1733 }
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001734 bs->dev = dev;
Luiz Capitulino28a72822011-09-26 17:43:50 -03001735 bdrv_iostatus_reset(bs);
Markus Armbruster18846de2010-06-29 16:58:30 +02001736 return 0;
1737}
1738
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001739/* TODO qdevified devices don't use this, remove when devices are qdevified */
1740void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
Markus Armbruster18846de2010-06-29 16:58:30 +02001741{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001742 if (bdrv_attach_dev(bs, dev) < 0) {
1743 abort();
1744 }
1745}
1746
1747void bdrv_detach_dev(BlockDriverState *bs, void *dev)
1748/* TODO change to DeviceState *dev when all users are qdevified */
1749{
1750 assert(bs->dev == dev);
1751 bs->dev = NULL;
Markus Armbruster0e49de52011-08-03 15:07:41 +02001752 bs->dev_ops = NULL;
1753 bs->dev_opaque = NULL;
Markus Armbruster29e05f22011-09-06 18:58:57 +02001754 bs->buffer_alignment = 512;
Markus Armbruster18846de2010-06-29 16:58:30 +02001755}
1756
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001757/* TODO change to return DeviceState * when all users are qdevified */
1758void *bdrv_get_attached_dev(BlockDriverState *bs)
Markus Armbruster18846de2010-06-29 16:58:30 +02001759{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001760 return bs->dev;
Markus Armbruster18846de2010-06-29 16:58:30 +02001761}
1762
Markus Armbruster0e49de52011-08-03 15:07:41 +02001763void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
1764 void *opaque)
1765{
1766 bs->dev_ops = ops;
1767 bs->dev_opaque = opaque;
1768}
1769
Paolo Bonzini32c81a42012-09-28 17:22:58 +02001770void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
1771 enum MonitorEvent ev,
1772 BlockErrorAction action, bool is_read)
Luiz Capitulino329c0a42012-01-25 16:59:43 -02001773{
1774 QObject *data;
1775 const char *action_str;
1776
1777 switch (action) {
1778 case BDRV_ACTION_REPORT:
1779 action_str = "report";
1780 break;
1781 case BDRV_ACTION_IGNORE:
1782 action_str = "ignore";
1783 break;
1784 case BDRV_ACTION_STOP:
1785 action_str = "stop";
1786 break;
1787 default:
1788 abort();
1789 }
1790
1791 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1792 bdrv->device_name,
1793 action_str,
1794 is_read ? "read" : "write");
Paolo Bonzini32c81a42012-09-28 17:22:58 +02001795 monitor_protocol_event(ev, data);
Luiz Capitulino329c0a42012-01-25 16:59:43 -02001796
1797 qobject_decref(data);
1798}
1799
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001800static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
1801{
1802 QObject *data;
1803
1804 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1805 bdrv_get_device_name(bs), ejected);
1806 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
1807
1808 qobject_decref(data);
1809}
1810
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001811static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
Markus Armbruster0e49de52011-08-03 15:07:41 +02001812{
Markus Armbruster145feb12011-08-03 15:07:42 +02001813 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001814 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001815 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001816 if (tray_was_closed) {
1817 /* tray open */
1818 bdrv_emit_qmp_eject_event(bs, true);
1819 }
1820 if (load) {
1821 /* tray close */
1822 bdrv_emit_qmp_eject_event(bs, false);
1823 }
Markus Armbruster145feb12011-08-03 15:07:42 +02001824 }
1825}
1826
Markus Armbruster2c6942f2011-09-06 18:58:51 +02001827bool bdrv_dev_has_removable_media(BlockDriverState *bs)
1828{
1829 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
1830}
1831
Paolo Bonzini025ccaa2011-11-07 17:50:13 +01001832void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
1833{
1834 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
1835 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
1836 }
1837}
1838
Markus Armbrustere4def802011-09-06 18:58:53 +02001839bool bdrv_dev_is_tray_open(BlockDriverState *bs)
1840{
1841 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
1842 return bs->dev_ops->is_tray_open(bs->dev_opaque);
1843 }
1844 return false;
1845}
1846
Markus Armbruster145feb12011-08-03 15:07:42 +02001847static void bdrv_dev_resize_cb(BlockDriverState *bs)
1848{
1849 if (bs->dev_ops && bs->dev_ops->resize_cb) {
1850 bs->dev_ops->resize_cb(bs->dev_opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +02001851 }
1852}
1853
Markus Armbrusterf1076392011-09-06 18:58:46 +02001854bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
1855{
1856 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
1857 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
1858 }
1859 return false;
1860}
1861
aliguorie97fc192009-04-21 23:11:50 +00001862/*
1863 * Run consistency checks on an image
1864 *
Kevin Wolfe076f332010-06-29 11:43:13 +02001865 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02001866 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02001867 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00001868 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02001869int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00001870{
1871 if (bs->drv->bdrv_check == NULL) {
1872 return -ENOTSUP;
1873 }
1874
Kevin Wolfe076f332010-06-29 11:43:13 +02001875 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02001876 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00001877}
1878
Kevin Wolf8a426612010-07-16 17:17:01 +02001879#define COMMIT_BUF_SECTORS 2048
1880
bellard33e39632003-07-06 17:15:21 +00001881/* commit COW file into the raw image */
1882int bdrv_commit(BlockDriverState *bs)
1883{
bellard19cb3732006-08-19 11:45:59 +00001884 BlockDriver *drv = bs->drv;
Kevin Wolf8a426612010-07-16 17:17:01 +02001885 int64_t sector, total_sectors;
1886 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04001887 int ret = 0;
Kevin Wolf8a426612010-07-16 17:17:01 +02001888 uint8_t *buf;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02001889 char filename[PATH_MAX];
bellard33e39632003-07-06 17:15:21 +00001890
bellard19cb3732006-08-19 11:45:59 +00001891 if (!drv)
1892 return -ENOMEDIUM;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001893
1894 if (!bs->backing_hd) {
1895 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00001896 }
1897
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00001898 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
1899 return -EBUSY;
1900 }
1901
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001902 ro = bs->backing_hd->read_only;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02001903 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1904 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001905 open_flags = bs->backing_hd->open_flags;
1906
1907 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04001908 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
1909 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001910 }
bellard33e39632003-07-06 17:15:21 +00001911 }
bellardea2384d2004-08-01 21:59:26 +00001912
Jan Kiszka6ea44302009-11-30 18:21:19 +01001913 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
Anthony Liguori7267c092011-08-20 22:09:37 -05001914 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
bellardea2384d2004-08-01 21:59:26 +00001915
Kevin Wolf8a426612010-07-16 17:17:01 +02001916 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02001917 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
1918 if (ret < 0) {
1919 goto ro_cleanup;
1920 }
1921 if (ret) {
Kevin Wolf8a426612010-07-16 17:17:01 +02001922 if (bdrv_read(bs, sector, buf, n) != 0) {
1923 ret = -EIO;
1924 goto ro_cleanup;
1925 }
1926
1927 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
1928 ret = -EIO;
1929 goto ro_cleanup;
1930 }
bellardea2384d2004-08-01 21:59:26 +00001931 }
1932 }
bellard95389c82005-12-18 18:28:15 +00001933
Christoph Hellwig1d449522010-01-17 12:32:30 +01001934 if (drv->bdrv_make_empty) {
1935 ret = drv->bdrv_make_empty(bs);
1936 bdrv_flush(bs);
1937 }
bellard95389c82005-12-18 18:28:15 +00001938
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01001939 /*
1940 * Make sure all data we wrote to the backing device is actually
1941 * stable on disk.
1942 */
1943 if (bs->backing_hd)
1944 bdrv_flush(bs->backing_hd);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001945
1946ro_cleanup:
Anthony Liguori7267c092011-08-20 22:09:37 -05001947 g_free(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001948
1949 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04001950 /* ignoring error return here */
1951 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001952 }
1953
Christoph Hellwig1d449522010-01-17 12:32:30 +01001954 return ret;
bellard33e39632003-07-06 17:15:21 +00001955}
1956
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001957int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001958{
1959 BlockDriverState *bs;
1960
1961 QTAILQ_FOREACH(bs, &bdrv_states, list) {
Jeff Cody272d2d82013-02-26 09:55:48 -05001962 if (bs->drv && bs->backing_hd) {
1963 int ret = bdrv_commit(bs);
1964 if (ret < 0) {
1965 return ret;
1966 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001967 }
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001968 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001969 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001970}
1971
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001972/**
1973 * Remove an active request from the tracked requests list
1974 *
1975 * This function should be called when a tracked request is completing.
1976 */
1977static void tracked_request_end(BdrvTrackedRequest *req)
1978{
1979 QLIST_REMOVE(req, list);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001980 qemu_co_queue_restart_all(&req->wait_queue);
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001981}
1982
1983/**
1984 * Add an active request to the tracked requests list
1985 */
1986static void tracked_request_begin(BdrvTrackedRequest *req,
1987 BlockDriverState *bs,
1988 int64_t sector_num,
1989 int nb_sectors, bool is_write)
1990{
1991 *req = (BdrvTrackedRequest){
1992 .bs = bs,
1993 .sector_num = sector_num,
1994 .nb_sectors = nb_sectors,
1995 .is_write = is_write,
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00001996 .co = qemu_coroutine_self(),
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001997 };
1998
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001999 qemu_co_queue_init(&req->wait_queue);
2000
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002001 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2002}
2003
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002004/**
2005 * Round a region to cluster boundaries
2006 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002007void bdrv_round_to_clusters(BlockDriverState *bs,
2008 int64_t sector_num, int nb_sectors,
2009 int64_t *cluster_sector_num,
2010 int *cluster_nb_sectors)
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002011{
2012 BlockDriverInfo bdi;
2013
2014 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2015 *cluster_sector_num = sector_num;
2016 *cluster_nb_sectors = nb_sectors;
2017 } else {
2018 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2019 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2020 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2021 nb_sectors, c);
2022 }
2023}
2024
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002025static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2026 int64_t sector_num, int nb_sectors) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002027 /* aaaa bbbb */
2028 if (sector_num >= req->sector_num + req->nb_sectors) {
2029 return false;
2030 }
2031 /* bbbb aaaa */
2032 if (req->sector_num >= sector_num + nb_sectors) {
2033 return false;
2034 }
2035 return true;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002036}
2037
2038static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
2039 int64_t sector_num, int nb_sectors)
2040{
2041 BdrvTrackedRequest *req;
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002042 int64_t cluster_sector_num;
2043 int cluster_nb_sectors;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002044 bool retry;
2045
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002046 /* If we touch the same cluster it counts as an overlap. This guarantees
2047 * that allocating writes will be serialized and not race with each other
2048 * for the same cluster. For example, in copy-on-read it ensures that the
2049 * CoR read and write operations are atomic and guest writes cannot
2050 * interleave between them.
2051 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002052 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2053 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002054
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002055 do {
2056 retry = false;
2057 QLIST_FOREACH(req, &bs->tracked_requests, list) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002058 if (tracked_request_overlaps(req, cluster_sector_num,
2059 cluster_nb_sectors)) {
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00002060 /* Hitting this means there was a reentrant request, for
2061 * example, a block driver issuing nested requests. This must
2062 * never happen since it means deadlock.
2063 */
2064 assert(qemu_coroutine_self() != req->co);
2065
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002066 qemu_co_queue_wait(&req->wait_queue);
2067 retry = true;
2068 break;
2069 }
2070 }
2071 } while (retry);
2072}
2073
Kevin Wolf756e6732010-01-12 12:55:17 +01002074/*
2075 * Return values:
2076 * 0 - success
2077 * -EINVAL - backing format specified, but no file
2078 * -ENOSPC - can't update the backing file because no space is left in the
2079 * image file header
2080 * -ENOTSUP - format driver doesn't support changing the backing file
2081 */
2082int bdrv_change_backing_file(BlockDriverState *bs,
2083 const char *backing_file, const char *backing_fmt)
2084{
2085 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002086 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002087
Paolo Bonzini5f377792012-04-12 14:01:01 +02002088 /* Backing file format doesn't make sense without a backing file */
2089 if (backing_fmt && !backing_file) {
2090 return -EINVAL;
2091 }
2092
Kevin Wolf756e6732010-01-12 12:55:17 +01002093 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002094 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002095 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002096 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002097 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002098
2099 if (ret == 0) {
2100 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2101 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2102 }
2103 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002104}
2105
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002106/*
2107 * Finds the image layer in the chain that has 'bs' as its backing file.
2108 *
2109 * active is the current topmost image.
2110 *
2111 * Returns NULL if bs is not found in active's image chain,
2112 * or if active == bs.
2113 */
2114BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2115 BlockDriverState *bs)
2116{
2117 BlockDriverState *overlay = NULL;
2118 BlockDriverState *intermediate;
2119
2120 assert(active != NULL);
2121 assert(bs != NULL);
2122
2123 /* if bs is the same as active, then by definition it has no overlay
2124 */
2125 if (active == bs) {
2126 return NULL;
2127 }
2128
2129 intermediate = active;
2130 while (intermediate->backing_hd) {
2131 if (intermediate->backing_hd == bs) {
2132 overlay = intermediate;
2133 break;
2134 }
2135 intermediate = intermediate->backing_hd;
2136 }
2137
2138 return overlay;
2139}
2140
2141typedef struct BlkIntermediateStates {
2142 BlockDriverState *bs;
2143 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2144} BlkIntermediateStates;
2145
2146
2147/*
2148 * Drops images above 'base' up to and including 'top', and sets the image
2149 * above 'top' to have base as its backing file.
2150 *
2151 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2152 * information in 'bs' can be properly updated.
2153 *
2154 * E.g., this will convert the following chain:
2155 * bottom <- base <- intermediate <- top <- active
2156 *
2157 * to
2158 *
2159 * bottom <- base <- active
2160 *
2161 * It is allowed for bottom==base, in which case it converts:
2162 *
2163 * base <- intermediate <- top <- active
2164 *
2165 * to
2166 *
2167 * base <- active
2168 *
2169 * Error conditions:
2170 * if active == top, that is considered an error
2171 *
2172 */
2173int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2174 BlockDriverState *base)
2175{
2176 BlockDriverState *intermediate;
2177 BlockDriverState *base_bs = NULL;
2178 BlockDriverState *new_top_bs = NULL;
2179 BlkIntermediateStates *intermediate_state, *next;
2180 int ret = -EIO;
2181
2182 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2183 QSIMPLEQ_INIT(&states_to_delete);
2184
2185 if (!top->drv || !base->drv) {
2186 goto exit;
2187 }
2188
2189 new_top_bs = bdrv_find_overlay(active, top);
2190
2191 if (new_top_bs == NULL) {
2192 /* we could not find the image above 'top', this is an error */
2193 goto exit;
2194 }
2195
2196 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2197 * to do, no intermediate images */
2198 if (new_top_bs->backing_hd == base) {
2199 ret = 0;
2200 goto exit;
2201 }
2202
2203 intermediate = top;
2204
2205 /* now we will go down through the list, and add each BDS we find
2206 * into our deletion queue, until we hit the 'base'
2207 */
2208 while (intermediate) {
2209 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2210 intermediate_state->bs = intermediate;
2211 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2212
2213 if (intermediate->backing_hd == base) {
2214 base_bs = intermediate->backing_hd;
2215 break;
2216 }
2217 intermediate = intermediate->backing_hd;
2218 }
2219 if (base_bs == NULL) {
2220 /* something went wrong, we did not end at the base. safely
2221 * unravel everything, and exit with error */
2222 goto exit;
2223 }
2224
2225 /* success - we can delete the intermediate states, and link top->base */
2226 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2227 base_bs->drv ? base_bs->drv->format_name : "");
2228 if (ret) {
2229 goto exit;
2230 }
2231 new_top_bs->backing_hd = base_bs;
2232
2233
2234 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2235 /* so that bdrv_close() does not recursively close the chain */
2236 intermediate_state->bs->backing_hd = NULL;
Fam Zheng4f6fd342013-08-23 09:14:47 +08002237 bdrv_unref(intermediate_state->bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002238 }
2239 ret = 0;
2240
2241exit:
2242 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2243 g_free(intermediate_state);
2244 }
2245 return ret;
2246}
2247
2248
aliguori71d07702009-03-03 17:37:16 +00002249static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2250 size_t size)
2251{
2252 int64_t len;
2253
2254 if (!bdrv_is_inserted(bs))
2255 return -ENOMEDIUM;
2256
2257 if (bs->growable)
2258 return 0;
2259
2260 len = bdrv_getlength(bs);
2261
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02002262 if (offset < 0)
2263 return -EIO;
2264
2265 if ((offset > len) || (len - offset < size))
aliguori71d07702009-03-03 17:37:16 +00002266 return -EIO;
2267
2268 return 0;
2269}
2270
2271static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2272 int nb_sectors)
2273{
Jes Sorenseneb5a3162010-05-27 16:20:31 +02002274 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2275 nb_sectors * BDRV_SECTOR_SIZE);
aliguori71d07702009-03-03 17:37:16 +00002276}
2277
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002278typedef struct RwCo {
2279 BlockDriverState *bs;
2280 int64_t sector_num;
2281 int nb_sectors;
2282 QEMUIOVector *qiov;
2283 bool is_write;
2284 int ret;
Peter Lieven4105eaa2013-07-11 14:16:22 +02002285 BdrvRequestFlags flags;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002286} RwCo;
2287
2288static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2289{
2290 RwCo *rwco = opaque;
2291
2292 if (!rwco->is_write) {
2293 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002294 rwco->nb_sectors, rwco->qiov,
2295 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002296 } else {
2297 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002298 rwco->nb_sectors, rwco->qiov,
2299 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002300 }
2301}
2302
2303/*
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002304 * Process a vectored synchronous request using coroutines
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002305 */
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002306static int bdrv_rwv_co(BlockDriverState *bs, int64_t sector_num,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002307 QEMUIOVector *qiov, bool is_write,
2308 BdrvRequestFlags flags)
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002309{
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002310 Coroutine *co;
2311 RwCo rwco = {
2312 .bs = bs,
2313 .sector_num = sector_num,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002314 .nb_sectors = qiov->size >> BDRV_SECTOR_BITS,
2315 .qiov = qiov,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002316 .is_write = is_write,
2317 .ret = NOT_DONE,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002318 .flags = flags,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002319 };
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002320 assert((qiov->size & (BDRV_SECTOR_SIZE - 1)) == 0);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002321
Zhi Yong Wu498e3862012-04-02 18:59:34 +08002322 /**
2323 * In sync call context, when the vcpu is blocked, this throttling timer
2324 * will not fire; so the I/O throttling function has to be disabled here
2325 * if it has been enabled.
2326 */
2327 if (bs->io_limits_enabled) {
2328 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2329 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2330 bdrv_io_limits_disable(bs);
2331 }
2332
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002333 if (qemu_in_coroutine()) {
2334 /* Fast-path if already in coroutine context */
2335 bdrv_rw_co_entry(&rwco);
2336 } else {
2337 co = qemu_coroutine_create(bdrv_rw_co_entry);
2338 qemu_coroutine_enter(co, &rwco);
2339 while (rwco.ret == NOT_DONE) {
2340 qemu_aio_wait();
2341 }
2342 }
2343 return rwco.ret;
2344}
2345
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002346/*
2347 * Process a synchronous request using coroutines
2348 */
2349static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002350 int nb_sectors, bool is_write, BdrvRequestFlags flags)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002351{
2352 QEMUIOVector qiov;
2353 struct iovec iov = {
2354 .iov_base = (void *)buf,
2355 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2356 };
2357
2358 qemu_iovec_init_external(&qiov, &iov, 1);
Peter Lieven4105eaa2013-07-11 14:16:22 +02002359 return bdrv_rwv_co(bs, sector_num, &qiov, is_write, flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002360}
2361
bellard19cb3732006-08-19 11:45:59 +00002362/* return < 0 if error. See bdrv_write() for the return codes */
ths5fafdf22007-09-16 21:08:06 +00002363int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002364 uint8_t *buf, int nb_sectors)
2365{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002366 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
bellardfc01f7e2003-06-30 10:03:06 +00002367}
2368
Markus Armbruster07d27a42012-06-29 17:34:29 +02002369/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2370int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2371 uint8_t *buf, int nb_sectors)
2372{
2373 bool enabled;
2374 int ret;
2375
2376 enabled = bs->io_limits_enabled;
2377 bs->io_limits_enabled = false;
Peter Lieven4e7395e2013-07-18 10:37:32 +02002378 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
Markus Armbruster07d27a42012-06-29 17:34:29 +02002379 bs->io_limits_enabled = enabled;
2380 return ret;
2381}
2382
ths5fafdf22007-09-16 21:08:06 +00002383/* Return < 0 if error. Important errors are:
bellard19cb3732006-08-19 11:45:59 +00002384 -EIO generic I/O error (may happen for all errors)
2385 -ENOMEDIUM No media inserted.
2386 -EINVAL Invalid sector number or nb_sectors
2387 -EACCES Trying to write a read-only device
2388*/
ths5fafdf22007-09-16 21:08:06 +00002389int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002390 const uint8_t *buf, int nb_sectors)
2391{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002392 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
bellard83f64092006-08-01 16:21:11 +00002393}
2394
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002395int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov)
2396{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002397 return bdrv_rwv_co(bs, sector_num, qiov, true, 0);
2398}
2399
2400int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
2401{
2402 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2403 BDRV_REQ_ZERO_WRITE);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002404}
2405
aliguorieda578e2009-03-12 19:57:16 +00002406int bdrv_pread(BlockDriverState *bs, int64_t offset,
2407 void *buf, int count1)
bellard83f64092006-08-01 16:21:11 +00002408{
Jan Kiszka6ea44302009-11-30 18:21:19 +01002409 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
bellard83f64092006-08-01 16:21:11 +00002410 int len, nb_sectors, count;
2411 int64_t sector_num;
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002412 int ret;
bellard83f64092006-08-01 16:21:11 +00002413
2414 count = count1;
2415 /* first read to align to sector start */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002416 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
bellard83f64092006-08-01 16:21:11 +00002417 if (len > count)
2418 len = count;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002419 sector_num = offset >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002420 if (len > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002421 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2422 return ret;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002423 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
bellard83f64092006-08-01 16:21:11 +00002424 count -= len;
2425 if (count == 0)
2426 return count1;
2427 sector_num++;
2428 buf += len;
2429 }
2430
2431 /* read the sectors "in place" */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002432 nb_sectors = count >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002433 if (nb_sectors > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002434 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
2435 return ret;
bellard83f64092006-08-01 16:21:11 +00002436 sector_num += nb_sectors;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002437 len = nb_sectors << BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002438 buf += len;
2439 count -= len;
2440 }
2441
2442 /* add data from the last sector */
2443 if (count > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002444 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2445 return ret;
bellard83f64092006-08-01 16:21:11 +00002446 memcpy(buf, tmp_buf, count);
2447 }
2448 return count1;
2449}
2450
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002451int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
bellard83f64092006-08-01 16:21:11 +00002452{
Jan Kiszka6ea44302009-11-30 18:21:19 +01002453 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
bellard83f64092006-08-01 16:21:11 +00002454 int len, nb_sectors, count;
2455 int64_t sector_num;
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002456 int ret;
bellard83f64092006-08-01 16:21:11 +00002457
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002458 count = qiov->size;
2459
bellard83f64092006-08-01 16:21:11 +00002460 /* first write to align to sector start */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002461 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
bellard83f64092006-08-01 16:21:11 +00002462 if (len > count)
2463 len = count;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002464 sector_num = offset >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002465 if (len > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002466 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2467 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002468 qemu_iovec_to_buf(qiov, 0, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)),
2469 len);
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002470 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2471 return ret;
bellard83f64092006-08-01 16:21:11 +00002472 count -= len;
2473 if (count == 0)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002474 return qiov->size;
bellard83f64092006-08-01 16:21:11 +00002475 sector_num++;
bellard83f64092006-08-01 16:21:11 +00002476 }
2477
2478 /* write the sectors "in place" */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002479 nb_sectors = count >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002480 if (nb_sectors > 0) {
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002481 QEMUIOVector qiov_inplace;
2482
2483 qemu_iovec_init(&qiov_inplace, qiov->niov);
2484 qemu_iovec_concat(&qiov_inplace, qiov, len,
2485 nb_sectors << BDRV_SECTOR_BITS);
2486 ret = bdrv_writev(bs, sector_num, &qiov_inplace);
2487 qemu_iovec_destroy(&qiov_inplace);
2488 if (ret < 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002489 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002490 }
2491
bellard83f64092006-08-01 16:21:11 +00002492 sector_num += nb_sectors;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002493 len = nb_sectors << BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002494 count -= len;
2495 }
2496
2497 /* add data from the last sector */
2498 if (count > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002499 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2500 return ret;
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002501 qemu_iovec_to_buf(qiov, qiov->size - count, tmp_buf, count);
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002502 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2503 return ret;
bellard83f64092006-08-01 16:21:11 +00002504 }
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002505 return qiov->size;
2506}
2507
2508int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2509 const void *buf, int count1)
2510{
2511 QEMUIOVector qiov;
2512 struct iovec iov = {
2513 .iov_base = (void *) buf,
2514 .iov_len = count1,
2515 };
2516
2517 qemu_iovec_init_external(&qiov, &iov, 1);
2518 return bdrv_pwritev(bs, offset, &qiov);
bellard83f64092006-08-01 16:21:11 +00002519}
bellard83f64092006-08-01 16:21:11 +00002520
Kevin Wolff08145f2010-06-16 16:38:15 +02002521/*
2522 * Writes to the file and ensures that no writes are reordered across this
2523 * request (acts as a barrier)
2524 *
2525 * Returns 0 on success, -errno in error cases.
2526 */
2527int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2528 const void *buf, int count)
2529{
2530 int ret;
2531
2532 ret = bdrv_pwrite(bs, offset, buf, count);
2533 if (ret < 0) {
2534 return ret;
2535 }
2536
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002537 /* No flush needed for cache modes that already do it */
2538 if (bs->enable_write_cache) {
Kevin Wolff08145f2010-06-16 16:38:15 +02002539 bdrv_flush(bs);
2540 }
2541
2542 return 0;
2543}
2544
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002545static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002546 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2547{
2548 /* Perform I/O through a temporary buffer so that users who scribble over
2549 * their read buffer while the operation is in progress do not end up
2550 * modifying the image file. This is critical for zero-copy guest I/O
2551 * where anything might happen inside guest memory.
2552 */
2553 void *bounce_buffer;
2554
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002555 BlockDriver *drv = bs->drv;
Stefan Hajnocziab185922011-11-17 13:40:31 +00002556 struct iovec iov;
2557 QEMUIOVector bounce_qiov;
2558 int64_t cluster_sector_num;
2559 int cluster_nb_sectors;
2560 size_t skip_bytes;
2561 int ret;
2562
2563 /* Cover entire cluster so no additional backing file I/O is required when
2564 * allocating cluster in the image file.
2565 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002566 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2567 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002568
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002569 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2570 cluster_sector_num, cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002571
2572 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2573 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2574 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2575
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002576 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2577 &bounce_qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002578 if (ret < 0) {
2579 goto err;
2580 }
2581
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002582 if (drv->bdrv_co_write_zeroes &&
2583 buffer_is_zero(bounce_buffer, iov.iov_len)) {
Kevin Wolf621f0582012-03-20 15:12:58 +01002584 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2585 cluster_nb_sectors);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002586 } else {
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002587 /* This does not change the data on the disk, it is not necessary
2588 * to flush even in cache=writethrough mode.
2589 */
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002590 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002591 &bounce_qiov);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002592 }
2593
Stefan Hajnocziab185922011-11-17 13:40:31 +00002594 if (ret < 0) {
2595 /* It might be okay to ignore write errors for guest requests. If this
2596 * is a deliberate copy-on-read then we don't want to ignore the error.
2597 * Simply report it in all cases.
2598 */
2599 goto err;
2600 }
2601
2602 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
Michael Tokarev03396142012-06-07 20:17:55 +04002603 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2604 nb_sectors * BDRV_SECTOR_SIZE);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002605
2606err:
2607 qemu_vfree(bounce_buffer);
2608 return ret;
2609}
2610
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002611/*
2612 * Handle a read request in coroutine context
2613 */
2614static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002615 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2616 BdrvRequestFlags flags)
Kevin Wolfda1fa912011-07-14 17:27:13 +02002617{
2618 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002619 BdrvTrackedRequest req;
2620 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002621
Kevin Wolfda1fa912011-07-14 17:27:13 +02002622 if (!drv) {
2623 return -ENOMEDIUM;
2624 }
2625 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2626 return -EIO;
2627 }
2628
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002629 if (bs->copy_on_read) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002630 flags |= BDRV_REQ_COPY_ON_READ;
2631 }
2632 if (flags & BDRV_REQ_COPY_ON_READ) {
2633 bs->copy_on_read_in_flight++;
2634 }
2635
2636 if (bs->copy_on_read_in_flight) {
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002637 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2638 }
2639
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02002640 /* throttling disk I/O */
2641 if (bs->io_limits_enabled) {
2642 bdrv_io_limits_intercept(bs, nb_sectors, false);
2643 }
2644
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002645 tracked_request_begin(&req, bs, sector_num, nb_sectors, false);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002646
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002647 if (flags & BDRV_REQ_COPY_ON_READ) {
Stefan Hajnocziab185922011-11-17 13:40:31 +00002648 int pnum;
2649
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02002650 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002651 if (ret < 0) {
2652 goto out;
2653 }
2654
2655 if (!ret || pnum != nb_sectors) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002656 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002657 goto out;
2658 }
2659 }
2660
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08002661 if (!(bs->zero_beyond_eof && bs->growable)) {
2662 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
2663 } else {
2664 /* Read zeros after EOF of growable BDSes */
2665 int64_t len, total_sectors, max_nb_sectors;
2666
2667 len = bdrv_getlength(bs);
2668 if (len < 0) {
2669 ret = len;
2670 goto out;
2671 }
2672
Fam Zhengd055a1f2013-09-26 19:55:33 +08002673 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08002674 max_nb_sectors = MAX(0, total_sectors - sector_num);
2675 if (max_nb_sectors > 0) {
2676 ret = drv->bdrv_co_readv(bs, sector_num,
2677 MIN(nb_sectors, max_nb_sectors), qiov);
2678 } else {
2679 ret = 0;
2680 }
2681
2682 /* Reading beyond end of file is supposed to produce zeroes */
2683 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
2684 uint64_t offset = MAX(0, total_sectors - sector_num);
2685 uint64_t bytes = (sector_num + nb_sectors - offset) *
2686 BDRV_SECTOR_SIZE;
2687 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
2688 }
2689 }
Stefan Hajnocziab185922011-11-17 13:40:31 +00002690
2691out:
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002692 tracked_request_end(&req);
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002693
2694 if (flags & BDRV_REQ_COPY_ON_READ) {
2695 bs->copy_on_read_in_flight--;
2696 }
2697
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002698 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002699}
2700
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002701int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
Kevin Wolfda1fa912011-07-14 17:27:13 +02002702 int nb_sectors, QEMUIOVector *qiov)
2703{
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002704 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02002705
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002706 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
2707}
2708
2709int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
2710 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2711{
2712 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
2713
2714 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
2715 BDRV_REQ_COPY_ON_READ);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002716}
2717
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002718static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
2719 int64_t sector_num, int nb_sectors)
2720{
2721 BlockDriver *drv = bs->drv;
2722 QEMUIOVector qiov;
2723 struct iovec iov;
2724 int ret;
2725
Kevin Wolf621f0582012-03-20 15:12:58 +01002726 /* TODO Emulate only part of misaligned requests instead of letting block
2727 * drivers return -ENOTSUP and emulate everything */
2728
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002729 /* First try the efficient write zeroes operation */
2730 if (drv->bdrv_co_write_zeroes) {
Kevin Wolf621f0582012-03-20 15:12:58 +01002731 ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2732 if (ret != -ENOTSUP) {
2733 return ret;
2734 }
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002735 }
2736
2737 /* Fall back to bounce buffer if write zeroes is unsupported */
2738 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2739 iov.iov_base = qemu_blockalign(bs, iov.iov_len);
2740 memset(iov.iov_base, 0, iov.iov_len);
2741 qemu_iovec_init_external(&qiov, &iov, 1);
2742
2743 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, &qiov);
2744
2745 qemu_vfree(iov.iov_base);
2746 return ret;
2747}
2748
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002749/*
2750 * Handle a write request in coroutine context
2751 */
2752static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002753 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2754 BdrvRequestFlags flags)
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002755{
2756 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002757 BdrvTrackedRequest req;
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002758 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002759
2760 if (!bs->drv) {
2761 return -ENOMEDIUM;
2762 }
2763 if (bs->read_only) {
2764 return -EACCES;
2765 }
2766 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2767 return -EIO;
2768 }
2769
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002770 if (bs->copy_on_read_in_flight) {
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002771 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2772 }
2773
BenoƮt Canetcc0681c2013-09-02 14:14:39 +02002774 /* throttling disk I/O */
2775 if (bs->io_limits_enabled) {
2776 bdrv_io_limits_intercept(bs, nb_sectors, true);
2777 }
2778
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002779 tracked_request_begin(&req, bs, sector_num, nb_sectors, true);
2780
Stefan Hajnoczid616b222013-06-24 17:13:10 +02002781 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, &req);
2782
2783 if (ret < 0) {
2784 /* Do nothing, write notifier decided to fail this request */
2785 } else if (flags & BDRV_REQ_ZERO_WRITE) {
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002786 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors);
2787 } else {
2788 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
2789 }
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002790
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002791 if (ret == 0 && !bs->enable_write_cache) {
2792 ret = bdrv_co_flush(bs);
2793 }
2794
Kevin Wolfda1fa912011-07-14 17:27:13 +02002795 if (bs->dirty_bitmap) {
Paolo Bonzini1755da12012-10-18 16:49:18 +02002796 bdrv_set_dirty(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02002797 }
2798
2799 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2800 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2801 }
Paolo Bonzinidf2a6f22013-09-04 19:00:21 +02002802 if (bs->growable && ret >= 0) {
2803 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
2804 }
Kevin Wolfda1fa912011-07-14 17:27:13 +02002805
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002806 tracked_request_end(&req);
2807
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002808 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002809}
2810
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002811int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
2812 int nb_sectors, QEMUIOVector *qiov)
2813{
2814 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
2815
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002816 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
2817}
2818
2819int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
2820 int64_t sector_num, int nb_sectors)
2821{
2822 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2823
2824 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
2825 BDRV_REQ_ZERO_WRITE);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002826}
2827
bellard83f64092006-08-01 16:21:11 +00002828/**
bellard83f64092006-08-01 16:21:11 +00002829 * Truncate file to 'offset' bytes (needed only for file protocols)
2830 */
2831int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2832{
2833 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002834 int ret;
bellard83f64092006-08-01 16:21:11 +00002835 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002836 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00002837 if (!drv->bdrv_truncate)
2838 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02002839 if (bs->read_only)
2840 return -EACCES;
Marcelo Tosatti85916752011-01-26 12:12:35 -02002841 if (bdrv_in_use(bs))
2842 return -EBUSY;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002843 ret = drv->bdrv_truncate(bs, offset);
2844 if (ret == 0) {
2845 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
Markus Armbruster145feb12011-08-03 15:07:42 +02002846 bdrv_dev_resize_cb(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002847 }
2848 return ret;
bellard83f64092006-08-01 16:21:11 +00002849}
2850
2851/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002852 * Length of a allocated file in bytes. Sparse files are counted by actual
2853 * allocated space. Return < 0 if error or unknown.
2854 */
2855int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2856{
2857 BlockDriver *drv = bs->drv;
2858 if (!drv) {
2859 return -ENOMEDIUM;
2860 }
2861 if (drv->bdrv_get_allocated_file_size) {
2862 return drv->bdrv_get_allocated_file_size(bs);
2863 }
2864 if (bs->file) {
2865 return bdrv_get_allocated_file_size(bs->file);
2866 }
2867 return -ENOTSUP;
2868}
2869
2870/**
bellard83f64092006-08-01 16:21:11 +00002871 * Length of a file in bytes. Return < 0 if error or unknown.
2872 */
2873int64_t bdrv_getlength(BlockDriverState *bs)
2874{
2875 BlockDriver *drv = bs->drv;
2876 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002877 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002878
Kevin Wolfb94a2612013-10-29 12:18:58 +01002879 if (drv->has_variable_length) {
2880 int ret = refresh_total_sectors(bs, bs->total_sectors);
2881 if (ret < 0) {
2882 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002883 }
bellard83f64092006-08-01 16:21:11 +00002884 }
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002885 return bs->total_sectors * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00002886}
2887
bellard19cb3732006-08-19 11:45:59 +00002888/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00002889void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00002890{
bellard19cb3732006-08-19 11:45:59 +00002891 int64_t length;
2892 length = bdrv_getlength(bs);
2893 if (length < 0)
2894 length = 0;
2895 else
Jan Kiszka6ea44302009-11-30 18:21:19 +01002896 length = length >> BDRV_SECTOR_BITS;
bellard19cb3732006-08-19 11:45:59 +00002897 *nb_sectors_ptr = length;
bellardfc01f7e2003-06-30 10:03:06 +00002898}
bellardcf989512004-02-16 21:56:36 +00002899
Paolo Bonziniff06f5f2012-09-28 17:22:54 +02002900void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2901 BlockdevOnError on_write_error)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02002902{
2903 bs->on_read_error = on_read_error;
2904 bs->on_write_error = on_write_error;
2905}
2906
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +02002907BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02002908{
2909 return is_read ? bs->on_read_error : bs->on_write_error;
2910}
2911
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002912BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2913{
2914 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2915
2916 switch (on_err) {
2917 case BLOCKDEV_ON_ERROR_ENOSPC:
2918 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
2919 case BLOCKDEV_ON_ERROR_STOP:
2920 return BDRV_ACTION_STOP;
2921 case BLOCKDEV_ON_ERROR_REPORT:
2922 return BDRV_ACTION_REPORT;
2923 case BLOCKDEV_ON_ERROR_IGNORE:
2924 return BDRV_ACTION_IGNORE;
2925 default:
2926 abort();
2927 }
2928}
2929
2930/* This is done by device models because, while the block layer knows
2931 * about the error, it does not know whether an operation comes from
2932 * the device or the block layer (from a job, for example).
2933 */
2934void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2935 bool is_read, int error)
2936{
2937 assert(error >= 0);
Paolo Bonzini32c81a42012-09-28 17:22:58 +02002938 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002939 if (action == BDRV_ACTION_STOP) {
2940 vm_stop(RUN_STATE_IO_ERROR);
2941 bdrv_iostatus_set_err(bs, error);
2942 }
2943}
2944
bellardb3380822004-03-14 21:38:54 +00002945int bdrv_is_read_only(BlockDriverState *bs)
2946{
2947 return bs->read_only;
2948}
2949
ths985a03b2007-12-24 16:10:43 +00002950int bdrv_is_sg(BlockDriverState *bs)
2951{
2952 return bs->sg;
2953}
2954
Christoph Hellwige900a7b2009-09-04 19:01:15 +02002955int bdrv_enable_write_cache(BlockDriverState *bs)
2956{
2957 return bs->enable_write_cache;
2958}
2959
Paolo Bonzini425b0142012-06-06 00:04:52 +02002960void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2961{
2962 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04002963
2964 /* so a reopen() will preserve wce */
2965 if (wce) {
2966 bs->open_flags |= BDRV_O_CACHE_WB;
2967 } else {
2968 bs->open_flags &= ~BDRV_O_CACHE_WB;
2969 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02002970}
2971
bellardea2384d2004-08-01 21:59:26 +00002972int bdrv_is_encrypted(BlockDriverState *bs)
2973{
2974 if (bs->backing_hd && bs->backing_hd->encrypted)
2975 return 1;
2976 return bs->encrypted;
2977}
2978
aliguoric0f4ce72009-03-05 23:01:01 +00002979int bdrv_key_required(BlockDriverState *bs)
2980{
2981 BlockDriverState *backing_hd = bs->backing_hd;
2982
2983 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2984 return 1;
2985 return (bs->encrypted && !bs->valid_key);
2986}
2987
bellardea2384d2004-08-01 21:59:26 +00002988int bdrv_set_key(BlockDriverState *bs, const char *key)
2989{
2990 int ret;
2991 if (bs->backing_hd && bs->backing_hd->encrypted) {
2992 ret = bdrv_set_key(bs->backing_hd, key);
2993 if (ret < 0)
2994 return ret;
2995 if (!bs->encrypted)
2996 return 0;
2997 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02002998 if (!bs->encrypted) {
2999 return -EINVAL;
3000 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3001 return -ENOMEDIUM;
3002 }
aliguoric0f4ce72009-03-05 23:01:01 +00003003 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00003004 if (ret < 0) {
3005 bs->valid_key = 0;
3006 } else if (!bs->valid_key) {
3007 bs->valid_key = 1;
3008 /* call the change callback now, we skipped it on open */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02003009 bdrv_dev_change_media_cb(bs, true);
aliguoribb5fc202009-03-05 23:01:15 +00003010 }
aliguoric0f4ce72009-03-05 23:01:01 +00003011 return ret;
bellardea2384d2004-08-01 21:59:26 +00003012}
3013
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003014const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00003015{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003016 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00003017}
3018
ths5fafdf22007-09-16 21:08:06 +00003019void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00003020 void *opaque)
3021{
3022 BlockDriver *drv;
3023
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01003024 QLIST_FOREACH(drv, &bdrv_drivers, list) {
bellardea2384d2004-08-01 21:59:26 +00003025 it(opaque, drv->format_name);
3026 }
3027}
3028
bellardb3380822004-03-14 21:38:54 +00003029BlockDriverState *bdrv_find(const char *name)
3030{
3031 BlockDriverState *bs;
3032
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003033 QTAILQ_FOREACH(bs, &bdrv_states, list) {
3034 if (!strcmp(name, bs->device_name)) {
bellardb3380822004-03-14 21:38:54 +00003035 return bs;
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003036 }
bellardb3380822004-03-14 21:38:54 +00003037 }
3038 return NULL;
3039}
3040
Markus Armbruster2f399b02010-06-02 18:55:20 +02003041BlockDriverState *bdrv_next(BlockDriverState *bs)
3042{
3043 if (!bs) {
3044 return QTAILQ_FIRST(&bdrv_states);
3045 }
3046 return QTAILQ_NEXT(bs, list);
3047}
3048
aliguori51de9762009-03-05 23:00:43 +00003049void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
bellard81d09122004-07-14 17:21:37 +00003050{
3051 BlockDriverState *bs;
3052
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003053 QTAILQ_FOREACH(bs, &bdrv_states, list) {
aliguori51de9762009-03-05 23:00:43 +00003054 it(opaque, bs);
bellard81d09122004-07-14 17:21:37 +00003055 }
3056}
3057
bellardea2384d2004-08-01 21:59:26 +00003058const char *bdrv_get_device_name(BlockDriverState *bs)
3059{
3060 return bs->device_name;
3061}
3062
Markus Armbrusterc8433282012-06-05 16:49:24 +02003063int bdrv_get_flags(BlockDriverState *bs)
3064{
3065 return bs->open_flags;
3066}
3067
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003068int bdrv_flush_all(void)
aliguoric6ca28d2008-10-06 13:55:43 +00003069{
3070 BlockDriverState *bs;
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003071 int result = 0;
aliguoric6ca28d2008-10-06 13:55:43 +00003072
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003073 QTAILQ_FOREACH(bs, &bdrv_states, list) {
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003074 int ret = bdrv_flush(bs);
3075 if (ret < 0 && !result) {
3076 result = ret;
3077 }
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003078 }
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003079
3080 return result;
aliguoric6ca28d2008-10-06 13:55:43 +00003081}
3082
Peter Lieven3ac21622013-06-28 12:47:42 +02003083int bdrv_has_zero_init_1(BlockDriverState *bs)
3084{
3085 return 1;
3086}
3087
Kevin Wolff2feebb2010-04-14 17:30:35 +02003088int bdrv_has_zero_init(BlockDriverState *bs)
3089{
3090 assert(bs->drv);
3091
Paolo Bonzini11212d82013-09-04 19:00:27 +02003092 /* If BS is a copy on write image, it is initialized to
3093 the contents of the base image, which may not be zeroes. */
3094 if (bs->backing_hd) {
3095 return 0;
3096 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02003097 if (bs->drv->bdrv_has_zero_init) {
3098 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02003099 }
3100
Peter Lieven3ac21622013-06-28 12:47:42 +02003101 /* safe default */
3102 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02003103}
3104
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003105typedef struct BdrvCoGetBlockStatusData {
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003106 BlockDriverState *bs;
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +01003107 BlockDriverState *base;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003108 int64_t sector_num;
3109 int nb_sectors;
3110 int *pnum;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003111 int64_t ret;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003112 bool done;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003113} BdrvCoGetBlockStatusData;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003114
thsf58c7b32008-06-05 21:53:49 +00003115/*
3116 * Returns true iff the specified sector is present in the disk image. Drivers
3117 * not implementing the functionality are assumed to not support backing files,
3118 * hence all their sectors are reported as allocated.
3119 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003120 * If 'sector_num' is beyond the end of the disk image the return value is 0
3121 * and 'pnum' is set to 0.
3122 *
thsf58c7b32008-06-05 21:53:49 +00003123 * 'pnum' is set to the number of sectors (including and immediately following
3124 * the specified sector) that are known to be in the same
3125 * allocated/unallocated state.
3126 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003127 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3128 * beyond the end of the disk image it will be clamped.
thsf58c7b32008-06-05 21:53:49 +00003129 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003130static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3131 int64_t sector_num,
3132 int nb_sectors, int *pnum)
thsf58c7b32008-06-05 21:53:49 +00003133{
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003134 int64_t length;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003135 int64_t n;
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003136 int64_t ret, ret2;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003137
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003138 length = bdrv_getlength(bs);
3139 if (length < 0) {
3140 return length;
3141 }
3142
3143 if (sector_num >= (length >> BDRV_SECTOR_BITS)) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003144 *pnum = 0;
3145 return 0;
3146 }
3147
3148 n = bs->total_sectors - sector_num;
3149 if (n < nb_sectors) {
3150 nb_sectors = n;
3151 }
3152
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003153 if (!bs->drv->bdrv_co_get_block_status) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003154 *pnum = nb_sectors;
Paolo Bonzini918e92d2013-09-04 19:00:37 +02003155 ret = BDRV_BLOCK_DATA;
3156 if (bs->drv->protocol_name) {
3157 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
3158 }
3159 return ret;
thsf58c7b32008-06-05 21:53:49 +00003160 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003161
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003162 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
3163 if (ret < 0) {
Peter Lieven3e0a2332013-09-24 15:35:08 +02003164 *pnum = 0;
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003165 return ret;
3166 }
3167
Peter Lieven92bc50a2013-10-08 14:43:14 +02003168 if (ret & BDRV_BLOCK_RAW) {
3169 assert(ret & BDRV_BLOCK_OFFSET_VALID);
3170 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3171 *pnum, pnum);
3172 }
3173
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003174 if (!(ret & BDRV_BLOCK_DATA)) {
3175 if (bdrv_has_zero_init(bs)) {
3176 ret |= BDRV_BLOCK_ZERO;
Peter Lieven1f9db222013-09-24 15:35:09 +02003177 } else if (bs->backing_hd) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003178 BlockDriverState *bs2 = bs->backing_hd;
3179 int64_t length2 = bdrv_getlength(bs2);
3180 if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {
3181 ret |= BDRV_BLOCK_ZERO;
3182 }
3183 }
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003184 }
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003185
3186 if (bs->file &&
3187 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
3188 (ret & BDRV_BLOCK_OFFSET_VALID)) {
3189 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3190 *pnum, pnum);
3191 if (ret2 >= 0) {
3192 /* Ignore errors. This is just providing extra information, it
3193 * is useful but not necessary.
3194 */
3195 ret |= (ret2 & BDRV_BLOCK_ZERO);
3196 }
3197 }
3198
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003199 return ret;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003200}
3201
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003202/* Coroutine wrapper for bdrv_get_block_status() */
3203static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003204{
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003205 BdrvCoGetBlockStatusData *data = opaque;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003206 BlockDriverState *bs = data->bs;
3207
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003208 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
3209 data->pnum);
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003210 data->done = true;
3211}
3212
3213/*
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003214 * Synchronous wrapper around bdrv_co_get_block_status().
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003215 *
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003216 * See bdrv_co_get_block_status() for details.
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003217 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003218int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
3219 int nb_sectors, int *pnum)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00003220{
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003221 Coroutine *co;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003222 BdrvCoGetBlockStatusData data = {
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003223 .bs = bs,
3224 .sector_num = sector_num,
3225 .nb_sectors = nb_sectors,
3226 .pnum = pnum,
3227 .done = false,
3228 };
3229
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003230 if (qemu_in_coroutine()) {
3231 /* Fast-path if already in coroutine context */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003232 bdrv_get_block_status_co_entry(&data);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003233 } else {
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003234 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003235 qemu_coroutine_enter(co, &data);
3236 while (!data.done) {
3237 qemu_aio_wait();
3238 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003239 }
3240 return data.ret;
thsf58c7b32008-06-05 21:53:49 +00003241}
3242
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003243int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
3244 int nb_sectors, int *pnum)
3245{
Paolo Bonzini4333bb72013-09-04 19:00:29 +02003246 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
3247 if (ret < 0) {
3248 return ret;
3249 }
3250 return
3251 (ret & BDRV_BLOCK_DATA) ||
3252 ((ret & BDRV_BLOCK_ZERO) && !bdrv_has_zero_init(bs));
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003253}
3254
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003255/*
3256 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
3257 *
3258 * Return true if the given sector is allocated in any image between
3259 * BASE and TOP (inclusive). BASE can be NULL to check if the given
3260 * sector is allocated in any image of the chain. Return false otherwise.
3261 *
3262 * 'pnum' is set to the number of sectors (including and immediately following
3263 * the specified sector) that are known to be in the same
3264 * allocated/unallocated state.
3265 *
3266 */
Paolo Bonzini4f578632013-09-04 19:00:24 +02003267int bdrv_is_allocated_above(BlockDriverState *top,
3268 BlockDriverState *base,
3269 int64_t sector_num,
3270 int nb_sectors, int *pnum)
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003271{
3272 BlockDriverState *intermediate;
3273 int ret, n = nb_sectors;
3274
3275 intermediate = top;
3276 while (intermediate && intermediate != base) {
3277 int pnum_inter;
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003278 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
3279 &pnum_inter);
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003280 if (ret < 0) {
3281 return ret;
3282 } else if (ret) {
3283 *pnum = pnum_inter;
3284 return 1;
3285 }
3286
3287 /*
3288 * [sector_num, nb_sectors] is unallocated on top but intermediate
3289 * might have
3290 *
3291 * [sector_num+x, nr_sectors] allocated.
3292 */
Vishvananda Ishaya63ba17d2013-01-24 10:02:08 -08003293 if (n > pnum_inter &&
3294 (intermediate == top ||
3295 sector_num + pnum_inter < intermediate->total_sectors)) {
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02003296 n = pnum_inter;
3297 }
3298
3299 intermediate = intermediate->backing_hd;
3300 }
3301
3302 *pnum = n;
3303 return 0;
3304}
3305
aliguori045df332009-03-05 23:00:48 +00003306const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3307{
3308 if (bs->backing_hd && bs->backing_hd->encrypted)
3309 return bs->backing_file;
3310 else if (bs->encrypted)
3311 return bs->filename;
3312 else
3313 return NULL;
3314}
3315
ths5fafdf22007-09-16 21:08:06 +00003316void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00003317 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00003318{
Kevin Wolf3574c602011-10-26 11:02:11 +02003319 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00003320}
3321
ths5fafdf22007-09-16 21:08:06 +00003322int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellardfaea38e2006-08-05 21:31:00 +00003323 const uint8_t *buf, int nb_sectors)
3324{
3325 BlockDriver *drv = bs->drv;
3326 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003327 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003328 if (!drv->bdrv_write_compressed)
3329 return -ENOTSUP;
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02003330 if (bdrv_check_request(bs, sector_num, nb_sectors))
3331 return -EIO;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003332
Paolo Bonzini1755da12012-10-18 16:49:18 +02003333 assert(!bs->dirty_bitmap);
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003334
bellardfaea38e2006-08-05 21:31:00 +00003335 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
3336}
ths3b46e622007-09-17 08:09:54 +00003337
bellardfaea38e2006-08-05 21:31:00 +00003338int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3339{
3340 BlockDriver *drv = bs->drv;
3341 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003342 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003343 if (!drv->bdrv_get_info)
3344 return -ENOTSUP;
3345 memset(bdi, 0, sizeof(*bdi));
3346 return drv->bdrv_get_info(bs, bdi);
3347}
3348
Max Reitzeae041f2013-10-09 10:46:16 +02003349ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3350{
3351 BlockDriver *drv = bs->drv;
3352 if (drv && drv->bdrv_get_specific_info) {
3353 return drv->bdrv_get_specific_info(bs);
3354 }
3355 return NULL;
3356}
3357
Christoph Hellwig45566e92009-07-10 23:11:57 +02003358int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
3359 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00003360{
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003361 QEMUIOVector qiov;
3362 struct iovec iov = {
3363 .iov_base = (void *) buf,
3364 .iov_len = size,
3365 };
3366
3367 qemu_iovec_init_external(&qiov, &iov, 1);
3368 return bdrv_writev_vmstate(bs, &qiov, pos);
3369}
3370
3371int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
3372{
aliguori178e08a2009-04-05 19:10:55 +00003373 BlockDriver *drv = bs->drv;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003374
3375 if (!drv) {
aliguori178e08a2009-04-05 19:10:55 +00003376 return -ENOMEDIUM;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02003377 } else if (drv->bdrv_save_vmstate) {
3378 return drv->bdrv_save_vmstate(bs, qiov, pos);
3379 } else if (bs->file) {
3380 return bdrv_writev_vmstate(bs->file, qiov, pos);
3381 }
3382
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003383 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00003384}
3385
Christoph Hellwig45566e92009-07-10 23:11:57 +02003386int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
3387 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00003388{
3389 BlockDriver *drv = bs->drv;
3390 if (!drv)
3391 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003392 if (drv->bdrv_load_vmstate)
3393 return drv->bdrv_load_vmstate(bs, buf, pos, size);
3394 if (bs->file)
3395 return bdrv_load_vmstate(bs->file, buf, pos, size);
3396 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00003397}
3398
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003399void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3400{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003401 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003402 return;
3403 }
3404
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003405 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01003406}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003407
Kevin Wolf41c695c2012-12-06 14:32:58 +01003408int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3409 const char *tag)
3410{
3411 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3412 bs = bs->file;
3413 }
3414
3415 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3416 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3417 }
3418
3419 return -ENOTSUP;
3420}
3421
3422int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3423{
3424 while (bs && bs->drv && !bs->drv->bdrv_debug_resume) {
3425 bs = bs->file;
3426 }
3427
3428 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3429 return bs->drv->bdrv_debug_resume(bs, tag);
3430 }
3431
3432 return -ENOTSUP;
3433}
3434
3435bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3436{
3437 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3438 bs = bs->file;
3439 }
3440
3441 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3442 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3443 }
3444
3445 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003446}
3447
Blue Swirl199630b2010-07-25 20:49:34 +00003448int bdrv_is_snapshot(BlockDriverState *bs)
3449{
3450 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3451}
3452
Jeff Codyb1b1d782012-10-16 15:49:09 -04003453/* backing_file can either be relative, or absolute, or a protocol. If it is
3454 * relative, it must be relative to the chain. So, passing in bs->filename
3455 * from a BDS as backing_file should not be done, as that may be relative to
3456 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003457BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3458 const char *backing_file)
3459{
Jeff Codyb1b1d782012-10-16 15:49:09 -04003460 char *filename_full = NULL;
3461 char *backing_file_full = NULL;
3462 char *filename_tmp = NULL;
3463 int is_protocol = 0;
3464 BlockDriverState *curr_bs = NULL;
3465 BlockDriverState *retval = NULL;
3466
3467 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003468 return NULL;
3469 }
3470
Jeff Codyb1b1d782012-10-16 15:49:09 -04003471 filename_full = g_malloc(PATH_MAX);
3472 backing_file_full = g_malloc(PATH_MAX);
3473 filename_tmp = g_malloc(PATH_MAX);
3474
3475 is_protocol = path_has_protocol(backing_file);
3476
3477 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3478
3479 /* If either of the filename paths is actually a protocol, then
3480 * compare unmodified paths; otherwise make paths relative */
3481 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3482 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3483 retval = curr_bs->backing_hd;
3484 break;
3485 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003486 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04003487 /* If not an absolute filename path, make it relative to the current
3488 * image's filename path */
3489 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3490 backing_file);
3491
3492 /* We are going to compare absolute pathnames */
3493 if (!realpath(filename_tmp, filename_full)) {
3494 continue;
3495 }
3496
3497 /* We need to make sure the backing filename we are comparing against
3498 * is relative to the current image filename (or absolute) */
3499 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3500 curr_bs->backing_file);
3501
3502 if (!realpath(filename_tmp, backing_file_full)) {
3503 continue;
3504 }
3505
3506 if (strcmp(backing_file_full, filename_full) == 0) {
3507 retval = curr_bs->backing_hd;
3508 break;
3509 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003510 }
3511 }
3512
Jeff Codyb1b1d782012-10-16 15:49:09 -04003513 g_free(filename_full);
3514 g_free(backing_file_full);
3515 g_free(filename_tmp);
3516 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003517}
3518
BenoƮt Canetf198fd12012-08-02 10:22:47 +02003519int bdrv_get_backing_file_depth(BlockDriverState *bs)
3520{
3521 if (!bs->drv) {
3522 return 0;
3523 }
3524
3525 if (!bs->backing_hd) {
3526 return 0;
3527 }
3528
3529 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3530}
3531
Jeff Cody79fac562012-09-27 13:29:15 -04003532BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3533{
3534 BlockDriverState *curr_bs = NULL;
3535
3536 if (!bs) {
3537 return NULL;
3538 }
3539
3540 curr_bs = bs;
3541
3542 while (curr_bs->backing_hd) {
3543 curr_bs = curr_bs->backing_hd;
3544 }
3545 return curr_bs;
3546}
3547
bellard83f64092006-08-01 16:21:11 +00003548/**************************************************************/
3549/* async I/Os */
3550
aliguori3b69e4b2009-01-22 16:59:24 +00003551BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
aliguorif141eaf2009-04-07 18:43:24 +00003552 QEMUIOVector *qiov, int nb_sectors,
aliguori3b69e4b2009-01-22 16:59:24 +00003553 BlockDriverCompletionFunc *cb, void *opaque)
3554{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01003555 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
3556
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003557 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003558 cb, opaque, false);
bellard83f64092006-08-01 16:21:11 +00003559}
3560
aliguorif141eaf2009-04-07 18:43:24 +00003561BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
3562 QEMUIOVector *qiov, int nb_sectors,
3563 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00003564{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01003565 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
3566
Stefan Hajnoczi1a6e1152011-10-13 13:08:25 +01003567 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003568 cb, opaque, true);
bellard83f64092006-08-01 16:21:11 +00003569}
3570
Kevin Wolf40b4f532009-09-09 17:53:37 +02003571
3572typedef struct MultiwriteCB {
3573 int error;
3574 int num_requests;
3575 int num_callbacks;
3576 struct {
3577 BlockDriverCompletionFunc *cb;
3578 void *opaque;
3579 QEMUIOVector *free_qiov;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003580 } callbacks[];
3581} MultiwriteCB;
3582
3583static void multiwrite_user_cb(MultiwriteCB *mcb)
3584{
3585 int i;
3586
3587 for (i = 0; i < mcb->num_callbacks; i++) {
3588 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
Stefan Hajnoczi1e1ea482010-04-21 20:35:45 +01003589 if (mcb->callbacks[i].free_qiov) {
3590 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
3591 }
Anthony Liguori7267c092011-08-20 22:09:37 -05003592 g_free(mcb->callbacks[i].free_qiov);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003593 }
3594}
3595
3596static void multiwrite_cb(void *opaque, int ret)
3597{
3598 MultiwriteCB *mcb = opaque;
3599
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01003600 trace_multiwrite_cb(mcb, ret);
3601
Kevin Wolfcb6d3ca2010-04-01 22:48:44 +02003602 if (ret < 0 && !mcb->error) {
Kevin Wolf40b4f532009-09-09 17:53:37 +02003603 mcb->error = ret;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003604 }
3605
3606 mcb->num_requests--;
3607 if (mcb->num_requests == 0) {
Kevin Wolfde189a12010-07-01 16:08:51 +02003608 multiwrite_user_cb(mcb);
Anthony Liguori7267c092011-08-20 22:09:37 -05003609 g_free(mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003610 }
3611}
3612
3613static int multiwrite_req_compare(const void *a, const void *b)
3614{
Christoph Hellwig77be4362010-05-19 20:53:10 +02003615 const BlockRequest *req1 = a, *req2 = b;
3616
3617 /*
3618 * Note that we can't simply subtract req2->sector from req1->sector
3619 * here as that could overflow the return value.
3620 */
3621 if (req1->sector > req2->sector) {
3622 return 1;
3623 } else if (req1->sector < req2->sector) {
3624 return -1;
3625 } else {
3626 return 0;
3627 }
Kevin Wolf40b4f532009-09-09 17:53:37 +02003628}
3629
3630/*
3631 * Takes a bunch of requests and tries to merge them. Returns the number of
3632 * requests that remain after merging.
3633 */
3634static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
3635 int num_reqs, MultiwriteCB *mcb)
3636{
3637 int i, outidx;
3638
3639 // Sort requests by start sector
3640 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
3641
3642 // Check if adjacent requests touch the same clusters. If so, combine them,
3643 // filling up gaps with zero sectors.
3644 outidx = 0;
3645 for (i = 1; i < num_reqs; i++) {
3646 int merge = 0;
3647 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
3648
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01003649 // Handle exactly sequential writes and overlapping writes.
Kevin Wolf40b4f532009-09-09 17:53:37 +02003650 if (reqs[i].sector <= oldreq_last) {
3651 merge = 1;
3652 }
3653
Christoph Hellwige2a305f2010-01-26 14:49:08 +01003654 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
3655 merge = 0;
3656 }
3657
Kevin Wolf40b4f532009-09-09 17:53:37 +02003658 if (merge) {
3659 size_t size;
Anthony Liguori7267c092011-08-20 22:09:37 -05003660 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
Kevin Wolf40b4f532009-09-09 17:53:37 +02003661 qemu_iovec_init(qiov,
3662 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
3663
3664 // Add the first request to the merged one. If the requests are
3665 // overlapping, drop the last sectors of the first request.
3666 size = (reqs[i].sector - reqs[outidx].sector) << 9;
Michael Tokarev1b093c42012-03-12 21:28:06 +04003667 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003668
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01003669 // We should need to add any zeros between the two requests
3670 assert (reqs[i].sector <= oldreq_last);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003671
3672 // Add the second request
Michael Tokarev1b093c42012-03-12 21:28:06 +04003673 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003674
Kevin Wolfcbf1dff2010-05-21 11:09:42 +02003675 reqs[outidx].nb_sectors = qiov->size >> 9;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003676 reqs[outidx].qiov = qiov;
3677
3678 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
3679 } else {
3680 outidx++;
3681 reqs[outidx].sector = reqs[i].sector;
3682 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
3683 reqs[outidx].qiov = reqs[i].qiov;
3684 }
3685 }
3686
3687 return outidx + 1;
3688}
3689
3690/*
3691 * Submit multiple AIO write requests at once.
3692 *
3693 * On success, the function returns 0 and all requests in the reqs array have
3694 * been submitted. In error case this function returns -1, and any of the
3695 * requests may or may not be submitted yet. In particular, this means that the
3696 * callback will be called for some of the requests, for others it won't. The
3697 * caller must check the error field of the BlockRequest to wait for the right
3698 * callbacks (if error != 0, no callback will be called).
3699 *
3700 * The implementation may modify the contents of the reqs array, e.g. to merge
3701 * requests. However, the fields opaque and error are left unmodified as they
3702 * are used to signal failure for a single request to the caller.
3703 */
3704int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
3705{
Kevin Wolf40b4f532009-09-09 17:53:37 +02003706 MultiwriteCB *mcb;
3707 int i;
3708
Ryan Harper301db7c2011-03-07 10:01:04 -06003709 /* don't submit writes if we don't have a medium */
3710 if (bs->drv == NULL) {
3711 for (i = 0; i < num_reqs; i++) {
3712 reqs[i].error = -ENOMEDIUM;
3713 }
3714 return -1;
3715 }
3716
Kevin Wolf40b4f532009-09-09 17:53:37 +02003717 if (num_reqs == 0) {
3718 return 0;
3719 }
3720
3721 // Create MultiwriteCB structure
Anthony Liguori7267c092011-08-20 22:09:37 -05003722 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
Kevin Wolf40b4f532009-09-09 17:53:37 +02003723 mcb->num_requests = 0;
3724 mcb->num_callbacks = num_reqs;
3725
3726 for (i = 0; i < num_reqs; i++) {
3727 mcb->callbacks[i].cb = reqs[i].cb;
3728 mcb->callbacks[i].opaque = reqs[i].opaque;
3729 }
3730
3731 // Check for mergable requests
3732 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
3733
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01003734 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
3735
Paolo Bonzinidf9309f2011-11-14 17:50:50 +01003736 /* Run the aio requests. */
3737 mcb->num_requests = num_reqs;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003738 for (i = 0; i < num_reqs; i++) {
Paolo Bonziniad54ae82011-11-30 09:12:30 +01003739 bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
Kevin Wolf40b4f532009-09-09 17:53:37 +02003740 reqs[i].nb_sectors, multiwrite_cb, mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003741 }
3742
3743 return 0;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003744}
3745
bellard83f64092006-08-01 16:21:11 +00003746void bdrv_aio_cancel(BlockDriverAIOCB *acb)
pbrookce1a14d2006-08-07 02:38:06 +00003747{
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003748 acb->aiocb_info->cancel(acb);
bellard83f64092006-08-01 16:21:11 +00003749}
3750
3751/**************************************************************/
3752/* async block device emulation */
3753
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003754typedef struct BlockDriverAIOCBSync {
3755 BlockDriverAIOCB common;
3756 QEMUBH *bh;
3757 int ret;
3758 /* vector translation state */
3759 QEMUIOVector *qiov;
3760 uint8_t *bounce;
3761 int is_write;
3762} BlockDriverAIOCBSync;
3763
3764static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
3765{
Kevin Wolfb666d232010-05-05 11:44:39 +02003766 BlockDriverAIOCBSync *acb =
3767 container_of(blockacb, BlockDriverAIOCBSync, common);
Dor Laor6a7ad292009-06-01 12:07:23 +03003768 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03003769 acb->bh = NULL;
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003770 qemu_aio_release(acb);
3771}
3772
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003773static const AIOCBInfo bdrv_em_aiocb_info = {
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003774 .aiocb_size = sizeof(BlockDriverAIOCBSync),
3775 .cancel = bdrv_aio_cancel_em,
3776};
3777
bellard83f64092006-08-01 16:21:11 +00003778static void bdrv_aio_bh_cb(void *opaque)
bellardbeac80c2006-06-26 20:08:57 +00003779{
pbrookce1a14d2006-08-07 02:38:06 +00003780 BlockDriverAIOCBSync *acb = opaque;
aliguorif141eaf2009-04-07 18:43:24 +00003781
aliguorif141eaf2009-04-07 18:43:24 +00003782 if (!acb->is_write)
Michael Tokarev03396142012-06-07 20:17:55 +04003783 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
aliguoriceb42de2009-04-07 18:43:28 +00003784 qemu_vfree(acb->bounce);
pbrookce1a14d2006-08-07 02:38:06 +00003785 acb->common.cb(acb->common.opaque, acb->ret);
Dor Laor6a7ad292009-06-01 12:07:23 +03003786 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03003787 acb->bh = NULL;
pbrookce1a14d2006-08-07 02:38:06 +00003788 qemu_aio_release(acb);
bellardbeac80c2006-06-26 20:08:57 +00003789}
bellardbeac80c2006-06-26 20:08:57 +00003790
aliguorif141eaf2009-04-07 18:43:24 +00003791static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
3792 int64_t sector_num,
3793 QEMUIOVector *qiov,
3794 int nb_sectors,
3795 BlockDriverCompletionFunc *cb,
3796 void *opaque,
3797 int is_write)
3798
bellardea2384d2004-08-01 21:59:26 +00003799{
pbrookce1a14d2006-08-07 02:38:06 +00003800 BlockDriverAIOCBSync *acb;
pbrookce1a14d2006-08-07 02:38:06 +00003801
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003802 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
aliguorif141eaf2009-04-07 18:43:24 +00003803 acb->is_write = is_write;
3804 acb->qiov = qiov;
aliguorie268ca52009-04-22 20:20:00 +00003805 acb->bounce = qemu_blockalign(bs, qiov->size);
Paolo Bonzini3f3aace2011-11-14 17:50:54 +01003806 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
aliguorif141eaf2009-04-07 18:43:24 +00003807
3808 if (is_write) {
Michael Tokarevd5e6b162012-06-07 20:21:06 +04003809 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01003810 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00003811 } else {
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01003812 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00003813 }
3814
pbrookce1a14d2006-08-07 02:38:06 +00003815 qemu_bh_schedule(acb->bh);
aliguorif141eaf2009-04-07 18:43:24 +00003816
pbrookce1a14d2006-08-07 02:38:06 +00003817 return &acb->common;
pbrook7a6cba62006-06-04 11:39:07 +00003818}
3819
aliguorif141eaf2009-04-07 18:43:24 +00003820static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3821 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +00003822 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00003823{
aliguorif141eaf2009-04-07 18:43:24 +00003824 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
bellard83f64092006-08-01 16:21:11 +00003825}
3826
aliguorif141eaf2009-04-07 18:43:24 +00003827static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3828 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3829 BlockDriverCompletionFunc *cb, void *opaque)
3830{
3831 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
3832}
3833
Kevin Wolf68485422011-06-30 10:05:46 +02003834
3835typedef struct BlockDriverAIOCBCoroutine {
3836 BlockDriverAIOCB common;
3837 BlockRequest req;
3838 bool is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01003839 bool *done;
Kevin Wolf68485422011-06-30 10:05:46 +02003840 QEMUBH* bh;
3841} BlockDriverAIOCBCoroutine;
3842
3843static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
3844{
Kevin Wolfd318aea2012-11-13 16:35:08 +01003845 BlockDriverAIOCBCoroutine *acb =
3846 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
3847 bool done = false;
3848
3849 acb->done = &done;
3850 while (!done) {
3851 qemu_aio_wait();
3852 }
Kevin Wolf68485422011-06-30 10:05:46 +02003853}
3854
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003855static const AIOCBInfo bdrv_em_co_aiocb_info = {
Kevin Wolf68485422011-06-30 10:05:46 +02003856 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
3857 .cancel = bdrv_aio_co_cancel_em,
3858};
3859
Paolo Bonzini35246a62011-10-14 10:41:29 +02003860static void bdrv_co_em_bh(void *opaque)
Kevin Wolf68485422011-06-30 10:05:46 +02003861{
3862 BlockDriverAIOCBCoroutine *acb = opaque;
3863
3864 acb->common.cb(acb->common.opaque, acb->req.error);
Kevin Wolfd318aea2012-11-13 16:35:08 +01003865
3866 if (acb->done) {
3867 *acb->done = true;
3868 }
3869
Kevin Wolf68485422011-06-30 10:05:46 +02003870 qemu_bh_delete(acb->bh);
3871 qemu_aio_release(acb);
3872}
3873
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003874/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3875static void coroutine_fn bdrv_co_do_rw(void *opaque)
3876{
3877 BlockDriverAIOCBCoroutine *acb = opaque;
3878 BlockDriverState *bs = acb->common.bs;
3879
3880 if (!acb->is_write) {
3881 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003882 acb->req.nb_sectors, acb->req.qiov, 0);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003883 } else {
3884 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003885 acb->req.nb_sectors, acb->req.qiov, 0);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003886 }
3887
Paolo Bonzini35246a62011-10-14 10:41:29 +02003888 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003889 qemu_bh_schedule(acb->bh);
3890}
3891
Kevin Wolf68485422011-06-30 10:05:46 +02003892static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
3893 int64_t sector_num,
3894 QEMUIOVector *qiov,
3895 int nb_sectors,
3896 BlockDriverCompletionFunc *cb,
3897 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003898 bool is_write)
Kevin Wolf68485422011-06-30 10:05:46 +02003899{
3900 Coroutine *co;
3901 BlockDriverAIOCBCoroutine *acb;
3902
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003903 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolf68485422011-06-30 10:05:46 +02003904 acb->req.sector = sector_num;
3905 acb->req.nb_sectors = nb_sectors;
3906 acb->req.qiov = qiov;
3907 acb->is_write = is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01003908 acb->done = NULL;
Kevin Wolf68485422011-06-30 10:05:46 +02003909
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003910 co = qemu_coroutine_create(bdrv_co_do_rw);
Kevin Wolf68485422011-06-30 10:05:46 +02003911 qemu_coroutine_enter(co, acb);
3912
3913 return &acb->common;
3914}
3915
Paolo Bonzini07f07612011-10-17 12:32:12 +02003916static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02003917{
Paolo Bonzini07f07612011-10-17 12:32:12 +02003918 BlockDriverAIOCBCoroutine *acb = opaque;
3919 BlockDriverState *bs = acb->common.bs;
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02003920
Paolo Bonzini07f07612011-10-17 12:32:12 +02003921 acb->req.error = bdrv_co_flush(bs);
3922 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02003923 qemu_bh_schedule(acb->bh);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02003924}
3925
Paolo Bonzini07f07612011-10-17 12:32:12 +02003926BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Alexander Graf016f5cf2010-05-26 17:51:49 +02003927 BlockDriverCompletionFunc *cb, void *opaque)
3928{
Paolo Bonzini07f07612011-10-17 12:32:12 +02003929 trace_bdrv_aio_flush(bs, opaque);
Alexander Graf016f5cf2010-05-26 17:51:49 +02003930
Paolo Bonzini07f07612011-10-17 12:32:12 +02003931 Coroutine *co;
3932 BlockDriverAIOCBCoroutine *acb;
Alexander Graf016f5cf2010-05-26 17:51:49 +02003933
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003934 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolfd318aea2012-11-13 16:35:08 +01003935 acb->done = NULL;
3936
Paolo Bonzini07f07612011-10-17 12:32:12 +02003937 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
3938 qemu_coroutine_enter(co, acb);
Alexander Graf016f5cf2010-05-26 17:51:49 +02003939
Alexander Graf016f5cf2010-05-26 17:51:49 +02003940 return &acb->common;
3941}
3942
Paolo Bonzini4265d622011-10-17 12:32:14 +02003943static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
3944{
3945 BlockDriverAIOCBCoroutine *acb = opaque;
3946 BlockDriverState *bs = acb->common.bs;
3947
3948 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
3949 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3950 qemu_bh_schedule(acb->bh);
3951}
3952
3953BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
3954 int64_t sector_num, int nb_sectors,
3955 BlockDriverCompletionFunc *cb, void *opaque)
3956{
3957 Coroutine *co;
3958 BlockDriverAIOCBCoroutine *acb;
3959
3960 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
3961
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003962 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +02003963 acb->req.sector = sector_num;
3964 acb->req.nb_sectors = nb_sectors;
Kevin Wolfd318aea2012-11-13 16:35:08 +01003965 acb->done = NULL;
Paolo Bonzini4265d622011-10-17 12:32:14 +02003966 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
3967 qemu_coroutine_enter(co, acb);
3968
3969 return &acb->common;
3970}
3971
bellardea2384d2004-08-01 21:59:26 +00003972void bdrv_init(void)
3973{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003974 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00003975}
pbrookce1a14d2006-08-07 02:38:06 +00003976
Markus Armbrustereb852012009-10-27 18:41:44 +01003977void bdrv_init_with_whitelist(void)
3978{
3979 use_bdrv_whitelist = 1;
3980 bdrv_init();
3981}
3982
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003983void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003984 BlockDriverCompletionFunc *cb, void *opaque)
aliguori6bbff9a2009-03-20 18:25:59 +00003985{
pbrookce1a14d2006-08-07 02:38:06 +00003986 BlockDriverAIOCB *acb;
3987
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003988 acb = g_slice_alloc(aiocb_info->aiocb_size);
3989 acb->aiocb_info = aiocb_info;
pbrookce1a14d2006-08-07 02:38:06 +00003990 acb->bs = bs;
3991 acb->cb = cb;
3992 acb->opaque = opaque;
3993 return acb;
3994}
3995
3996void qemu_aio_release(void *p)
3997{
Stefan Hajnoczid37c9752012-10-31 16:34:36 +01003998 BlockDriverAIOCB *acb = p;
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003999 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
pbrookce1a14d2006-08-07 02:38:06 +00004000}
bellard19cb3732006-08-19 11:45:59 +00004001
4002/**************************************************************/
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004003/* Coroutine block device emulation */
4004
4005typedef struct CoroutineIOCompletion {
4006 Coroutine *coroutine;
4007 int ret;
4008} CoroutineIOCompletion;
4009
4010static void bdrv_co_io_em_complete(void *opaque, int ret)
4011{
4012 CoroutineIOCompletion *co = opaque;
4013
4014 co->ret = ret;
4015 qemu_coroutine_enter(co->coroutine, NULL);
4016}
4017
4018static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4019 int nb_sectors, QEMUIOVector *iov,
4020 bool is_write)
4021{
4022 CoroutineIOCompletion co = {
4023 .coroutine = qemu_coroutine_self(),
4024 };
4025 BlockDriverAIOCB *acb;
4026
4027 if (is_write) {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004028 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4029 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004030 } else {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004031 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4032 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004033 }
4034
Stefan Hajnoczi59370aa2011-09-30 17:34:58 +01004035 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004036 if (!acb) {
4037 return -EIO;
4038 }
4039 qemu_coroutine_yield();
4040
4041 return co.ret;
4042}
4043
4044static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4045 int64_t sector_num, int nb_sectors,
4046 QEMUIOVector *iov)
4047{
4048 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4049}
4050
4051static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4052 int64_t sector_num, int nb_sectors,
4053 QEMUIOVector *iov)
4054{
4055 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4056}
4057
Paolo Bonzini07f07612011-10-17 12:32:12 +02004058static void coroutine_fn bdrv_flush_co_entry(void *opaque)
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004059{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004060 RwCo *rwco = opaque;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004061
Paolo Bonzini07f07612011-10-17 12:32:12 +02004062 rwco->ret = bdrv_co_flush(rwco->bs);
4063}
4064
4065int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4066{
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004067 int ret;
4068
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004069 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Paolo Bonzini07f07612011-10-17 12:32:12 +02004070 return 0;
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004071 }
4072
Kevin Wolfca716362011-11-10 18:13:59 +01004073 /* Write back cached data to the OS even with cache=unsafe */
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004074 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004075 if (bs->drv->bdrv_co_flush_to_os) {
4076 ret = bs->drv->bdrv_co_flush_to_os(bs);
4077 if (ret < 0) {
4078 return ret;
4079 }
4080 }
4081
Kevin Wolfca716362011-11-10 18:13:59 +01004082 /* But don't actually force it to the disk with cache=unsafe */
4083 if (bs->open_flags & BDRV_O_NO_FLUSH) {
Kevin Wolfd4c82322012-08-15 12:52:45 +02004084 goto flush_parent;
Kevin Wolfca716362011-11-10 18:13:59 +01004085 }
4086
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004087 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004088 if (bs->drv->bdrv_co_flush_to_disk) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004089 ret = bs->drv->bdrv_co_flush_to_disk(bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004090 } else if (bs->drv->bdrv_aio_flush) {
4091 BlockDriverAIOCB *acb;
4092 CoroutineIOCompletion co = {
4093 .coroutine = qemu_coroutine_self(),
4094 };
4095
4096 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4097 if (acb == NULL) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004098 ret = -EIO;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004099 } else {
4100 qemu_coroutine_yield();
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004101 ret = co.ret;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004102 }
Paolo Bonzini07f07612011-10-17 12:32:12 +02004103 } else {
4104 /*
4105 * Some block drivers always operate in either writethrough or unsafe
4106 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4107 * know how the server works (because the behaviour is hardcoded or
4108 * depends on server-side configuration), so we can't ensure that
4109 * everything is safe on disk. Returning an error doesn't work because
4110 * that would break guests even if the server operates in writethrough
4111 * mode.
4112 *
4113 * Let's hope the user knows what he's doing.
4114 */
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004115 ret = 0;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004116 }
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004117 if (ret < 0) {
4118 return ret;
4119 }
4120
4121 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4122 * in the case of cache=unsafe, so there are no useless flushes.
4123 */
Kevin Wolfd4c82322012-08-15 12:52:45 +02004124flush_parent:
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004125 return bdrv_co_flush(bs->file);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004126}
4127
Anthony Liguori0f154232011-11-14 15:09:45 -06004128void bdrv_invalidate_cache(BlockDriverState *bs)
4129{
4130 if (bs->drv && bs->drv->bdrv_invalidate_cache) {
4131 bs->drv->bdrv_invalidate_cache(bs);
4132 }
4133}
4134
4135void bdrv_invalidate_cache_all(void)
4136{
4137 BlockDriverState *bs;
4138
4139 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4140 bdrv_invalidate_cache(bs);
4141 }
4142}
4143
BenoƮt Canet07789262012-03-23 08:36:49 +01004144void bdrv_clear_incoming_migration_all(void)
4145{
4146 BlockDriverState *bs;
4147
4148 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4149 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
4150 }
4151}
4152
Paolo Bonzini07f07612011-10-17 12:32:12 +02004153int bdrv_flush(BlockDriverState *bs)
4154{
4155 Coroutine *co;
4156 RwCo rwco = {
4157 .bs = bs,
4158 .ret = NOT_DONE,
4159 };
4160
4161 if (qemu_in_coroutine()) {
4162 /* Fast-path if already in coroutine context */
4163 bdrv_flush_co_entry(&rwco);
4164 } else {
4165 co = qemu_coroutine_create(bdrv_flush_co_entry);
4166 qemu_coroutine_enter(co, &rwco);
4167 while (rwco.ret == NOT_DONE) {
4168 qemu_aio_wait();
4169 }
4170 }
4171
4172 return rwco.ret;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004173}
4174
Paolo Bonzini4265d622011-10-17 12:32:14 +02004175static void coroutine_fn bdrv_discard_co_entry(void *opaque)
4176{
4177 RwCo *rwco = opaque;
4178
4179 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
4180}
4181
4182int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
4183 int nb_sectors)
4184{
4185 if (!bs->drv) {
4186 return -ENOMEDIUM;
4187 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
4188 return -EIO;
4189 } else if (bs->read_only) {
4190 return -EROFS;
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004191 }
4192
4193 if (bs->dirty_bitmap) {
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004194 bdrv_reset_dirty(bs, sector_num, nb_sectors);
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004195 }
4196
Paolo Bonzini9e8f1832013-02-08 14:06:11 +01004197 /* Do nothing if disabled. */
4198 if (!(bs->open_flags & BDRV_O_UNMAP)) {
4199 return 0;
4200 }
4201
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004202 if (bs->drv->bdrv_co_discard) {
Paolo Bonzini4265d622011-10-17 12:32:14 +02004203 return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors);
4204 } else if (bs->drv->bdrv_aio_discard) {
4205 BlockDriverAIOCB *acb;
4206 CoroutineIOCompletion co = {
4207 .coroutine = qemu_coroutine_self(),
4208 };
4209
4210 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
4211 bdrv_co_io_em_complete, &co);
4212 if (acb == NULL) {
4213 return -EIO;
4214 } else {
4215 qemu_coroutine_yield();
4216 return co.ret;
4217 }
Paolo Bonzini4265d622011-10-17 12:32:14 +02004218 } else {
4219 return 0;
4220 }
4221}
4222
4223int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
4224{
4225 Coroutine *co;
4226 RwCo rwco = {
4227 .bs = bs,
4228 .sector_num = sector_num,
4229 .nb_sectors = nb_sectors,
4230 .ret = NOT_DONE,
4231 };
4232
4233 if (qemu_in_coroutine()) {
4234 /* Fast-path if already in coroutine context */
4235 bdrv_discard_co_entry(&rwco);
4236 } else {
4237 co = qemu_coroutine_create(bdrv_discard_co_entry);
4238 qemu_coroutine_enter(co, &rwco);
4239 while (rwco.ret == NOT_DONE) {
4240 qemu_aio_wait();
4241 }
4242 }
4243
4244 return rwco.ret;
4245}
4246
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004247/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00004248/* removable device support */
4249
4250/**
4251 * Return TRUE if the media is present
4252 */
4253int bdrv_is_inserted(BlockDriverState *bs)
4254{
4255 BlockDriver *drv = bs->drv;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02004256
bellard19cb3732006-08-19 11:45:59 +00004257 if (!drv)
4258 return 0;
4259 if (!drv->bdrv_is_inserted)
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02004260 return 1;
4261 return drv->bdrv_is_inserted(bs);
bellard19cb3732006-08-19 11:45:59 +00004262}
4263
4264/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02004265 * Return whether the media changed since the last call to this
4266 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00004267 */
4268int bdrv_media_changed(BlockDriverState *bs)
4269{
4270 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00004271
Markus Armbruster8e49ca42011-08-03 15:08:08 +02004272 if (drv && drv->bdrv_media_changed) {
4273 return drv->bdrv_media_changed(bs);
4274 }
4275 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00004276}
4277
4278/**
4279 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4280 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02004281void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00004282{
4283 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00004284
Markus Armbruster822e1cd2011-07-20 18:23:42 +02004285 if (drv && drv->bdrv_eject) {
4286 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00004287 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02004288
4289 if (bs->device_name[0] != '\0') {
4290 bdrv_emit_qmp_eject_event(bs, eject_flag);
4291 }
bellard19cb3732006-08-19 11:45:59 +00004292}
4293
bellard19cb3732006-08-19 11:45:59 +00004294/**
4295 * Lock or unlock the media (if it is locked, the user won't be able
4296 * to eject it manually).
4297 */
Markus Armbruster025e8492011-09-06 18:58:47 +02004298void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00004299{
4300 BlockDriver *drv = bs->drv;
4301
Markus Armbruster025e8492011-09-06 18:58:47 +02004302 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01004303
Markus Armbruster025e8492011-09-06 18:58:47 +02004304 if (drv && drv->bdrv_lock_medium) {
4305 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00004306 }
4307}
ths985a03b2007-12-24 16:10:43 +00004308
4309/* needed for generic scsi interface */
4310
4311int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
4312{
4313 BlockDriver *drv = bs->drv;
4314
4315 if (drv && drv->bdrv_ioctl)
4316 return drv->bdrv_ioctl(bs, req, buf);
4317 return -ENOTSUP;
4318}
aliguori7d780662009-03-12 19:57:08 +00004319
aliguori221f7152009-03-28 17:28:41 +00004320BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
4321 unsigned long int req, void *buf,
4322 BlockDriverCompletionFunc *cb, void *opaque)
aliguori7d780662009-03-12 19:57:08 +00004323{
aliguori221f7152009-03-28 17:28:41 +00004324 BlockDriver *drv = bs->drv;
aliguori7d780662009-03-12 19:57:08 +00004325
aliguori221f7152009-03-28 17:28:41 +00004326 if (drv && drv->bdrv_aio_ioctl)
4327 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
4328 return NULL;
aliguori7d780662009-03-12 19:57:08 +00004329}
aliguorie268ca52009-04-22 20:20:00 +00004330
Markus Armbruster7b6f9302011-09-06 18:58:56 +02004331void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
4332{
4333 bs->buffer_alignment = align;
4334}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004335
aliguorie268ca52009-04-22 20:20:00 +00004336void *qemu_blockalign(BlockDriverState *bs, size_t size)
4337{
4338 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
4339}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004340
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01004341/*
4342 * Check if all memory in this vector is sector aligned.
4343 */
4344bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
4345{
4346 int i;
4347
4348 for (i = 0; i < qiov->niov; i++) {
4349 if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {
4350 return false;
4351 }
4352 }
4353
4354 return true;
4355}
4356
Paolo Bonzini50717e92013-01-21 17:09:45 +01004357void bdrv_set_dirty_tracking(BlockDriverState *bs, int granularity)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004358{
4359 int64_t bitmap_size;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004360
Paolo Bonzini50717e92013-01-21 17:09:45 +01004361 assert((granularity & (granularity - 1)) == 0);
4362
4363 if (granularity) {
4364 granularity >>= BDRV_SECTOR_BITS;
4365 assert(!bs->dirty_bitmap);
4366 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS);
4367 bs->dirty_bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004368 } else {
Jan Kiszkac6d22832009-11-30 18:21:20 +01004369 if (bs->dirty_bitmap) {
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004370 hbitmap_free(bs->dirty_bitmap);
Jan Kiszkac6d22832009-11-30 18:21:20 +01004371 bs->dirty_bitmap = NULL;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004372 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004373 }
4374}
4375
4376int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
4377{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004378 if (bs->dirty_bitmap) {
4379 return hbitmap_get(bs->dirty_bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004380 } else {
4381 return 0;
4382 }
4383}
4384
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004385void bdrv_dirty_iter_init(BlockDriverState *bs, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02004386{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004387 hbitmap_iter_init(hbi, bs->dirty_bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02004388}
4389
4390void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
4391 int nr_sectors)
4392{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004393 hbitmap_set(bs->dirty_bitmap, cur_sector, nr_sectors);
Paolo Bonzini1755da12012-10-18 16:49:18 +02004394}
4395
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004396void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
4397 int nr_sectors)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004398{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004399 hbitmap_reset(bs->dirty_bitmap, cur_sector, nr_sectors);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004400}
Liran Schouraaa0eb72010-01-26 10:31:48 +02004401
4402int64_t bdrv_get_dirty_count(BlockDriverState *bs)
4403{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004404 if (bs->dirty_bitmap) {
Paolo Bonziniacc906c2013-01-21 17:09:44 +01004405 return hbitmap_count(bs->dirty_bitmap);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004406 } else {
4407 return 0;
4408 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02004409}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004410
Fam Zheng9fcb0252013-08-23 09:14:46 +08004411/* Get a reference to bs */
4412void bdrv_ref(BlockDriverState *bs)
4413{
4414 bs->refcnt++;
4415}
4416
4417/* Release a previously grabbed reference to bs.
4418 * If after releasing, reference count is zero, the BlockDriverState is
4419 * deleted. */
4420void bdrv_unref(BlockDriverState *bs)
4421{
4422 assert(bs->refcnt > 0);
4423 if (--bs->refcnt == 0) {
4424 bdrv_delete(bs);
4425 }
4426}
4427
Marcelo Tosattidb593f22011-01-26 12:12:34 -02004428void bdrv_set_in_use(BlockDriverState *bs, int in_use)
4429{
4430 assert(bs->in_use != in_use);
4431 bs->in_use = in_use;
4432}
4433
4434int bdrv_in_use(BlockDriverState *bs)
4435{
4436 return bs->in_use;
4437}
4438
Luiz Capitulino28a72822011-09-26 17:43:50 -03004439void bdrv_iostatus_enable(BlockDriverState *bs)
4440{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004441 bs->iostatus_enabled = true;
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004442 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004443}
4444
4445/* The I/O status is only enabled if the drive explicitly
4446 * enables it _and_ the VM is configured to stop on errors */
4447bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
4448{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004449 return (bs->iostatus_enabled &&
Paolo Bonzini92aa5c62012-09-28 17:22:55 +02004450 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
4451 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
4452 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
Luiz Capitulino28a72822011-09-26 17:43:50 -03004453}
4454
4455void bdrv_iostatus_disable(BlockDriverState *bs)
4456{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004457 bs->iostatus_enabled = false;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004458}
4459
4460void bdrv_iostatus_reset(BlockDriverState *bs)
4461{
4462 if (bdrv_iostatus_is_enabled(bs)) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004463 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Paolo Bonzini3bd293c2012-10-18 16:49:27 +02004464 if (bs->job) {
4465 block_job_iostatus_reset(bs->job);
4466 }
Luiz Capitulino28a72822011-09-26 17:43:50 -03004467 }
4468}
4469
Luiz Capitulino28a72822011-09-26 17:43:50 -03004470void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
4471{
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02004472 assert(bdrv_iostatus_is_enabled(bs));
4473 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004474 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
4475 BLOCK_DEVICE_IO_STATUS_FAILED;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004476 }
4477}
4478
Christoph Hellwiga597e792011-08-25 08:26:01 +02004479void
4480bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
4481 enum BlockAcctType type)
4482{
4483 assert(type < BDRV_MAX_IOTYPE);
4484
4485 cookie->bytes = bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02004486 cookie->start_time_ns = get_clock();
Christoph Hellwiga597e792011-08-25 08:26:01 +02004487 cookie->type = type;
4488}
4489
4490void
4491bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
4492{
4493 assert(cookie->type < BDRV_MAX_IOTYPE);
4494
4495 bs->nr_bytes[cookie->type] += cookie->bytes;
4496 bs->nr_ops[cookie->type]++;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02004497 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +02004498}
4499
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004500void bdrv_img_create(const char *filename, const char *fmt,
4501 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01004502 char *options, uint64_t img_size, int flags,
4503 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004504{
4505 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolfd2208942011-06-01 14:03:31 +02004506 QEMUOptionParameter *backing_fmt, *backing_file, *size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004507 BlockDriverState *bs = NULL;
4508 BlockDriver *drv, *proto_drv;
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00004509 BlockDriver *backing_drv = NULL;
Max Reitzcc84d902013-09-06 17:14:26 +02004510 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004511 int ret = 0;
4512
4513 /* Find driver and parse its options */
4514 drv = bdrv_find_format(fmt);
4515 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004516 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004517 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004518 }
4519
Kevin Wolf98289622013-07-10 15:47:39 +02004520 proto_drv = bdrv_find_protocol(filename, true);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004521 if (!proto_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004522 error_setg(errp, "Unknown protocol '%s'", filename);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004523 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004524 }
4525
4526 create_options = append_option_parameters(create_options,
4527 drv->create_options);
4528 create_options = append_option_parameters(create_options,
4529 proto_drv->create_options);
4530
4531 /* Create parameter list with default values */
4532 param = parse_option_parameters("", create_options, param);
4533
4534 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
4535
4536 /* Parse -o options */
4537 if (options) {
4538 param = parse_option_parameters(options, create_options, param);
4539 if (param == NULL) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004540 error_setg(errp, "Invalid options for file format '%s'.", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004541 goto out;
4542 }
4543 }
4544
4545 if (base_filename) {
4546 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
4547 base_filename)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004548 error_setg(errp, "Backing file not supported for file format '%s'",
4549 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004550 goto out;
4551 }
4552 }
4553
4554 if (base_fmt) {
4555 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004556 error_setg(errp, "Backing file format not supported for file "
4557 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004558 goto out;
4559 }
4560 }
4561
Jes Sorensen792da932010-12-16 13:52:17 +01004562 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
4563 if (backing_file && backing_file->value.s) {
4564 if (!strcmp(filename, backing_file->value.s)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004565 error_setg(errp, "Error: Trying to create an image with the "
4566 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01004567 goto out;
4568 }
4569 }
4570
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004571 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
4572 if (backing_fmt && backing_fmt->value.s) {
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00004573 backing_drv = bdrv_find_format(backing_fmt->value.s);
4574 if (!backing_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004575 error_setg(errp, "Unknown backing file format '%s'",
4576 backing_fmt->value.s);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004577 goto out;
4578 }
4579 }
4580
4581 // The size for the image must always be specified, with one exception:
4582 // If we are using a backing file, we can obtain the size from there
Kevin Wolfd2208942011-06-01 14:03:31 +02004583 size = get_option_parameter(param, BLOCK_OPT_SIZE);
4584 if (size && size->value.n == -1) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004585 if (backing_file && backing_file->value.s) {
4586 uint64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004587 char buf[32];
Paolo Bonzini63090da2012-04-12 14:01:03 +02004588 int back_flags;
4589
4590 /* backing files always opened read-only */
4591 back_flags =
4592 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004593
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004594 bs = bdrv_new("");
4595
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01004596 ret = bdrv_open(bs, backing_file->value.s, NULL, back_flags,
Max Reitzcc84d902013-09-06 17:14:26 +02004597 backing_drv, &local_err);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004598 if (ret < 0) {
Max Reitzcc84d902013-09-06 17:14:26 +02004599 error_setg_errno(errp, -ret, "Could not open '%s': %s",
4600 backing_file->value.s,
4601 error_get_pretty(local_err));
4602 error_free(local_err);
4603 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004604 goto out;
4605 }
4606 bdrv_get_geometry(bs, &size);
4607 size *= 512;
4608
4609 snprintf(buf, sizeof(buf), "%" PRId64, size);
4610 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
4611 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004612 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004613 goto out;
4614 }
4615 }
4616
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01004617 if (!quiet) {
4618 printf("Formatting '%s', fmt=%s ", filename, fmt);
4619 print_option_parameters(param);
4620 puts("");
4621 }
Max Reitzcc84d902013-09-06 17:14:26 +02004622 ret = bdrv_create(drv, filename, param, &local_err);
4623 if (ret == -EFBIG) {
4624 /* This is generally a better message than whatever the driver would
4625 * deliver (especially because of the cluster_size_hint), since that
4626 * is most probably not much different from "image too large". */
4627 const char *cluster_size_hint = "";
4628 if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
4629 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004630 }
Max Reitzcc84d902013-09-06 17:14:26 +02004631 error_setg(errp, "The image size is too large for file format '%s'"
4632 "%s", fmt, cluster_size_hint);
4633 error_free(local_err);
4634 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004635 }
4636
4637out:
4638 free_option_parameters(create_options);
4639 free_option_parameters(param);
4640
4641 if (bs) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08004642 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004643 }
Max Reitzcc84d902013-09-06 17:14:26 +02004644 if (error_is_set(&local_err)) {
4645 error_propagate(errp, local_err);
4646 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004647}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01004648
4649AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4650{
4651 /* Currently BlockDriverState always uses the main loop AioContext */
4652 return qemu_get_aio_context();
4653}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02004654
4655void bdrv_add_before_write_notifier(BlockDriverState *bs,
4656 NotifierWithReturn *notifier)
4657{
4658 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
4659}
Max Reitz6f176b42013-09-03 10:09:50 +02004660
4661int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options)
4662{
4663 if (bs->drv->bdrv_amend_options == NULL) {
4664 return -ENOTSUP;
4665 }
4666 return bs->drv->bdrv_amend_options(bs, options);
4667}
BenoƮt Canetf6186f42013-10-02 14:33:48 +02004668
4669ExtSnapshotPerm bdrv_check_ext_snapshot(BlockDriverState *bs)
4670{
4671 if (bs->drv->bdrv_check_ext_snapshot) {
4672 return bs->drv->bdrv_check_ext_snapshot(bs);
4673 }
4674
4675 if (bs->file && bs->file->drv && bs->file->drv->bdrv_check_ext_snapshot) {
4676 return bs->file->drv->bdrv_check_ext_snapshot(bs);
4677 }
4678
4679 /* external snapshots are allowed by default */
4680 return EXT_SNAPSHOT_ALLOWED;
4681}
4682
4683ExtSnapshotPerm bdrv_check_ext_snapshot_forbidden(BlockDriverState *bs)
4684{
4685 return EXT_SNAPSHOT_FORBIDDEN;
4686}