blob: cb5d7aebe68b95c63b6d43e27b95e25f6e23e95e [file] [log] [blame]
bellardfc01f7e2003-06-30 10:03:06 +00001/*
2 * QEMU System Emulator block driver
ths5fafdf22007-09-16 21:08:06 +00003 *
bellardfc01f7e2003-06-30 10:03:06 +00004 * Copyright (c) 2003 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellardfc01f7e2003-06-30 10:03:06 +00006 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
blueswir13990d092008-12-05 17:53:21 +000024#include "config-host.h"
pbrookfaf07962007-11-11 02:51:17 +000025#include "qemu-common.h"
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +010026#include "trace.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010027#include "block/block_int.h"
28#include "block/blockjob.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010029#include "qemu/error-report.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010030#include "qemu/module.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010031#include "qapi/qmp/qerror.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010032#include "qapi/qmp/qjson.h"
Markus Armbrusterbfb197e2014-10-07 13:59:11 +020033#include "sysemu/block-backend.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010034#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010035#include "qemu/notify.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010036#include "block/coroutine.h"
Benoît Canetc13163f2014-01-23 21:31:34 +010037#include "block/qapi.h"
Luiz Capitulinob2023812011-09-21 17:16:47 -030038#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010039#include "qemu/timer.h"
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +020040#include "qapi-event.h"
Alberto Garciadb628332015-06-08 18:17:45 +020041#include "block/throttle-groups.h"
bellardfc01f7e2003-06-30 10:03:06 +000042
Juan Quintela71e72a12009-07-27 16:12:56 +020043#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000044#include <sys/types.h>
45#include <sys/stat.h>
46#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000047#include <sys/queue.h>
blueswir1c5e97232009-03-07 20:06:23 +000048#ifndef __DragonFly__
bellard7674e7b2005-04-26 21:59:26 +000049#include <sys/disk.h>
50#endif
blueswir1c5e97232009-03-07 20:06:23 +000051#endif
bellard7674e7b2005-04-26 21:59:26 +000052
aliguori49dc7682009-03-08 16:26:59 +000053#ifdef _WIN32
54#include <windows.h>
55#endif
56
John Snow9bd2b082015-04-17 19:49:57 -040057/**
58 * A BdrvDirtyBitmap can be in three possible states:
59 * (1) successor is NULL and disabled is false: full r/w mode
60 * (2) successor is NULL and disabled is true: read only mode ("disabled")
61 * (3) successor is set: frozen mode.
62 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
63 * or enabled. A frozen bitmap can only abdicate() or reclaim().
64 */
Fam Zhenge4654d22013-11-13 18:29:43 +080065struct BdrvDirtyBitmap {
John Snowaa0c7ca2015-04-17 19:50:01 -040066 HBitmap *bitmap; /* Dirty sector bitmap implementation */
67 BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
68 char *name; /* Optional non-empty unique ID */
69 int64_t size; /* Size of the bitmap (Number of sectors) */
70 bool disabled; /* Bitmap is read-only */
Fam Zhenge4654d22013-11-13 18:29:43 +080071 QLIST_ENTRY(BdrvDirtyBitmap) list;
72};
73
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010074#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
75
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +010076static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
77 QTAILQ_HEAD_INITIALIZER(bdrv_states);
blueswir17ee930d2008-09-17 19:04:14 +000078
Benoît Canetdc364f42014-01-23 21:31:32 +010079static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
80 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
81
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010082static QLIST_HEAD(, BlockDriver) bdrv_drivers =
83 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +000084
Kevin Wolff3930ed2015-04-08 13:43:47 +020085static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
86 const char *reference, QDict *options, int flags,
87 BlockDriverState *parent,
88 const BdrvChildRole *child_role,
89 BlockDriver *drv, Error **errp);
90
John Snowce1ffea2015-04-17 19:50:03 -040091static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
Markus Armbrustereb852012009-10-27 18:41:44 +010092/* If non-zero, use only whitelisted block drivers */
93static int use_bdrv_whitelist;
94
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +000095#ifdef _WIN32
96static int is_windows_drive_prefix(const char *filename)
97{
98 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
99 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
100 filename[1] == ':');
101}
102
103int is_windows_drive(const char *filename)
104{
105 if (is_windows_drive_prefix(filename) &&
106 filename[2] == '\0')
107 return 1;
108 if (strstart(filename, "\\\\.\\", NULL) ||
109 strstart(filename, "//./", NULL))
110 return 1;
111 return 0;
112}
113#endif
114
Kevin Wolf339064d2013-11-28 10:23:32 +0100115size_t bdrv_opt_mem_align(BlockDriverState *bs)
116{
117 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300118 /* page size or 4k (hdd sector size) should be on the safe side */
119 return MAX(4096, getpagesize());
Kevin Wolf339064d2013-11-28 10:23:32 +0100120 }
121
122 return bs->bl.opt_mem_alignment;
123}
124
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300125size_t bdrv_min_mem_align(BlockDriverState *bs)
126{
127 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300128 /* page size or 4k (hdd sector size) should be on the safe side */
129 return MAX(4096, getpagesize());
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300130 }
131
132 return bs->bl.min_mem_alignment;
133}
134
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000135/* check if the path starts with "<protocol>:" */
Max Reitz5c984152014-12-03 14:57:22 +0100136int path_has_protocol(const char *path)
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000137{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200138 const char *p;
139
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000140#ifdef _WIN32
141 if (is_windows_drive(path) ||
142 is_windows_drive_prefix(path)) {
143 return 0;
144 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200145 p = path + strcspn(path, ":/\\");
146#else
147 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000148#endif
149
Paolo Bonzini947995c2012-05-08 16:51:48 +0200150 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000151}
152
bellard83f64092006-08-01 16:21:11 +0000153int path_is_absolute(const char *path)
154{
bellard21664422007-01-07 18:22:37 +0000155#ifdef _WIN32
156 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200157 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000158 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200159 }
160 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000161#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200162 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000163#endif
bellard83f64092006-08-01 16:21:11 +0000164}
165
166/* if filename is absolute, just copy it to dest. Otherwise, build a
167 path to it by considering it is relative to base_path. URL are
168 supported. */
169void path_combine(char *dest, int dest_size,
170 const char *base_path,
171 const char *filename)
172{
173 const char *p, *p1;
174 int len;
175
176 if (dest_size <= 0)
177 return;
178 if (path_is_absolute(filename)) {
179 pstrcpy(dest, dest_size, filename);
180 } else {
181 p = strchr(base_path, ':');
182 if (p)
183 p++;
184 else
185 p = base_path;
bellard3b9f94e2007-01-07 17:27:07 +0000186 p1 = strrchr(base_path, '/');
187#ifdef _WIN32
188 {
189 const char *p2;
190 p2 = strrchr(base_path, '\\');
191 if (!p1 || p2 > p1)
192 p1 = p2;
193 }
194#endif
bellard83f64092006-08-01 16:21:11 +0000195 if (p1)
196 p1++;
197 else
198 p1 = base_path;
199 if (p1 > p)
200 p = p1;
201 len = p - base_path;
202 if (len > dest_size - 1)
203 len = dest_size - 1;
204 memcpy(dest, base_path, len);
205 dest[len] = '\0';
206 pstrcat(dest, dest_size, filename);
207 }
208}
209
Max Reitz0a828552014-11-26 17:20:25 +0100210void bdrv_get_full_backing_filename_from_filename(const char *backed,
211 const char *backing,
Max Reitz9f074292014-11-26 17:20:26 +0100212 char *dest, size_t sz,
213 Error **errp)
Max Reitz0a828552014-11-26 17:20:25 +0100214{
Max Reitz9f074292014-11-26 17:20:26 +0100215 if (backing[0] == '\0' || path_has_protocol(backing) ||
216 path_is_absolute(backing))
217 {
Max Reitz0a828552014-11-26 17:20:25 +0100218 pstrcpy(dest, sz, backing);
Max Reitz9f074292014-11-26 17:20:26 +0100219 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
220 error_setg(errp, "Cannot use relative backing file names for '%s'",
221 backed);
Max Reitz0a828552014-11-26 17:20:25 +0100222 } else {
223 path_combine(dest, sz, backed, backing);
224 }
225}
226
Max Reitz9f074292014-11-26 17:20:26 +0100227void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
228 Error **errp)
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200229{
Max Reitz9f074292014-11-26 17:20:26 +0100230 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
231
232 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
233 dest, sz, errp);
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200234}
235
Stefan Hajnoczi0eb72172015-04-28 14:27:51 +0100236void bdrv_register(BlockDriver *bdrv)
237{
238 bdrv_setup_io_funcs(bdrv);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +0200239
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100240 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000241}
bellardb3380822004-03-14 21:38:54 +0000242
Markus Armbruster7f06d472014-10-07 13:59:12 +0200243BlockDriverState *bdrv_new_root(void)
bellardfc01f7e2003-06-30 10:03:06 +0000244{
Markus Armbruster7f06d472014-10-07 13:59:12 +0200245 BlockDriverState *bs = bdrv_new();
Markus Armbrustere4e99862014-10-07 13:59:03 +0200246
Markus Armbrustere4e99862014-10-07 13:59:03 +0200247 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
Markus Armbrustere4e99862014-10-07 13:59:03 +0200248 return bs;
249}
250
251BlockDriverState *bdrv_new(void)
252{
253 BlockDriverState *bs;
254 int i;
255
Markus Armbruster5839e532014-08-19 10:31:08 +0200256 bs = g_new0(BlockDriverState, 1);
Fam Zhenge4654d22013-11-13 18:29:43 +0800257 QLIST_INIT(&bs->dirty_bitmaps);
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800258 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
259 QLIST_INIT(&bs->op_blockers[i]);
260 }
Luiz Capitulino28a72822011-09-26 17:43:50 -0300261 bdrv_iostatus_disable(bs);
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200262 notifier_list_init(&bs->close_notifiers);
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200263 notifier_with_return_list_init(&bs->before_write_notifiers);
Benoît Canetcc0681c2013-09-02 14:14:39 +0200264 qemu_co_queue_init(&bs->throttled_reqs[0]);
265 qemu_co_queue_init(&bs->throttled_reqs[1]);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800266 bs->refcnt = 1;
Stefan Hajnoczidcd04222014-05-08 16:34:37 +0200267 bs->aio_context = qemu_get_aio_context();
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200268
bellardb3380822004-03-14 21:38:54 +0000269 return bs;
270}
271
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200272void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
273{
274 notifier_list_add(&bs->close_notifiers, notify);
275}
276
bellardea2384d2004-08-01 21:59:26 +0000277BlockDriver *bdrv_find_format(const char *format_name)
278{
279 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100280 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
281 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000282 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100283 }
bellardea2384d2004-08-01 21:59:26 +0000284 }
285 return NULL;
286}
287
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800288static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100289{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800290 static const char *whitelist_rw[] = {
291 CONFIG_BDRV_RW_WHITELIST
292 };
293 static const char *whitelist_ro[] = {
294 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100295 };
296 const char **p;
297
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800298 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100299 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800300 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100301
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800302 for (p = whitelist_rw; *p; p++) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100303 if (!strcmp(drv->format_name, *p)) {
304 return 1;
305 }
306 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800307 if (read_only) {
308 for (p = whitelist_ro; *p; p++) {
309 if (!strcmp(drv->format_name, *p)) {
310 return 1;
311 }
312 }
313 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100314 return 0;
315}
316
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800317BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
318 bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100319{
320 BlockDriver *drv = bdrv_find_format(format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800321 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
Markus Armbrustereb852012009-10-27 18:41:44 +0100322}
323
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800324typedef struct CreateCo {
325 BlockDriver *drv;
326 char *filename;
Chunyan Liu83d05212014-06-05 17:20:51 +0800327 QemuOpts *opts;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800328 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200329 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800330} CreateCo;
331
332static void coroutine_fn bdrv_create_co_entry(void *opaque)
333{
Max Reitzcc84d902013-09-06 17:14:26 +0200334 Error *local_err = NULL;
335 int ret;
336
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800337 CreateCo *cco = opaque;
338 assert(cco->drv);
339
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800340 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100341 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200342 error_propagate(&cco->err, local_err);
343 }
344 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800345}
346
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200347int bdrv_create(BlockDriver *drv, const char* filename,
Chunyan Liu83d05212014-06-05 17:20:51 +0800348 QemuOpts *opts, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000349{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800350 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200351
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800352 Coroutine *co;
353 CreateCo cco = {
354 .drv = drv,
355 .filename = g_strdup(filename),
Chunyan Liu83d05212014-06-05 17:20:51 +0800356 .opts = opts,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800357 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200358 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800359 };
360
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800361 if (!drv->bdrv_create) {
Max Reitzcc84d902013-09-06 17:14:26 +0200362 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300363 ret = -ENOTSUP;
364 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800365 }
366
367 if (qemu_in_coroutine()) {
368 /* Fast-path if already in coroutine context */
369 bdrv_create_co_entry(&cco);
370 } else {
371 co = qemu_coroutine_create(bdrv_create_co_entry);
372 qemu_coroutine_enter(co, &cco);
373 while (cco.ret == NOT_DONE) {
Paolo Bonzinib47ec2c2014-07-07 15:18:01 +0200374 aio_poll(qemu_get_aio_context(), true);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800375 }
376 }
377
378 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200379 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100380 if (cco.err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200381 error_propagate(errp, cco.err);
382 } else {
383 error_setg_errno(errp, -ret, "Could not create image");
384 }
385 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800386
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300387out:
388 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800389 return ret;
bellardea2384d2004-08-01 21:59:26 +0000390}
391
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800392int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200393{
394 BlockDriver *drv;
Max Reitzcc84d902013-09-06 17:14:26 +0200395 Error *local_err = NULL;
396 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200397
Max Reitzb65a5e12015-02-05 13:58:12 -0500398 drv = bdrv_find_protocol(filename, true, errp);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200399 if (drv == NULL) {
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000400 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200401 }
402
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800403 ret = bdrv_create(drv, filename, opts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100404 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200405 error_propagate(errp, local_err);
406 }
407 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200408}
409
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100410/**
411 * Try to get @bs's logical and physical block size.
412 * On success, store them in @bsz struct and return 0.
413 * On failure return -errno.
414 * @bs must not be empty.
415 */
416int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
417{
418 BlockDriver *drv = bs->drv;
419
420 if (drv && drv->bdrv_probe_blocksizes) {
421 return drv->bdrv_probe_blocksizes(bs, bsz);
422 }
423
424 return -ENOTSUP;
425}
426
427/**
428 * Try to get @bs's geometry (cyls, heads, sectors).
429 * On success, store them in @geo struct and return 0.
430 * On failure return -errno.
431 * @bs must not be empty.
432 */
433int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
434{
435 BlockDriver *drv = bs->drv;
436
437 if (drv && drv->bdrv_probe_geometry) {
438 return drv->bdrv_probe_geometry(bs, geo);
439 }
440
441 return -ENOTSUP;
442}
443
Jim Meyeringeba25052012-05-28 09:27:54 +0200444/*
445 * Create a uniquely-named empty temporary file.
446 * Return 0 upon success, otherwise a negative errno value.
447 */
448int get_tmp_filename(char *filename, int size)
449{
bellardd5249392004-08-03 21:14:23 +0000450#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000451 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200452 /* GetTempFileName requires that its output buffer (4th param)
453 have length MAX_PATH or greater. */
454 assert(size >= MAX_PATH);
455 return (GetTempPath(MAX_PATH, temp_dir)
456 && GetTempFileName(temp_dir, "qem", 0, filename)
457 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000458#else
bellardea2384d2004-08-01 21:59:26 +0000459 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000460 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000461 tmpdir = getenv("TMPDIR");
Amit Shah69bef792014-02-26 15:12:37 +0530462 if (!tmpdir) {
463 tmpdir = "/var/tmp";
464 }
Jim Meyeringeba25052012-05-28 09:27:54 +0200465 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
466 return -EOVERFLOW;
467 }
bellardea2384d2004-08-01 21:59:26 +0000468 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800469 if (fd < 0) {
470 return -errno;
471 }
472 if (close(fd) != 0) {
473 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200474 return -errno;
475 }
476 return 0;
bellardd5249392004-08-03 21:14:23 +0000477#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200478}
bellardea2384d2004-08-01 21:59:26 +0000479
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200480/*
481 * Detect host devices. By convention, /dev/cdrom[N] is always
482 * recognized as a host CDROM.
483 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200484static BlockDriver *find_hdev_driver(const char *filename)
485{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200486 int score_max = 0, score;
487 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200488
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100489 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200490 if (d->bdrv_probe_device) {
491 score = d->bdrv_probe_device(filename);
492 if (score > score_max) {
493 score_max = score;
494 drv = d;
495 }
496 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200497 }
498
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200499 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200500}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200501
Kevin Wolf98289622013-07-10 15:47:39 +0200502BlockDriver *bdrv_find_protocol(const char *filename,
Max Reitzb65a5e12015-02-05 13:58:12 -0500503 bool allow_protocol_prefix,
504 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200505{
506 BlockDriver *drv1;
507 char protocol[128];
508 int len;
509 const char *p;
510
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200511 /* TODO Drivers without bdrv_file_open must be specified explicitly */
512
Christoph Hellwig39508e72010-06-23 12:25:17 +0200513 /*
514 * XXX(hch): we really should not let host device detection
515 * override an explicit protocol specification, but moving this
516 * later breaks access to device names with colons in them.
517 * Thanks to the brain-dead persistent naming schemes on udev-
518 * based Linux systems those actually are quite common.
519 */
520 drv1 = find_hdev_driver(filename);
521 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200522 return drv1;
523 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200524
Kevin Wolf98289622013-07-10 15:47:39 +0200525 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Max Reitzef810432014-12-02 18:32:42 +0100526 return &bdrv_file;
Christoph Hellwig39508e72010-06-23 12:25:17 +0200527 }
Kevin Wolf98289622013-07-10 15:47:39 +0200528
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000529 p = strchr(filename, ':');
530 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200531 len = p - filename;
532 if (len > sizeof(protocol) - 1)
533 len = sizeof(protocol) - 1;
534 memcpy(protocol, filename, len);
535 protocol[len] = '\0';
536 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
537 if (drv1->protocol_name &&
538 !strcmp(drv1->protocol_name, protocol)) {
539 return drv1;
540 }
541 }
Max Reitzb65a5e12015-02-05 13:58:12 -0500542
543 error_setg(errp, "Unknown protocol '%s'", protocol);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200544 return NULL;
545}
546
Markus Armbrusterc6684242014-11-20 16:27:10 +0100547/*
548 * Guess image format by probing its contents.
549 * This is not a good idea when your image is raw (CVE-2008-2004), but
550 * we do it anyway for backward compatibility.
551 *
552 * @buf contains the image's first @buf_size bytes.
Kevin Wolf7cddd372014-11-20 16:27:11 +0100553 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
554 * but can be smaller if the image file is smaller)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100555 * @filename is its filename.
556 *
557 * For all block drivers, call the bdrv_probe() method to get its
558 * probing score.
559 * Return the first block driver with the highest probing score.
560 */
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100561BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
562 const char *filename)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100563{
564 int score_max = 0, score;
565 BlockDriver *drv = NULL, *d;
566
567 QLIST_FOREACH(d, &bdrv_drivers, list) {
568 if (d->bdrv_probe) {
569 score = d->bdrv_probe(buf, buf_size, filename);
570 if (score > score_max) {
571 score_max = score;
572 drv = d;
573 }
574 }
575 }
576
577 return drv;
578}
579
Kevin Wolff500a6d2012-11-12 17:35:27 +0100580static int find_image_format(BlockDriverState *bs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200581 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000582{
Markus Armbrusterc6684242014-11-20 16:27:10 +0100583 BlockDriver *drv;
Kevin Wolf7cddd372014-11-20 16:27:11 +0100584 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
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 */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300588 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Max Reitzef810432014-12-02 18:32:42 +0100589 *pdrv = &bdrv_raw;
Stefan Weilc98ac352010-07-21 21:51:51 +0200590 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700591 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700592
bellard83f64092006-08-01 16:21:11 +0000593 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000594 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200595 error_setg_errno(errp, -ret, "Could not read image for determining its "
596 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200597 *pdrv = NULL;
598 return ret;
bellard83f64092006-08-01 16:21:11 +0000599 }
600
Markus Armbrusterc6684242014-11-20 16:27:10 +0100601 drv = bdrv_probe_all(buf, ret, filename);
Stefan Weilc98ac352010-07-21 21:51:51 +0200602 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200603 error_setg(errp, "Could not determine image format: No compatible "
604 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200605 ret = -ENOENT;
606 }
607 *pdrv = drv;
608 return ret;
bellardea2384d2004-08-01 21:59:26 +0000609}
610
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100611/**
612 * Set the current 'total_sectors' value
Markus Armbruster65a9bb22014-06-26 13:23:17 +0200613 * Return 0 on success, -errno on error.
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100614 */
615static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
616{
617 BlockDriver *drv = bs->drv;
618
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700619 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300620 if (bdrv_is_sg(bs))
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700621 return 0;
622
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100623 /* query actual device if possible, otherwise just trust the hint */
624 if (drv->bdrv_getlength) {
625 int64_t length = drv->bdrv_getlength(bs);
626 if (length < 0) {
627 return length;
628 }
Fam Zheng7e382002013-11-06 19:48:06 +0800629 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100630 }
631
632 bs->total_sectors = hint;
633 return 0;
634}
635
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100636/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100637 * Set open flags for a given discard mode
638 *
639 * Return 0 on success, -1 if the discard mode was invalid.
640 */
641int bdrv_parse_discard_flags(const char *mode, int *flags)
642{
643 *flags &= ~BDRV_O_UNMAP;
644
645 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
646 /* do nothing */
647 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
648 *flags |= BDRV_O_UNMAP;
649 } else {
650 return -1;
651 }
652
653 return 0;
654}
655
656/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100657 * Set open flags for a given cache mode
658 *
659 * Return 0 on success, -1 if the cache mode was invalid.
660 */
661int bdrv_parse_cache_flags(const char *mode, int *flags)
662{
663 *flags &= ~BDRV_O_CACHE_MASK;
664
665 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
666 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100667 } else if (!strcmp(mode, "directsync")) {
668 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100669 } else if (!strcmp(mode, "writeback")) {
670 *flags |= BDRV_O_CACHE_WB;
671 } else if (!strcmp(mode, "unsafe")) {
672 *flags |= BDRV_O_CACHE_WB;
673 *flags |= BDRV_O_NO_FLUSH;
674 } else if (!strcmp(mode, "writethrough")) {
675 /* this is the default */
676 } else {
677 return -1;
678 }
679
680 return 0;
681}
682
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200683/*
Kevin Wolfb1e6fc02014-05-06 12:11:42 +0200684 * Returns the flags that a temporary snapshot should get, based on the
685 * originally requested flags (the originally requested image will have flags
686 * like a backing file)
687 */
688static int bdrv_temp_snapshot_flags(int flags)
689{
690 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
691}
692
693/*
Kevin Wolff3930ed2015-04-08 13:43:47 +0200694 * Returns the flags that bs->file should get if a protocol driver is expected,
695 * based on the given flags for the parent BDS
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200696 */
697static int bdrv_inherited_flags(int flags)
698{
699 /* Enable protocol handling, disable format probing for bs->file */
700 flags |= BDRV_O_PROTOCOL;
701
702 /* Our block drivers take care to send flushes and respect unmap policy,
703 * so we can enable both unconditionally on lower layers. */
704 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
705
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200706 /* Clear flags that only apply to the top layer */
Kevin Wolf5669b442014-04-11 21:36:45 +0200707 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200708
709 return flags;
710}
711
Kevin Wolff3930ed2015-04-08 13:43:47 +0200712const BdrvChildRole child_file = {
713 .inherit_flags = bdrv_inherited_flags,
714};
715
716/*
717 * Returns the flags that bs->file should get if the use of formats (and not
718 * only protocols) is permitted for it, based on the given flags for the parent
719 * BDS
720 */
721static int bdrv_inherited_fmt_flags(int parent_flags)
722{
723 int flags = child_file.inherit_flags(parent_flags);
724 return flags & ~BDRV_O_PROTOCOL;
725}
726
727const BdrvChildRole child_format = {
728 .inherit_flags = bdrv_inherited_fmt_flags,
729};
730
Kevin Wolf317fc442014-04-25 13:27:34 +0200731/*
732 * Returns the flags that bs->backing_hd should get, based on the given flags
733 * for the parent BDS
734 */
735static int bdrv_backing_flags(int flags)
736{
737 /* backing files always opened read-only */
738 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
739
740 /* snapshot=on is handled on the top layer */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200741 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
Kevin Wolf317fc442014-04-25 13:27:34 +0200742
743 return flags;
744}
745
Kevin Wolff3930ed2015-04-08 13:43:47 +0200746static const BdrvChildRole child_backing = {
747 .inherit_flags = bdrv_backing_flags,
748};
749
Kevin Wolf7b272452012-11-12 17:05:39 +0100750static int bdrv_open_flags(BlockDriverState *bs, int flags)
751{
752 int open_flags = flags | BDRV_O_CACHE_WB;
753
754 /*
755 * Clear flags that are internal to the block layer before opening the
756 * image.
757 */
Kevin Wolf20cca272014-06-04 14:33:27 +0200758 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
Kevin Wolf7b272452012-11-12 17:05:39 +0100759
760 /*
761 * Snapshots should be writable.
762 */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200763 if (flags & BDRV_O_TEMPORARY) {
Kevin Wolf7b272452012-11-12 17:05:39 +0100764 open_flags |= BDRV_O_RDWR;
765 }
766
767 return open_flags;
768}
769
Kevin Wolf636ea372014-01-24 14:11:52 +0100770static void bdrv_assign_node_name(BlockDriverState *bs,
771 const char *node_name,
772 Error **errp)
Benoît Canet6913c0c2014-01-23 21:31:33 +0100773{
774 if (!node_name) {
Kevin Wolf636ea372014-01-24 14:11:52 +0100775 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100776 }
777
Kevin Wolf9aebf3b2014-09-25 09:54:02 +0200778 /* Check for empty string or invalid characters */
Markus Armbrusterf5bebbb2014-09-30 13:59:30 +0200779 if (!id_wellformed(node_name)) {
Kevin Wolf9aebf3b2014-09-25 09:54:02 +0200780 error_setg(errp, "Invalid node name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100781 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100782 }
783
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100784 /* takes care of avoiding namespaces collisions */
Markus Armbruster7f06d472014-10-07 13:59:12 +0200785 if (blk_by_name(node_name)) {
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100786 error_setg(errp, "node-name=%s is conflicting with a device id",
787 node_name);
Kevin Wolf636ea372014-01-24 14:11:52 +0100788 return;
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100789 }
790
Benoît Canet6913c0c2014-01-23 21:31:33 +0100791 /* takes care of avoiding duplicates node names */
792 if (bdrv_find_node(node_name)) {
793 error_setg(errp, "Duplicate node name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100794 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100795 }
796
797 /* copy node name into the bs and insert it into the graph list */
798 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
799 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
Benoît Canet6913c0c2014-01-23 21:31:33 +0100800}
801
Kevin Wolf18edf282015-04-07 17:12:56 +0200802static QemuOptsList bdrv_runtime_opts = {
803 .name = "bdrv_common",
804 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
805 .desc = {
806 {
807 .name = "node-name",
808 .type = QEMU_OPT_STRING,
809 .help = "Node name of the block device node",
810 },
811 { /* end of list */ }
812 },
813};
814
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200815/*
Kevin Wolf57915332010-04-14 15:24:50 +0200816 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +0100817 *
818 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +0200819 */
Kevin Wolff500a6d2012-11-12 17:35:27 +0100820static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200821 QDict *options, int flags, BlockDriver *drv, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +0200822{
823 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200824 const char *filename;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100825 const char *node_name = NULL;
Kevin Wolf18edf282015-04-07 17:12:56 +0200826 QemuOpts *opts;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200827 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +0200828
829 assert(drv != NULL);
Paolo Bonzini64058752012-05-08 16:51:49 +0200830 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +0100831 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +0200832
Kevin Wolf45673672013-04-22 17:48:40 +0200833 if (file != NULL) {
834 filename = file->filename;
835 } else {
836 filename = qdict_get_try_str(options, "filename");
837 }
838
Kevin Wolf765003d2014-02-03 14:49:42 +0100839 if (drv->bdrv_needs_filename && !filename) {
840 error_setg(errp, "The '%s' block driver requires a file name",
841 drv->format_name);
842 return -EINVAL;
843 }
844
Kevin Wolf45673672013-04-22 17:48:40 +0200845 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
Stefan Hajnoczi28dcee12011-09-22 20:14:12 +0100846
Kevin Wolf18edf282015-04-07 17:12:56 +0200847 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
848 qemu_opts_absorb_qdict(opts, options, &local_err);
849 if (local_err) {
850 error_propagate(errp, local_err);
851 ret = -EINVAL;
852 goto fail_opts;
853 }
854
855 node_name = qemu_opt_get(opts, "node-name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100856 bdrv_assign_node_name(bs, node_name, &local_err);
Markus Armbruster0fb63952014-04-25 16:50:31 +0200857 if (local_err) {
Kevin Wolf636ea372014-01-24 14:11:52 +0100858 error_propagate(errp, local_err);
Kevin Wolf18edf282015-04-07 17:12:56 +0200859 ret = -EINVAL;
860 goto fail_opts;
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100861 }
862
Paolo Bonzini1b7fd722011-11-29 11:35:47 +0100863 bs->guest_block_size = 512;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100864 bs->request_alignment = 512;
Asias He0d51b4d2013-08-22 15:24:14 +0800865 bs->zero_beyond_eof = true;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800866 open_flags = bdrv_open_flags(bs, flags);
867 bs->read_only = !(open_flags & BDRV_O_RDWR);
868
869 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200870 error_setg(errp,
871 !bs->read_only && bdrv_is_whitelisted(drv, true)
872 ? "Driver '%s' can only be used for read-only devices"
873 : "Driver '%s' is not whitelisted",
874 drv->format_name);
Kevin Wolf18edf282015-04-07 17:12:56 +0200875 ret = -ENOTSUP;
876 goto fail_opts;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800877 }
Kevin Wolf57915332010-04-14 15:24:50 +0200878
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000879 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200880 if (flags & BDRV_O_COPY_ON_READ) {
881 if (!bs->read_only) {
882 bdrv_enable_copy_on_read(bs);
883 } else {
884 error_setg(errp, "Can't use copy-on-read on read-only device");
Kevin Wolf18edf282015-04-07 17:12:56 +0200885 ret = -EINVAL;
886 goto fail_opts;
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200887 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000888 }
889
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100890 if (filename != NULL) {
891 pstrcpy(bs->filename, sizeof(bs->filename), filename);
892 } else {
893 bs->filename[0] = '\0';
894 }
Max Reitz91af7012014-07-18 20:24:56 +0200895 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
Kevin Wolf57915332010-04-14 15:24:50 +0200896
Kevin Wolf57915332010-04-14 15:24:50 +0200897 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500898 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200899
Stefan Hajnoczi03f541b2011-10-27 10:54:28 +0100900 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100901
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200902 /* Open the image, either directly or using a protocol */
903 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100904 assert(file == NULL);
Benoît Canet030be322013-09-24 17:07:04 +0200905 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200906 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +0100907 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200908 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200909 error_setg(errp, "Can't use '%s' as a block driver for the "
910 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200911 ret = -EINVAL;
912 goto free_and_fail;
913 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100914 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200915 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200916 }
917
Kevin Wolf57915332010-04-14 15:24:50 +0200918 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100919 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200920 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +0800921 } else if (bs->filename[0]) {
922 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200923 } else {
924 error_setg_errno(errp, -ret, "Could not open image");
925 }
Kevin Wolf57915332010-04-14 15:24:50 +0200926 goto free_and_fail;
927 }
928
Markus Armbrustera1f688f2015-03-13 21:09:40 +0100929 if (bs->encrypted) {
930 error_report("Encrypted images are deprecated");
931 error_printf("Support for them will be removed in a future release.\n"
932 "You can use 'qemu-img convert' to convert your image"
933 " to an unencrypted one.\n");
934 }
935
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100936 ret = refresh_total_sectors(bs, bs->total_sectors);
937 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200938 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100939 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200940 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100941
Kevin Wolf3baca892014-07-16 17:48:16 +0200942 bdrv_refresh_limits(bs, &local_err);
943 if (local_err) {
944 error_propagate(errp, local_err);
945 ret = -EINVAL;
946 goto free_and_fail;
947 }
948
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100949 assert(bdrv_opt_mem_align(bs) != 0);
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300950 assert(bdrv_min_mem_align(bs) != 0);
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300951 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
Kevin Wolf18edf282015-04-07 17:12:56 +0200952
953 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +0200954 return 0;
955
956free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +0100957 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -0500958 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +0200959 bs->opaque = NULL;
960 bs->drv = NULL;
Kevin Wolf18edf282015-04-07 17:12:56 +0200961fail_opts:
962 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +0200963 return ret;
964}
965
Kevin Wolf5e5c4f62014-05-26 11:45:08 +0200966static QDict *parse_json_filename(const char *filename, Error **errp)
967{
968 QObject *options_obj;
969 QDict *options;
970 int ret;
971
972 ret = strstart(filename, "json:", &filename);
973 assert(ret);
974
975 options_obj = qobject_from_json(filename);
976 if (!options_obj) {
977 error_setg(errp, "Could not parse the JSON options");
978 return NULL;
979 }
980
981 if (qobject_type(options_obj) != QTYPE_QDICT) {
982 qobject_decref(options_obj);
983 error_setg(errp, "Invalid JSON object given");
984 return NULL;
985 }
986
987 options = qobject_to_qdict(options_obj);
988 qdict_flatten(options);
989
990 return options;
991}
992
Kevin Wolf57915332010-04-14 15:24:50 +0200993/*
Kevin Wolff54120f2014-05-26 11:09:59 +0200994 * Fills in default options for opening images and converts the legacy
995 * filename/flags pair to option QDict entries.
Max Reitz53a29512015-03-19 14:53:16 -0400996 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
997 * block driver has been specified explicitly.
Kevin Wolff54120f2014-05-26 11:09:59 +0200998 */
Max Reitz53a29512015-03-19 14:53:16 -0400999static int bdrv_fill_options(QDict **options, const char **pfilename,
1000 int *flags, BlockDriver *drv, Error **errp)
Kevin Wolff54120f2014-05-26 11:09:59 +02001001{
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001002 const char *filename = *pfilename;
Kevin Wolff54120f2014-05-26 11:09:59 +02001003 const char *drvname;
Max Reitz53a29512015-03-19 14:53:16 -04001004 bool protocol = *flags & BDRV_O_PROTOCOL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001005 bool parse_filename = false;
Max Reitz53a29512015-03-19 14:53:16 -04001006 BlockDriver *tmp_drv;
Kevin Wolff54120f2014-05-26 11:09:59 +02001007 Error *local_err = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001008
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001009 /* Parse json: pseudo-protocol */
1010 if (filename && g_str_has_prefix(filename, "json:")) {
1011 QDict *json_options = parse_json_filename(filename, &local_err);
1012 if (local_err) {
1013 error_propagate(errp, local_err);
1014 return -EINVAL;
1015 }
1016
1017 /* Options given in the filename have lower priority than options
1018 * specified directly */
1019 qdict_join(*options, json_options, false);
1020 QDECREF(json_options);
1021 *pfilename = filename = NULL;
1022 }
1023
Max Reitz53a29512015-03-19 14:53:16 -04001024 drvname = qdict_get_try_str(*options, "driver");
1025
1026 /* If the user has explicitly specified the driver, this choice should
1027 * override the BDRV_O_PROTOCOL flag */
1028 tmp_drv = drv;
1029 if (!tmp_drv && drvname) {
1030 tmp_drv = bdrv_find_format(drvname);
1031 }
1032 if (tmp_drv) {
1033 protocol = tmp_drv->bdrv_file_open;
1034 }
1035
1036 if (protocol) {
1037 *flags |= BDRV_O_PROTOCOL;
1038 } else {
1039 *flags &= ~BDRV_O_PROTOCOL;
1040 }
1041
Kevin Wolff54120f2014-05-26 11:09:59 +02001042 /* Fetch the file name from the options QDict if necessary */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001043 if (protocol && filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001044 if (!qdict_haskey(*options, "filename")) {
1045 qdict_put(*options, "filename", qstring_from_str(filename));
1046 parse_filename = true;
1047 } else {
1048 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1049 "the same time");
1050 return -EINVAL;
1051 }
1052 }
1053
1054 /* Find the right block driver */
1055 filename = qdict_get_try_str(*options, "filename");
Kevin Wolff54120f2014-05-26 11:09:59 +02001056
Kevin Wolf17b005f2014-05-27 10:50:29 +02001057 if (drv) {
1058 if (drvname) {
1059 error_setg(errp, "Driver specified twice");
1060 return -EINVAL;
1061 }
1062 drvname = drv->format_name;
1063 qdict_put(*options, "driver", qstring_from_str(drvname));
1064 } else {
1065 if (!drvname && protocol) {
1066 if (filename) {
Max Reitzb65a5e12015-02-05 13:58:12 -05001067 drv = bdrv_find_protocol(filename, parse_filename, errp);
Kevin Wolf17b005f2014-05-27 10:50:29 +02001068 if (!drv) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02001069 return -EINVAL;
1070 }
1071
1072 drvname = drv->format_name;
1073 qdict_put(*options, "driver", qstring_from_str(drvname));
1074 } else {
1075 error_setg(errp, "Must specify either driver or file");
Kevin Wolff54120f2014-05-26 11:09:59 +02001076 return -EINVAL;
1077 }
Kevin Wolf17b005f2014-05-27 10:50:29 +02001078 } else if (drvname) {
1079 drv = bdrv_find_format(drvname);
1080 if (!drv) {
1081 error_setg(errp, "Unknown driver '%s'", drvname);
1082 return -ENOENT;
1083 }
Kevin Wolff54120f2014-05-26 11:09:59 +02001084 }
1085 }
1086
Kevin Wolf17b005f2014-05-27 10:50:29 +02001087 assert(drv || !protocol);
Kevin Wolff54120f2014-05-26 11:09:59 +02001088
1089 /* Driver-specific filename parsing */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001090 if (drv && drv->bdrv_parse_filename && parse_filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001091 drv->bdrv_parse_filename(filename, *options, &local_err);
1092 if (local_err) {
1093 error_propagate(errp, local_err);
1094 return -EINVAL;
1095 }
1096
1097 if (!drv->bdrv_needs_filename) {
1098 qdict_del(*options, "filename");
1099 }
1100 }
1101
1102 return 0;
1103}
1104
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001105static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1106 BlockDriverState *child_bs,
1107 const BdrvChildRole *child_role)
Kevin Wolfdf581792015-06-15 11:53:47 +02001108{
1109 BdrvChild *child = g_new(BdrvChild, 1);
1110 *child = (BdrvChild) {
1111 .bs = child_bs,
1112 .role = child_role,
1113 };
1114
1115 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001116
1117 return child;
Kevin Wolfdf581792015-06-15 11:53:47 +02001118}
1119
Kevin Wolf33a60402015-06-15 13:51:04 +02001120static void bdrv_detach_child(BdrvChild *child)
1121{
1122 QLIST_REMOVE(child, next);
1123 g_free(child);
1124}
1125
1126void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1127{
1128 BlockDriverState *child_bs = child->bs;
1129
1130 if (child->bs->inherits_from == parent) {
1131 child->bs->inherits_from = NULL;
1132 }
1133
1134 bdrv_detach_child(child);
1135 bdrv_unref(child_bs);
1136}
1137
Fam Zheng8d24cce2014-05-23 21:29:45 +08001138void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1139{
1140
Fam Zheng826b6ca2014-05-23 21:29:47 +08001141 if (bs->backing_hd) {
1142 assert(bs->backing_blocker);
1143 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
Kevin Wolf80a1e132015-06-17 15:52:09 +02001144 bdrv_detach_child(bs->backing_child);
Fam Zheng826b6ca2014-05-23 21:29:47 +08001145 } else if (backing_hd) {
1146 error_setg(&bs->backing_blocker,
Alberto Garcia81e5f782015-04-08 12:29:19 +03001147 "node is used as backing hd of '%s'",
1148 bdrv_get_device_or_node_name(bs));
Fam Zheng826b6ca2014-05-23 21:29:47 +08001149 }
1150
Fam Zheng8d24cce2014-05-23 21:29:45 +08001151 bs->backing_hd = backing_hd;
1152 if (!backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001153 error_free(bs->backing_blocker);
1154 bs->backing_blocker = NULL;
Kevin Wolf80a1e132015-06-17 15:52:09 +02001155 bs->backing_child = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001156 goto out;
1157 }
Kevin Wolf80a1e132015-06-17 15:52:09 +02001158 bs->backing_child = bdrv_attach_child(bs, backing_hd, &child_backing);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001159 bs->open_flags &= ~BDRV_O_NO_BACKING;
1160 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1161 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1162 backing_hd->drv ? backing_hd->drv->format_name : "");
Fam Zheng826b6ca2014-05-23 21:29:47 +08001163
1164 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1165 /* Otherwise we won't be able to commit due to check in bdrv_commit */
Fam Zhengbb000212014-09-11 13:14:00 +08001166 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
Fam Zheng826b6ca2014-05-23 21:29:47 +08001167 bs->backing_blocker);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001168out:
Kevin Wolf3baca892014-07-16 17:48:16 +02001169 bdrv_refresh_limits(bs, NULL);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001170}
1171
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001172/*
1173 * Opens the backing file for a BlockDriverState if not yet open
1174 *
1175 * options is a QDict of options to pass to the block drivers, or NULL for an
1176 * empty set of options. The reference to the QDict is transferred to this
1177 * function (even on failure), so if the caller intends to reuse the dictionary,
1178 * it needs to use QINCREF() before calling bdrv_file_open.
1179 */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001180int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02001181{
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001182 char *backing_filename = g_malloc0(PATH_MAX);
Kevin Wolf317fc442014-04-25 13:27:34 +02001183 int ret = 0;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001184 BlockDriverState *backing_hd;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001185 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001186
1187 if (bs->backing_hd != NULL) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001188 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001189 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001190 }
1191
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001192 /* NULL means an empty set of options */
1193 if (options == NULL) {
1194 options = qdict_new();
1195 }
1196
Paolo Bonzini9156df12012-10-18 16:49:17 +02001197 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolf1cb6f502013-04-12 20:27:07 +02001198 if (qdict_haskey(options, "file.filename")) {
1199 backing_filename[0] = '\0';
1200 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001201 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001202 goto free_exit;
Fam Zhengdbecebd2013-09-22 20:05:06 +08001203 } else {
Max Reitz9f074292014-11-26 17:20:26 +01001204 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1205 &local_err);
1206 if (local_err) {
1207 ret = -EINVAL;
1208 error_propagate(errp, local_err);
1209 QDECREF(options);
1210 goto free_exit;
1211 }
Paolo Bonzini9156df12012-10-18 16:49:17 +02001212 }
1213
Kevin Wolf8ee79e72014-06-04 15:09:35 +02001214 if (!bs->drv || !bs->drv->supports_backing) {
1215 ret = -EINVAL;
1216 error_setg(errp, "Driver doesn't support backing files");
1217 QDECREF(options);
1218 goto free_exit;
1219 }
1220
Markus Armbrustere4e99862014-10-07 13:59:03 +02001221 backing_hd = bdrv_new();
Fam Zheng8d24cce2014-05-23 21:29:45 +08001222
Kevin Wolfc5f6e492014-11-25 18:12:42 +01001223 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1224 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
Paolo Bonzini9156df12012-10-18 16:49:17 +02001225 }
1226
Max Reitzf67503e2014-02-18 18:33:05 +01001227 assert(bs->backing_hd == NULL);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001228 ret = bdrv_open_inherit(&backing_hd,
1229 *backing_filename ? backing_filename : NULL,
1230 NULL, options, 0, bs, &child_backing,
1231 NULL, &local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001232 if (ret < 0) {
Fam Zheng8d24cce2014-05-23 21:29:45 +08001233 bdrv_unref(backing_hd);
1234 backing_hd = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001235 bs->open_flags |= BDRV_O_NO_BACKING;
Fam Zhengb04b6b62013-11-08 11:26:49 +08001236 error_setg(errp, "Could not open backing file: %s",
1237 error_get_pretty(local_err));
1238 error_free(local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001239 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001240 }
Kevin Wolfdf581792015-06-15 11:53:47 +02001241
Fam Zheng8d24cce2014-05-23 21:29:45 +08001242 bdrv_set_backing_hd(bs, backing_hd);
Peter Feinerd80ac652014-01-08 19:43:25 +00001243
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001244free_exit:
1245 g_free(backing_filename);
1246 return ret;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001247}
1248
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001249/*
Max Reitzda557aa2013-12-20 19:28:11 +01001250 * Opens a disk image whose options are given as BlockdevRef in another block
1251 * device's options.
1252 *
Max Reitzda557aa2013-12-20 19:28:11 +01001253 * If allow_none is true, no image will be opened if filename is false and no
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001254 * BlockdevRef is given. NULL will be returned, but errp remains unset.
Max Reitzda557aa2013-12-20 19:28:11 +01001255 *
1256 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1257 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1258 * itself, all options starting with "${bdref_key}." are considered part of the
1259 * BlockdevRef.
1260 *
1261 * The BlockdevRef will be removed from the options QDict.
1262 */
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001263BdrvChild *bdrv_open_child(const char *filename,
1264 QDict *options, const char *bdref_key,
1265 BlockDriverState* parent,
1266 const BdrvChildRole *child_role,
1267 bool allow_none, Error **errp)
Max Reitzda557aa2013-12-20 19:28:11 +01001268{
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001269 BdrvChild *c = NULL;
1270 BlockDriverState *bs;
Max Reitzda557aa2013-12-20 19:28:11 +01001271 QDict *image_options;
1272 int ret;
1273 char *bdref_key_dot;
1274 const char *reference;
1275
Kevin Wolfdf581792015-06-15 11:53:47 +02001276 assert(child_role != NULL);
Max Reitzf67503e2014-02-18 18:33:05 +01001277
Max Reitzda557aa2013-12-20 19:28:11 +01001278 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1279 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1280 g_free(bdref_key_dot);
1281
1282 reference = qdict_get_try_str(options, bdref_key);
1283 if (!filename && !reference && !qdict_size(image_options)) {
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001284 if (!allow_none) {
Max Reitzda557aa2013-12-20 19:28:11 +01001285 error_setg(errp, "A block device must be specified for \"%s\"",
1286 bdref_key);
Max Reitzda557aa2013-12-20 19:28:11 +01001287 }
Markus Armbrusterb20e61e2014-05-28 11:16:57 +02001288 QDECREF(image_options);
Max Reitzda557aa2013-12-20 19:28:11 +01001289 goto done;
1290 }
1291
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001292 bs = NULL;
1293 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
Kevin Wolff3930ed2015-04-08 13:43:47 +02001294 parent, child_role, NULL, errp);
Kevin Wolfdf581792015-06-15 11:53:47 +02001295 if (ret < 0) {
1296 goto done;
1297 }
1298
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001299 c = bdrv_attach_child(parent, bs, child_role);
Max Reitzda557aa2013-12-20 19:28:11 +01001300
1301done:
1302 qdict_del(options, bdref_key);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001303 return c;
1304}
1305
1306/*
1307 * This is a version of bdrv_open_child() that returns 0/-EINVAL instead of
1308 * a BdrvChild object.
1309 *
1310 * If allow_none is true, no image will be opened if filename is false and no
1311 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1312 *
1313 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1314 */
1315int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1316 QDict *options, const char *bdref_key,
1317 BlockDriverState* parent, const BdrvChildRole *child_role,
1318 bool allow_none, Error **errp)
1319{
1320 Error *local_err = NULL;
1321 BdrvChild *c;
1322
1323 assert(pbs);
1324 assert(*pbs == NULL);
1325
1326 c = bdrv_open_child(filename, options, bdref_key, parent, child_role,
1327 allow_none, &local_err);
1328 if (local_err) {
1329 error_propagate(errp, local_err);
1330 return -EINVAL;
1331 }
1332
1333 if (c != NULL) {
1334 *pbs = c->bs;
1335 }
1336
1337 return 0;
Max Reitzda557aa2013-12-20 19:28:11 +01001338}
1339
Chen Gang6b8aeca2014-06-23 23:28:23 +08001340int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
Kevin Wolfb9988752014-04-03 12:09:34 +02001341{
1342 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001343 char *tmp_filename = g_malloc0(PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001344 int64_t total_size;
Chunyan Liu83d05212014-06-05 17:20:51 +08001345 QemuOpts *opts = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001346 QDict *snapshot_options;
1347 BlockDriverState *bs_snapshot;
Fam Zhengc2e0dbb2015-07-06 12:24:44 +08001348 Error *local_err = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001349 int ret;
1350
1351 /* if snapshot, we create a temporary backing file and open it
1352 instead of opening 'filename' directly */
1353
1354 /* Get the required size from the image */
Kevin Wolff1877432014-04-04 17:07:19 +02001355 total_size = bdrv_getlength(bs);
1356 if (total_size < 0) {
Chen Gang6b8aeca2014-06-23 23:28:23 +08001357 ret = total_size;
Kevin Wolff1877432014-04-04 17:07:19 +02001358 error_setg_errno(errp, -total_size, "Could not get image size");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001359 goto out;
Kevin Wolff1877432014-04-04 17:07:19 +02001360 }
Kevin Wolfb9988752014-04-03 12:09:34 +02001361
1362 /* Create the temporary image */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001363 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001364 if (ret < 0) {
1365 error_setg_errno(errp, -ret, "Could not get temporary filename");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001366 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001367 }
1368
Max Reitzef810432014-12-02 18:32:42 +01001369 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001370 &error_abort);
Markus Armbruster39101f22015-02-12 16:46:36 +01001371 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
Max Reitzef810432014-12-02 18:32:42 +01001372 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08001373 qemu_opts_del(opts);
Kevin Wolfb9988752014-04-03 12:09:34 +02001374 if (ret < 0) {
1375 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1376 "'%s': %s", tmp_filename,
1377 error_get_pretty(local_err));
1378 error_free(local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001379 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001380 }
1381
1382 /* Prepare a new options QDict for the temporary file */
1383 snapshot_options = qdict_new();
1384 qdict_put(snapshot_options, "file.driver",
1385 qstring_from_str("file"));
1386 qdict_put(snapshot_options, "file.filename",
1387 qstring_from_str(tmp_filename));
1388
Markus Armbrustere4e99862014-10-07 13:59:03 +02001389 bs_snapshot = bdrv_new();
Kevin Wolfb9988752014-04-03 12:09:34 +02001390
1391 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
Max Reitzef810432014-12-02 18:32:42 +01001392 flags, &bdrv_qcow2, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001393 if (ret < 0) {
1394 error_propagate(errp, local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001395 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001396 }
1397
1398 bdrv_append(bs_snapshot, bs);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001399
1400out:
1401 g_free(tmp_filename);
Chen Gang6b8aeca2014-06-23 23:28:23 +08001402 return ret;
Kevin Wolfb9988752014-04-03 12:09:34 +02001403}
1404
Max Reitzda557aa2013-12-20 19:28:11 +01001405/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001406 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001407 *
1408 * options is a QDict of options to pass to the block drivers, or NULL for an
1409 * empty set of options. The reference to the QDict belongs to the block layer
1410 * after the call (even on failure), so if the caller intends to reuse the
1411 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Max Reitzf67503e2014-02-18 18:33:05 +01001412 *
1413 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1414 * If it is not NULL, the referenced BDS will be reused.
Max Reitzddf56362014-02-18 18:33:06 +01001415 *
1416 * The reference parameter may be used to specify an existing block device which
1417 * should be opened. If specified, neither options nor a filename may be given,
1418 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001419 */
Kevin Wolff3930ed2015-04-08 13:43:47 +02001420static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1421 const char *reference, QDict *options, int flags,
1422 BlockDriverState *parent,
1423 const BdrvChildRole *child_role,
1424 BlockDriver *drv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001425{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001426 int ret;
Max Reitzf67503e2014-02-18 18:33:05 +01001427 BlockDriverState *file = NULL, *bs;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001428 const char *drvname;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001429 Error *local_err = NULL;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001430 int snapshot_flags = 0;
bellard712e7872005-04-28 21:09:32 +00001431
Max Reitzf67503e2014-02-18 18:33:05 +01001432 assert(pbs);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001433 assert(!child_role || !flags);
1434 assert(!child_role == !parent);
Max Reitzf67503e2014-02-18 18:33:05 +01001435
Max Reitzddf56362014-02-18 18:33:06 +01001436 if (reference) {
1437 bool options_non_empty = options ? qdict_size(options) : false;
1438 QDECREF(options);
1439
1440 if (*pbs) {
1441 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1442 "another block device");
1443 return -EINVAL;
1444 }
1445
1446 if (filename || options_non_empty) {
1447 error_setg(errp, "Cannot reference an existing block device with "
1448 "additional options or a new filename");
1449 return -EINVAL;
1450 }
1451
1452 bs = bdrv_lookup_bs(reference, reference, errp);
1453 if (!bs) {
1454 return -ENODEV;
1455 }
1456 bdrv_ref(bs);
1457 *pbs = bs;
1458 return 0;
1459 }
1460
Max Reitzf67503e2014-02-18 18:33:05 +01001461 if (*pbs) {
1462 bs = *pbs;
1463 } else {
Markus Armbrustere4e99862014-10-07 13:59:03 +02001464 bs = bdrv_new();
Max Reitzf67503e2014-02-18 18:33:05 +01001465 }
1466
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001467 /* NULL means an empty set of options */
1468 if (options == NULL) {
1469 options = qdict_new();
1470 }
1471
Kevin Wolff3930ed2015-04-08 13:43:47 +02001472 if (child_role) {
Kevin Wolfbddcec32015-04-09 18:47:50 +02001473 bs->inherits_from = parent;
Kevin Wolff3930ed2015-04-08 13:43:47 +02001474 flags = child_role->inherit_flags(parent->open_flags);
1475 }
1476
Max Reitz53a29512015-03-19 14:53:16 -04001477 ret = bdrv_fill_options(&options, &filename, &flags, drv, &local_err);
Kevin Wolf462f5bc2014-05-26 11:39:55 +02001478 if (local_err) {
1479 goto fail;
1480 }
1481
Kevin Wolf76c591b2014-06-04 14:19:44 +02001482 /* Find the right image format driver */
1483 drv = NULL;
1484 drvname = qdict_get_try_str(options, "driver");
1485 if (drvname) {
1486 drv = bdrv_find_format(drvname);
1487 qdict_del(options, "driver");
1488 if (!drv) {
1489 error_setg(errp, "Unknown driver: '%s'", drvname);
1490 ret = -EINVAL;
1491 goto fail;
1492 }
1493 }
1494
1495 assert(drvname || !(flags & BDRV_O_PROTOCOL));
Kevin Wolf76c591b2014-06-04 14:19:44 +02001496
Kevin Wolff3930ed2015-04-08 13:43:47 +02001497 bs->open_flags = flags;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001498 bs->options = options;
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001499 options = qdict_clone_shallow(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001500
Kevin Wolff4788ad2014-06-03 16:44:19 +02001501 /* Open image file without format layer */
1502 if ((flags & BDRV_O_PROTOCOL) == 0) {
1503 if (flags & BDRV_O_RDWR) {
1504 flags |= BDRV_O_ALLOW_RDWR;
1505 }
1506 if (flags & BDRV_O_SNAPSHOT) {
1507 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1508 flags = bdrv_backing_flags(flags);
1509 }
1510
1511 assert(file == NULL);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001512 bs->open_flags = flags;
Kevin Wolff4788ad2014-06-03 16:44:19 +02001513 ret = bdrv_open_image(&file, filename, options, "file",
Kevin Wolff3930ed2015-04-08 13:43:47 +02001514 bs, &child_file, true, &local_err);
Kevin Wolff4788ad2014-06-03 16:44:19 +02001515 if (ret < 0) {
Max Reitz5469a2a2014-02-18 18:33:10 +01001516 goto fail;
1517 }
1518 }
1519
Kevin Wolf76c591b2014-06-04 14:19:44 +02001520 /* Image format probing */
Kevin Wolf38f3ef52014-11-20 16:27:12 +01001521 bs->probed = !drv;
Kevin Wolf76c591b2014-06-04 14:19:44 +02001522 if (!drv && file) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02001523 ret = find_image_format(file, filename, &drv, &local_err);
1524 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001525 goto fail;
Max Reitz2a05cbe2013-12-20 19:28:10 +01001526 }
Kevin Wolf76c591b2014-06-04 14:19:44 +02001527 } else if (!drv) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02001528 error_setg(errp, "Must specify either driver or file");
1529 ret = -EINVAL;
Kevin Wolf8bfea152014-04-11 19:16:36 +02001530 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001531 }
1532
Max Reitz53a29512015-03-19 14:53:16 -04001533 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1534 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1535 /* file must be NULL if a protocol BDS is about to be created
1536 * (the inverse results in an error message from bdrv_open_common()) */
1537 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1538
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001539 /* Open the image */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001540 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001541 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001542 goto fail;
Christoph Hellwig69873072010-01-20 18:13:25 +01001543 }
1544
Max Reitz2a05cbe2013-12-20 19:28:10 +01001545 if (file && (bs->file != file)) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001546 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001547 file = NULL;
1548 }
1549
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001550 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001551 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001552 QDict *backing_options;
1553
Benoît Canet5726d872013-09-25 13:30:01 +02001554 qdict_extract_subqdict(options, &backing_options, "backing.");
Max Reitz34b5d2c2013-09-05 14:45:29 +02001555 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001556 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001557 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001558 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001559 }
1560
Max Reitz91af7012014-07-18 20:24:56 +02001561 bdrv_refresh_filename(bs);
1562
Kevin Wolfb9988752014-04-03 12:09:34 +02001563 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1564 * temporary snapshot afterwards. */
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001565 if (snapshot_flags) {
Chen Gang6b8aeca2014-06-23 23:28:23 +08001566 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001567 if (local_err) {
Kevin Wolfb9988752014-04-03 12:09:34 +02001568 goto close_and_fail;
1569 }
1570 }
1571
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001572 /* Check if any unknown options were used */
Max Reitz5acd9d82014-02-18 18:33:11 +01001573 if (options && (qdict_size(options) != 0)) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001574 const QDictEntry *entry = qdict_first(options);
Max Reitz5acd9d82014-02-18 18:33:11 +01001575 if (flags & BDRV_O_PROTOCOL) {
1576 error_setg(errp, "Block protocol '%s' doesn't support the option "
1577 "'%s'", drv->format_name, entry->key);
1578 } else {
1579 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1580 "support the option '%s'", drv->format_name,
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02001581 bdrv_get_device_name(bs), entry->key);
Max Reitz5acd9d82014-02-18 18:33:11 +01001582 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001583
1584 ret = -EINVAL;
1585 goto close_and_fail;
1586 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001587
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001588 if (!bdrv_key_required(bs)) {
Markus Armbrustera7f53e22014-10-07 13:59:25 +02001589 if (bs->blk) {
1590 blk_dev_change_media_cb(bs->blk, true);
1591 }
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001592 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1593 && !runstate_check(RUN_STATE_INMIGRATE)
1594 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1595 error_setg(errp,
1596 "Guest must be stopped for opening of encrypted image");
1597 ret = -EBUSY;
1598 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001599 }
1600
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001601 QDECREF(options);
Max Reitzf67503e2014-02-18 18:33:05 +01001602 *pbs = bs;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001603 return 0;
1604
Kevin Wolf8bfea152014-04-11 19:16:36 +02001605fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001606 if (file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001607 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001608 }
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001609 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001610 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001611 bs->options = NULL;
Max Reitzf67503e2014-02-18 18:33:05 +01001612 if (!*pbs) {
1613 /* If *pbs is NULL, a new BDS has been created in this function and
1614 needs to be freed now. Otherwise, it does not need to be closed,
1615 since it has not really been opened yet. */
1616 bdrv_unref(bs);
1617 }
Markus Armbruster84d18f02014-01-30 15:07:28 +01001618 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001619 error_propagate(errp, local_err);
1620 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001621 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001622
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001623close_and_fail:
Max Reitzf67503e2014-02-18 18:33:05 +01001624 /* See fail path, but now the BDS has to be always closed */
1625 if (*pbs) {
1626 bdrv_close(bs);
1627 } else {
1628 bdrv_unref(bs);
1629 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001630 QDECREF(options);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001631 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001632 error_propagate(errp, local_err);
1633 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001634 return ret;
1635}
1636
Kevin Wolff3930ed2015-04-08 13:43:47 +02001637int bdrv_open(BlockDriverState **pbs, const char *filename,
1638 const char *reference, QDict *options, int flags,
1639 BlockDriver *drv, Error **errp)
1640{
1641 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1642 NULL, drv, errp);
1643}
1644
Jeff Codye971aa12012-09-20 15:13:19 -04001645typedef struct BlockReopenQueueEntry {
1646 bool prepared;
1647 BDRVReopenState state;
1648 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1649} BlockReopenQueueEntry;
1650
1651/*
1652 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1653 * reopen of multiple devices.
1654 *
1655 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1656 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1657 * be created and initialized. This newly created BlockReopenQueue should be
1658 * passed back in for subsequent calls that are intended to be of the same
1659 * atomic 'set'.
1660 *
1661 * bs is the BlockDriverState to add to the reopen queue.
1662 *
1663 * flags contains the open flags for the associated bs
1664 *
1665 * returns a pointer to bs_queue, which is either the newly allocated
1666 * bs_queue, or the existing bs_queue being used.
1667 *
1668 */
1669BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1670 BlockDriverState *bs, int flags)
1671{
1672 assert(bs != NULL);
1673
1674 BlockReopenQueueEntry *bs_entry;
Kevin Wolf67251a32015-04-09 18:54:04 +02001675 BdrvChild *child;
1676
Jeff Codye971aa12012-09-20 15:13:19 -04001677 if (bs_queue == NULL) {
1678 bs_queue = g_new0(BlockReopenQueue, 1);
1679 QSIMPLEQ_INIT(bs_queue);
1680 }
1681
Kevin Wolff1f25a22014-04-25 19:04:55 +02001682 /* bdrv_open() masks this flag out */
1683 flags &= ~BDRV_O_PROTOCOL;
1684
Kevin Wolf67251a32015-04-09 18:54:04 +02001685 QLIST_FOREACH(child, &bs->children, next) {
1686 int child_flags;
1687
1688 if (child->bs->inherits_from != bs) {
1689 continue;
1690 }
1691
1692 child_flags = child->role->inherit_flags(flags);
1693 bdrv_reopen_queue(bs_queue, child->bs, child_flags);
Jeff Codye971aa12012-09-20 15:13:19 -04001694 }
1695
1696 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1697 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1698
1699 bs_entry->state.bs = bs;
1700 bs_entry->state.flags = flags;
1701
1702 return bs_queue;
1703}
1704
1705/*
1706 * Reopen multiple BlockDriverStates atomically & transactionally.
1707 *
1708 * The queue passed in (bs_queue) must have been built up previous
1709 * via bdrv_reopen_queue().
1710 *
1711 * Reopens all BDS specified in the queue, with the appropriate
1712 * flags. All devices are prepared for reopen, and failure of any
1713 * device will cause all device changes to be abandonded, and intermediate
1714 * data cleaned up.
1715 *
1716 * If all devices prepare successfully, then the changes are committed
1717 * to all devices.
1718 *
1719 */
1720int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1721{
1722 int ret = -1;
1723 BlockReopenQueueEntry *bs_entry, *next;
1724 Error *local_err = NULL;
1725
1726 assert(bs_queue != NULL);
1727
1728 bdrv_drain_all();
1729
1730 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1731 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1732 error_propagate(errp, local_err);
1733 goto cleanup;
1734 }
1735 bs_entry->prepared = true;
1736 }
1737
1738 /* If we reach this point, we have success and just need to apply the
1739 * changes
1740 */
1741 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1742 bdrv_reopen_commit(&bs_entry->state);
1743 }
1744
1745 ret = 0;
1746
1747cleanup:
1748 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1749 if (ret && bs_entry->prepared) {
1750 bdrv_reopen_abort(&bs_entry->state);
1751 }
1752 g_free(bs_entry);
1753 }
1754 g_free(bs_queue);
1755 return ret;
1756}
1757
1758
1759/* Reopen a single BlockDriverState with the specified flags. */
1760int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1761{
1762 int ret = -1;
1763 Error *local_err = NULL;
1764 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1765
1766 ret = bdrv_reopen_multiple(queue, &local_err);
1767 if (local_err != NULL) {
1768 error_propagate(errp, local_err);
1769 }
1770 return ret;
1771}
1772
1773
1774/*
1775 * Prepares a BlockDriverState for reopen. All changes are staged in the
1776 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1777 * the block driver layer .bdrv_reopen_prepare()
1778 *
1779 * bs is the BlockDriverState to reopen
1780 * flags are the new open flags
1781 * queue is the reopen queue
1782 *
1783 * Returns 0 on success, non-zero on error. On error errp will be set
1784 * as well.
1785 *
1786 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1787 * It is the responsibility of the caller to then call the abort() or
1788 * commit() for any other BDS that have been left in a prepare() state
1789 *
1790 */
1791int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1792 Error **errp)
1793{
1794 int ret = -1;
1795 Error *local_err = NULL;
1796 BlockDriver *drv;
1797
1798 assert(reopen_state != NULL);
1799 assert(reopen_state->bs->drv != NULL);
1800 drv = reopen_state->bs->drv;
1801
1802 /* if we are to stay read-only, do not allow permission change
1803 * to r/w */
1804 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1805 reopen_state->flags & BDRV_O_RDWR) {
Alberto Garcia81e5f782015-04-08 12:29:19 +03001806 error_setg(errp, "Node '%s' is read only",
1807 bdrv_get_device_or_node_name(reopen_state->bs));
Jeff Codye971aa12012-09-20 15:13:19 -04001808 goto error;
1809 }
1810
1811
1812 ret = bdrv_flush(reopen_state->bs);
1813 if (ret) {
1814 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1815 strerror(-ret));
1816 goto error;
1817 }
1818
1819 if (drv->bdrv_reopen_prepare) {
1820 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1821 if (ret) {
1822 if (local_err != NULL) {
1823 error_propagate(errp, local_err);
1824 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04001825 error_setg(errp, "failed while preparing to reopen image '%s'",
1826 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04001827 }
1828 goto error;
1829 }
1830 } else {
1831 /* It is currently mandatory to have a bdrv_reopen_prepare()
1832 * handler for each supported drv. */
Alberto Garcia81e5f782015-04-08 12:29:19 +03001833 error_setg(errp, "Block format '%s' used by node '%s' "
1834 "does not support reopening files", drv->format_name,
1835 bdrv_get_device_or_node_name(reopen_state->bs));
Jeff Codye971aa12012-09-20 15:13:19 -04001836 ret = -1;
1837 goto error;
1838 }
1839
1840 ret = 0;
1841
1842error:
1843 return ret;
1844}
1845
1846/*
1847 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1848 * makes them final by swapping the staging BlockDriverState contents into
1849 * the active BlockDriverState contents.
1850 */
1851void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1852{
1853 BlockDriver *drv;
1854
1855 assert(reopen_state != NULL);
1856 drv = reopen_state->bs->drv;
1857 assert(drv != NULL);
1858
1859 /* If there are any driver level actions to take */
1860 if (drv->bdrv_reopen_commit) {
1861 drv->bdrv_reopen_commit(reopen_state);
1862 }
1863
1864 /* set BDS specific flags now */
1865 reopen_state->bs->open_flags = reopen_state->flags;
1866 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1867 BDRV_O_CACHE_WB);
1868 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf355ef4a2013-12-11 20:14:09 +01001869
Kevin Wolf3baca892014-07-16 17:48:16 +02001870 bdrv_refresh_limits(reopen_state->bs, NULL);
Jeff Codye971aa12012-09-20 15:13:19 -04001871}
1872
1873/*
1874 * Abort the reopen, and delete and free the staged changes in
1875 * reopen_state
1876 */
1877void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1878{
1879 BlockDriver *drv;
1880
1881 assert(reopen_state != NULL);
1882 drv = reopen_state->bs->drv;
1883 assert(drv != NULL);
1884
1885 if (drv->bdrv_reopen_abort) {
1886 drv->bdrv_reopen_abort(reopen_state);
1887 }
1888}
1889
1890
bellardfc01f7e2003-06-30 10:03:06 +00001891void bdrv_close(BlockDriverState *bs)
1892{
Max Reitz33384422014-06-20 21:57:33 +02001893 BdrvAioNotifier *ban, *ban_next;
1894
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001895 if (bs->job) {
1896 block_job_cancel_sync(bs->job);
1897 }
Fam Zheng53ec73e2015-05-29 18:53:14 +08001898 bdrv_drain(bs); /* complete I/O */
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02001899 bdrv_flush(bs);
Fam Zheng53ec73e2015-05-29 18:53:14 +08001900 bdrv_drain(bs); /* in case flush left pending I/O */
Paolo Bonzinid7d512f2012-08-23 11:20:36 +02001901 notifier_list_notify(&bs->close_notifiers, bs);
Kevin Wolf7094f122012-04-11 11:06:37 +02001902
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001903 if (bs->drv) {
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02001904 BdrvChild *child, *next;
1905
Kevin Wolf9a7dedb2015-06-16 10:58:20 +02001906 bs->drv->bdrv_close(bs);
1907
1908 if (bs->backing_hd) {
1909 BlockDriverState *backing_hd = bs->backing_hd;
1910 bdrv_set_backing_hd(bs, NULL);
1911 bdrv_unref(backing_hd);
1912 }
1913
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02001914 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
Kevin Wolf33a60402015-06-15 13:51:04 +02001915 /* TODO Remove bdrv_unref() from drivers' close function and use
1916 * bdrv_unref_child() here */
Kevin Wolfbddcec32015-04-09 18:47:50 +02001917 if (child->bs->inherits_from == bs) {
1918 child->bs->inherits_from = NULL;
1919 }
Kevin Wolf33a60402015-06-15 13:51:04 +02001920 bdrv_detach_child(child);
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02001921 }
1922
Anthony Liguori7267c092011-08-20 22:09:37 -05001923 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00001924 bs->opaque = NULL;
1925 bs->drv = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001926 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02001927 bs->backing_file[0] = '\0';
1928 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02001929 bs->total_sectors = 0;
1930 bs->encrypted = 0;
1931 bs->valid_key = 0;
1932 bs->sg = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08001933 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001934 QDECREF(bs->options);
1935 bs->options = NULL;
Max Reitz91af7012014-07-18 20:24:56 +02001936 QDECREF(bs->full_open_options);
1937 bs->full_open_options = NULL;
bellardb3380822004-03-14 21:38:54 +00001938
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001939 if (bs->file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001940 bdrv_unref(bs->file);
Paolo Bonzini0ac93772012-05-08 16:51:44 +02001941 bs->file = NULL;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001942 }
bellardb3380822004-03-14 21:38:54 +00001943 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001944
Markus Armbrustera7f53e22014-10-07 13:59:25 +02001945 if (bs->blk) {
1946 blk_dev_change_media_cb(bs->blk, false);
1947 }
Pavel Hrdina9ca11152012-08-09 12:44:48 +02001948
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001949 /*throttling disk I/O limits*/
1950 if (bs->io_limits_enabled) {
1951 bdrv_io_limits_disable(bs);
1952 }
Max Reitz33384422014-06-20 21:57:33 +02001953
1954 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1955 g_free(ban);
1956 }
1957 QLIST_INIT(&bs->aio_notifiers);
bellardb3380822004-03-14 21:38:54 +00001958}
1959
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001960void bdrv_close_all(void)
1961{
1962 BlockDriverState *bs;
1963
Benoît Canetdc364f42014-01-23 21:31:32 +01001964 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02001965 AioContext *aio_context = bdrv_get_aio_context(bs);
1966
1967 aio_context_acquire(aio_context);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001968 bdrv_close(bs);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02001969 aio_context_release(aio_context);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001970 }
1971}
1972
Benoît Canetdc364f42014-01-23 21:31:32 +01001973/* make a BlockDriverState anonymous by removing from bdrv_state and
1974 * graph_bdrv_state list.
Ryan Harperd22b2f42011-03-29 20:51:47 -05001975 Also, NULL terminate the device_name to prevent double remove */
1976void bdrv_make_anon(BlockDriverState *bs)
1977{
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02001978 /*
1979 * Take care to remove bs from bdrv_states only when it's actually
1980 * in it. Note that bs->device_list.tqe_prev is initially null,
1981 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1982 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1983 * resetting it to null on remove.
1984 */
1985 if (bs->device_list.tqe_prev) {
Benoît Canetdc364f42014-01-23 21:31:32 +01001986 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02001987 bs->device_list.tqe_prev = NULL;
Ryan Harperd22b2f42011-03-29 20:51:47 -05001988 }
Benoît Canetdc364f42014-01-23 21:31:32 +01001989 if (bs->node_name[0] != '\0') {
1990 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1991 }
1992 bs->node_name[0] = '\0';
Ryan Harperd22b2f42011-03-29 20:51:47 -05001993}
1994
Paolo Bonzinie023b2e2012-05-08 16:51:41 +02001995static void bdrv_rebind(BlockDriverState *bs)
1996{
1997 if (bs->drv && bs->drv->bdrv_rebind) {
1998 bs->drv->bdrv_rebind(bs);
1999 }
2000}
2001
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002002static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
2003 BlockDriverState *bs_src)
2004{
2005 /* move some fields that need to stay attached to the device */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002006
2007 /* dev info */
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01002008 bs_dest->guest_block_size = bs_src->guest_block_size;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002009 bs_dest->copy_on_read = bs_src->copy_on_read;
2010
2011 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2012
Benoît Canetcc0681c2013-09-02 14:14:39 +02002013 /* i/o throttled req */
Alberto Garcia76f4afb2015-06-08 18:17:44 +02002014 bs_dest->throttle_state = bs_src->throttle_state,
2015 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
2016 bs_dest->pending_reqs[0] = bs_src->pending_reqs[0];
2017 bs_dest->pending_reqs[1] = bs_src->pending_reqs[1];
2018 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
2019 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
2020 memcpy(&bs_dest->round_robin,
2021 &bs_src->round_robin,
2022 sizeof(bs_dest->round_robin));
Benoît Canet0e5b0a22015-06-08 18:17:41 +02002023 memcpy(&bs_dest->throttle_timers,
2024 &bs_src->throttle_timers,
2025 sizeof(ThrottleTimers));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002026
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002027 /* r/w error */
2028 bs_dest->on_read_error = bs_src->on_read_error;
2029 bs_dest->on_write_error = bs_src->on_write_error;
2030
2031 /* i/o status */
2032 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
2033 bs_dest->iostatus = bs_src->iostatus;
2034
2035 /* dirty bitmap */
Fam Zhenge4654d22013-11-13 18:29:43 +08002036 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002037
Fam Zheng9fcb0252013-08-23 09:14:46 +08002038 /* reference count */
2039 bs_dest->refcnt = bs_src->refcnt;
2040
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002041 /* job */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002042 bs_dest->job = bs_src->job;
2043
2044 /* keep the same entry in bdrv_states */
Benoît Canetdc364f42014-01-23 21:31:32 +01002045 bs_dest->device_list = bs_src->device_list;
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002046 bs_dest->blk = bs_src->blk;
2047
Fam Zhengfbe40ff2014-05-23 21:29:42 +08002048 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2049 sizeof(bs_dest->op_blockers));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002050}
2051
2052/*
2053 * Swap bs contents for two image chains while they are live,
2054 * while keeping required fields on the BlockDriverState that is
2055 * actually attached to a device.
2056 *
2057 * This will modify the BlockDriverState fields, and swap contents
2058 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2059 *
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002060 * bs_new must not be attached to a BlockBackend.
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002061 *
2062 * This function does not create any image files.
2063 */
2064void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2065{
2066 BlockDriverState tmp;
Kevin Wolfbddcec32015-04-09 18:47:50 +02002067 BdrvChild *child;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002068
Kevin Wolf6ee4ce12015-06-10 13:33:17 +02002069 bdrv_drain(bs_new);
2070 bdrv_drain(bs_old);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002071
Benoît Canet90ce8a02014-03-05 23:48:29 +01002072 /* The code needs to swap the node_name but simply swapping node_list won't
2073 * work so first remove the nodes from the graph list, do the swap then
2074 * insert them back if needed.
2075 */
2076 if (bs_new->node_name[0] != '\0') {
2077 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2078 }
2079 if (bs_old->node_name[0] != '\0') {
2080 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2081 }
2082
Alberto Garciadb628332015-06-08 18:17:45 +02002083 /* If the BlockDriverState is part of a throttling group acquire
2084 * its lock since we're going to mess with the protected fields.
2085 * Otherwise there's no need to worry since no one else can touch
2086 * them. */
2087 if (bs_old->throttle_state) {
2088 throttle_group_lock(bs_old);
2089 }
2090
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002091 /* bs_new must be unattached and shouldn't have anything fancy enabled */
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002092 assert(!bs_new->blk);
Fam Zhenge4654d22013-11-13 18:29:43 +08002093 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002094 assert(bs_new->job == NULL);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002095 assert(bs_new->io_limits_enabled == false);
Alberto Garciadb628332015-06-08 18:17:45 +02002096 assert(bs_new->throttle_state == NULL);
Benoît Canet0e5b0a22015-06-08 18:17:41 +02002097 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002098
2099 tmp = *bs_new;
2100 *bs_new = *bs_old;
2101 *bs_old = tmp;
2102
2103 /* there are some fields that should not be swapped, move them back */
2104 bdrv_move_feature_fields(&tmp, bs_old);
2105 bdrv_move_feature_fields(bs_old, bs_new);
2106 bdrv_move_feature_fields(bs_new, &tmp);
2107
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002108 /* bs_new must remain unattached */
Markus Armbruster7e7d56d2014-10-07 13:59:05 +02002109 assert(!bs_new->blk);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002110
2111 /* Check a few fields that should remain attached to the device */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002112 assert(bs_new->job == NULL);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002113 assert(bs_new->io_limits_enabled == false);
Alberto Garciadb628332015-06-08 18:17:45 +02002114 assert(bs_new->throttle_state == NULL);
Benoît Canet0e5b0a22015-06-08 18:17:41 +02002115 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002116
Alberto Garciadb628332015-06-08 18:17:45 +02002117 /* Release the ThrottleGroup lock */
2118 if (bs_old->throttle_state) {
2119 throttle_group_unlock(bs_old);
2120 }
2121
Benoît Canet90ce8a02014-03-05 23:48:29 +01002122 /* insert the nodes back into the graph node list if needed */
2123 if (bs_new->node_name[0] != '\0') {
2124 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2125 }
2126 if (bs_old->node_name[0] != '\0') {
2127 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2128 }
2129
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02002130 /*
2131 * Update lh_first.le_prev for non-empty lists.
2132 *
2133 * The head of the op blocker list doesn't change because it is moved back
2134 * in bdrv_move_feature_fields().
2135 */
Kevin Wolf6ee4ce12015-06-10 13:33:17 +02002136 assert(QLIST_EMPTY(&bs_old->tracked_requests));
2137 assert(QLIST_EMPTY(&bs_new->tracked_requests));
2138
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02002139 QLIST_FIX_HEAD_PTR(&bs_new->children, next);
2140 QLIST_FIX_HEAD_PTR(&bs_old->children, next);
2141
Kevin Wolfbddcec32015-04-09 18:47:50 +02002142 /* Update references in bs->opaque and children */
2143 QLIST_FOREACH(child, &bs_old->children, next) {
2144 if (child->bs->inherits_from == bs_new) {
2145 child->bs->inherits_from = bs_old;
2146 }
2147 }
2148 QLIST_FOREACH(child, &bs_new->children, next) {
2149 if (child->bs->inherits_from == bs_old) {
2150 child->bs->inherits_from = bs_new;
2151 }
2152 }
2153
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002154 bdrv_rebind(bs_new);
2155 bdrv_rebind(bs_old);
2156}
2157
Jeff Cody8802d1f2012-02-28 15:54:06 -05002158/*
2159 * Add new bs contents at the top of an image chain while the chain is
2160 * live, while keeping required fields on the top layer.
2161 *
2162 * This will modify the BlockDriverState fields, and swap contents
2163 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2164 *
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002165 * bs_new must not be attached to a BlockBackend.
Jeff Codyf6801b82012-03-27 16:30:19 -04002166 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05002167 * This function does not create any image files.
2168 */
2169void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2170{
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002171 bdrv_swap(bs_new, bs_top);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002172
2173 /* The contents of 'tmp' will become bs_top, as we are
2174 * swapping bs_new and bs_top contents. */
Fam Zheng8d24cce2014-05-23 21:29:45 +08002175 bdrv_set_backing_hd(bs_top, bs_new);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002176}
2177
Fam Zheng4f6fd342013-08-23 09:14:47 +08002178static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00002179{
Paolo Bonzini3e914652012-03-30 13:17:11 +02002180 assert(!bs->job);
Fam Zheng3718d8a2014-05-23 21:29:43 +08002181 assert(bdrv_op_blocker_is_empty(bs));
Fam Zheng4f6fd342013-08-23 09:14:47 +08002182 assert(!bs->refcnt);
Fam Zhenge4654d22013-11-13 18:29:43 +08002183 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Markus Armbruster18846de2010-06-29 16:58:30 +02002184
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02002185 bdrv_close(bs);
2186
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002187 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05002188 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00002189
Anthony Liguori7267c092011-08-20 22:09:37 -05002190 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00002191}
2192
aliguorie97fc192009-04-21 23:11:50 +00002193/*
2194 * Run consistency checks on an image
2195 *
Kevin Wolfe076f332010-06-29 11:43:13 +02002196 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02002197 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02002198 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00002199 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02002200int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00002201{
Max Reitz908bcd52014-08-07 22:47:55 +02002202 if (bs->drv == NULL) {
2203 return -ENOMEDIUM;
2204 }
aliguorie97fc192009-04-21 23:11:50 +00002205 if (bs->drv->bdrv_check == NULL) {
2206 return -ENOTSUP;
2207 }
2208
Kevin Wolfe076f332010-06-29 11:43:13 +02002209 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02002210 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00002211}
2212
Kevin Wolf8a426612010-07-16 17:17:01 +02002213#define COMMIT_BUF_SECTORS 2048
2214
bellard33e39632003-07-06 17:15:21 +00002215/* commit COW file into the raw image */
2216int bdrv_commit(BlockDriverState *bs)
2217{
bellard19cb3732006-08-19 11:45:59 +00002218 BlockDriver *drv = bs->drv;
Jeff Cody72706ea2014-01-24 09:02:35 -05002219 int64_t sector, total_sectors, length, backing_length;
Kevin Wolf8a426612010-07-16 17:17:01 +02002220 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04002221 int ret = 0;
Jeff Cody72706ea2014-01-24 09:02:35 -05002222 uint8_t *buf = NULL;
bellard33e39632003-07-06 17:15:21 +00002223
bellard19cb3732006-08-19 11:45:59 +00002224 if (!drv)
2225 return -ENOMEDIUM;
Liu Yuan6bb45152014-09-01 13:35:21 +08002226
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002227 if (!bs->backing_hd) {
2228 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00002229 }
2230
Fam Zhengbb000212014-09-11 13:14:00 +08002231 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2232 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00002233 return -EBUSY;
2234 }
2235
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002236 ro = bs->backing_hd->read_only;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002237 open_flags = bs->backing_hd->open_flags;
2238
2239 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002240 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2241 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002242 }
bellard33e39632003-07-06 17:15:21 +00002243 }
bellardea2384d2004-08-01 21:59:26 +00002244
Jeff Cody72706ea2014-01-24 09:02:35 -05002245 length = bdrv_getlength(bs);
2246 if (length < 0) {
2247 ret = length;
2248 goto ro_cleanup;
2249 }
2250
2251 backing_length = bdrv_getlength(bs->backing_hd);
2252 if (backing_length < 0) {
2253 ret = backing_length;
2254 goto ro_cleanup;
2255 }
2256
2257 /* If our top snapshot is larger than the backing file image,
2258 * grow the backing file image if possible. If not possible,
2259 * we must return an error */
2260 if (length > backing_length) {
2261 ret = bdrv_truncate(bs->backing_hd, length);
2262 if (ret < 0) {
2263 goto ro_cleanup;
2264 }
2265 }
2266
2267 total_sectors = length >> BDRV_SECTOR_BITS;
Kevin Wolf857d4f42014-05-20 13:16:51 +02002268
2269 /* qemu_try_blockalign() for bs will choose an alignment that works for
2270 * bs->backing_hd as well, so no need to compare the alignment manually. */
2271 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2272 if (buf == NULL) {
2273 ret = -ENOMEM;
2274 goto ro_cleanup;
2275 }
bellardea2384d2004-08-01 21:59:26 +00002276
Kevin Wolf8a426612010-07-16 17:17:01 +02002277 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02002278 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2279 if (ret < 0) {
2280 goto ro_cleanup;
2281 }
2282 if (ret) {
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002283 ret = bdrv_read(bs, sector, buf, n);
2284 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002285 goto ro_cleanup;
2286 }
2287
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002288 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2289 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002290 goto ro_cleanup;
2291 }
bellardea2384d2004-08-01 21:59:26 +00002292 }
2293 }
bellard95389c82005-12-18 18:28:15 +00002294
Christoph Hellwig1d449522010-01-17 12:32:30 +01002295 if (drv->bdrv_make_empty) {
2296 ret = drv->bdrv_make_empty(bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002297 if (ret < 0) {
2298 goto ro_cleanup;
2299 }
Christoph Hellwig1d449522010-01-17 12:32:30 +01002300 bdrv_flush(bs);
2301 }
bellard95389c82005-12-18 18:28:15 +00002302
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002303 /*
2304 * Make sure all data we wrote to the backing device is actually
2305 * stable on disk.
2306 */
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002307 if (bs->backing_hd) {
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002308 bdrv_flush(bs->backing_hd);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002309 }
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002310
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002311 ret = 0;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002312ro_cleanup:
Kevin Wolf857d4f42014-05-20 13:16:51 +02002313 qemu_vfree(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002314
2315 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002316 /* ignoring error return here */
2317 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002318 }
2319
Christoph Hellwig1d449522010-01-17 12:32:30 +01002320 return ret;
bellard33e39632003-07-06 17:15:21 +00002321}
2322
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002323int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002324{
2325 BlockDriverState *bs;
2326
Benoît Canetdc364f42014-01-23 21:31:32 +01002327 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002328 AioContext *aio_context = bdrv_get_aio_context(bs);
2329
2330 aio_context_acquire(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002331 if (bs->drv && bs->backing_hd) {
2332 int ret = bdrv_commit(bs);
2333 if (ret < 0) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002334 aio_context_release(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002335 return ret;
2336 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002337 }
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002338 aio_context_release(aio_context);
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002339 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002340 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002341}
2342
Kevin Wolf756e6732010-01-12 12:55:17 +01002343/*
2344 * Return values:
2345 * 0 - success
2346 * -EINVAL - backing format specified, but no file
2347 * -ENOSPC - can't update the backing file because no space is left in the
2348 * image file header
2349 * -ENOTSUP - format driver doesn't support changing the backing file
2350 */
2351int bdrv_change_backing_file(BlockDriverState *bs,
2352 const char *backing_file, const char *backing_fmt)
2353{
2354 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002355 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002356
Paolo Bonzini5f377792012-04-12 14:01:01 +02002357 /* Backing file format doesn't make sense without a backing file */
2358 if (backing_fmt && !backing_file) {
2359 return -EINVAL;
2360 }
2361
Kevin Wolf756e6732010-01-12 12:55:17 +01002362 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002363 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002364 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002365 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002366 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002367
2368 if (ret == 0) {
2369 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2370 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2371 }
2372 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002373}
2374
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002375/*
2376 * Finds the image layer in the chain that has 'bs' as its backing file.
2377 *
2378 * active is the current topmost image.
2379 *
2380 * Returns NULL if bs is not found in active's image chain,
2381 * or if active == bs.
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002382 *
2383 * Returns the bottommost base image if bs == NULL.
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002384 */
2385BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2386 BlockDriverState *bs)
2387{
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002388 while (active && bs != active->backing_hd) {
2389 active = active->backing_hd;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002390 }
2391
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002392 return active;
2393}
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002394
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002395/* Given a BDS, searches for the base layer. */
2396BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2397{
2398 return bdrv_find_overlay(bs, NULL);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002399}
2400
2401typedef struct BlkIntermediateStates {
2402 BlockDriverState *bs;
2403 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2404} BlkIntermediateStates;
2405
2406
2407/*
2408 * Drops images above 'base' up to and including 'top', and sets the image
2409 * above 'top' to have base as its backing file.
2410 *
2411 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2412 * information in 'bs' can be properly updated.
2413 *
2414 * E.g., this will convert the following chain:
2415 * bottom <- base <- intermediate <- top <- active
2416 *
2417 * to
2418 *
2419 * bottom <- base <- active
2420 *
2421 * It is allowed for bottom==base, in which case it converts:
2422 *
2423 * base <- intermediate <- top <- active
2424 *
2425 * to
2426 *
2427 * base <- active
2428 *
Jeff Cody54e26902014-06-25 15:40:10 -04002429 * If backing_file_str is non-NULL, it will be used when modifying top's
2430 * overlay image metadata.
2431 *
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002432 * Error conditions:
2433 * if active == top, that is considered an error
2434 *
2435 */
2436int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
Jeff Cody54e26902014-06-25 15:40:10 -04002437 BlockDriverState *base, const char *backing_file_str)
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002438{
2439 BlockDriverState *intermediate;
2440 BlockDriverState *base_bs = NULL;
2441 BlockDriverState *new_top_bs = NULL;
2442 BlkIntermediateStates *intermediate_state, *next;
2443 int ret = -EIO;
2444
2445 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2446 QSIMPLEQ_INIT(&states_to_delete);
2447
2448 if (!top->drv || !base->drv) {
2449 goto exit;
2450 }
2451
2452 new_top_bs = bdrv_find_overlay(active, top);
2453
2454 if (new_top_bs == NULL) {
2455 /* we could not find the image above 'top', this is an error */
2456 goto exit;
2457 }
2458
2459 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2460 * to do, no intermediate images */
2461 if (new_top_bs->backing_hd == base) {
2462 ret = 0;
2463 goto exit;
2464 }
2465
2466 intermediate = top;
2467
2468 /* now we will go down through the list, and add each BDS we find
2469 * into our deletion queue, until we hit the 'base'
2470 */
2471 while (intermediate) {
Markus Armbruster5839e532014-08-19 10:31:08 +02002472 intermediate_state = g_new0(BlkIntermediateStates, 1);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002473 intermediate_state->bs = intermediate;
2474 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2475
2476 if (intermediate->backing_hd == base) {
2477 base_bs = intermediate->backing_hd;
2478 break;
2479 }
2480 intermediate = intermediate->backing_hd;
2481 }
2482 if (base_bs == NULL) {
2483 /* something went wrong, we did not end at the base. safely
2484 * unravel everything, and exit with error */
2485 goto exit;
2486 }
2487
2488 /* success - we can delete the intermediate states, and link top->base */
Jeff Cody54e26902014-06-25 15:40:10 -04002489 backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2490 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002491 base_bs->drv ? base_bs->drv->format_name : "");
2492 if (ret) {
2493 goto exit;
2494 }
Fam Zheng920beae2014-05-23 21:29:46 +08002495 bdrv_set_backing_hd(new_top_bs, base_bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002496
2497 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2498 /* so that bdrv_close() does not recursively close the chain */
Fam Zheng920beae2014-05-23 21:29:46 +08002499 bdrv_set_backing_hd(intermediate_state->bs, NULL);
Fam Zheng4f6fd342013-08-23 09:14:47 +08002500 bdrv_unref(intermediate_state->bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002501 }
2502 ret = 0;
2503
2504exit:
2505 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2506 g_free(intermediate_state);
2507 }
2508 return ret;
2509}
2510
bellard83f64092006-08-01 16:21:11 +00002511/**
bellard83f64092006-08-01 16:21:11 +00002512 * Truncate file to 'offset' bytes (needed only for file protocols)
2513 */
2514int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2515{
2516 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002517 int ret;
bellard83f64092006-08-01 16:21:11 +00002518 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002519 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00002520 if (!drv->bdrv_truncate)
2521 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02002522 if (bs->read_only)
2523 return -EACCES;
Jeff Cody9c75e162014-06-25 16:55:30 -04002524
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002525 ret = drv->bdrv_truncate(bs, offset);
2526 if (ret == 0) {
2527 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
John Snowce1ffea2015-04-17 19:50:03 -04002528 bdrv_dirty_bitmap_truncate(bs);
Markus Armbrustera7f53e22014-10-07 13:59:25 +02002529 if (bs->blk) {
2530 blk_dev_resize_cb(bs->blk);
2531 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002532 }
2533 return ret;
bellard83f64092006-08-01 16:21:11 +00002534}
2535
2536/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002537 * Length of a allocated file in bytes. Sparse files are counted by actual
2538 * allocated space. Return < 0 if error or unknown.
2539 */
2540int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2541{
2542 BlockDriver *drv = bs->drv;
2543 if (!drv) {
2544 return -ENOMEDIUM;
2545 }
2546 if (drv->bdrv_get_allocated_file_size) {
2547 return drv->bdrv_get_allocated_file_size(bs);
2548 }
2549 if (bs->file) {
2550 return bdrv_get_allocated_file_size(bs->file);
2551 }
2552 return -ENOTSUP;
2553}
2554
2555/**
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002556 * Return number of sectors on success, -errno on error.
bellard83f64092006-08-01 16:21:11 +00002557 */
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002558int64_t bdrv_nb_sectors(BlockDriverState *bs)
bellard83f64092006-08-01 16:21:11 +00002559{
2560 BlockDriver *drv = bs->drv;
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002561
bellard83f64092006-08-01 16:21:11 +00002562 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002563 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002564
Kevin Wolfb94a2612013-10-29 12:18:58 +01002565 if (drv->has_variable_length) {
2566 int ret = refresh_total_sectors(bs, bs->total_sectors);
2567 if (ret < 0) {
2568 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002569 }
bellard83f64092006-08-01 16:21:11 +00002570 }
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002571 return bs->total_sectors;
2572}
2573
2574/**
2575 * Return length in bytes on success, -errno on error.
2576 * The length is always a multiple of BDRV_SECTOR_SIZE.
2577 */
2578int64_t bdrv_getlength(BlockDriverState *bs)
2579{
2580 int64_t ret = bdrv_nb_sectors(bs);
2581
Fam Zheng4a9c9ea2015-05-15 16:36:05 +08002582 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002583 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00002584}
2585
bellard19cb3732006-08-19 11:45:59 +00002586/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00002587void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00002588{
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002589 int64_t nb_sectors = bdrv_nb_sectors(bs);
2590
2591 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
bellardfc01f7e2003-06-30 10:03:06 +00002592}
bellardcf989512004-02-16 21:56:36 +00002593
Paolo Bonziniff06f5f2012-09-28 17:22:54 +02002594void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2595 BlockdevOnError on_write_error)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02002596{
2597 bs->on_read_error = on_read_error;
2598 bs->on_write_error = on_write_error;
2599}
2600
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +02002601BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02002602{
2603 return is_read ? bs->on_read_error : bs->on_write_error;
2604}
2605
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002606BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2607{
2608 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2609
2610 switch (on_err) {
2611 case BLOCKDEV_ON_ERROR_ENOSPC:
Wenchao Xiaa5895692014-06-18 08:43:30 +02002612 return (error == ENOSPC) ?
2613 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002614 case BLOCKDEV_ON_ERROR_STOP:
Wenchao Xiaa5895692014-06-18 08:43:30 +02002615 return BLOCK_ERROR_ACTION_STOP;
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002616 case BLOCKDEV_ON_ERROR_REPORT:
Wenchao Xiaa5895692014-06-18 08:43:30 +02002617 return BLOCK_ERROR_ACTION_REPORT;
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002618 case BLOCKDEV_ON_ERROR_IGNORE:
Wenchao Xiaa5895692014-06-18 08:43:30 +02002619 return BLOCK_ERROR_ACTION_IGNORE;
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002620 default:
2621 abort();
2622 }
2623}
2624
Luiz Capitulinoc7c2ff02014-08-29 16:07:27 -04002625static void send_qmp_error_event(BlockDriverState *bs,
2626 BlockErrorAction action,
2627 bool is_read, int error)
2628{
Peter Maydell573742a2014-10-10 20:33:03 +01002629 IoOperationType optype;
Luiz Capitulinoc7c2ff02014-08-29 16:07:27 -04002630
Peter Maydell573742a2014-10-10 20:33:03 +01002631 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2632 qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
Luiz Capitulinoc7c2ff02014-08-29 16:07:27 -04002633 bdrv_iostatus_is_enabled(bs),
Luiz Capitulino624ff572014-09-11 10:25:48 -04002634 error == ENOSPC, strerror(error),
2635 &error_abort);
Luiz Capitulinoc7c2ff02014-08-29 16:07:27 -04002636}
2637
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002638/* This is done by device models because, while the block layer knows
2639 * about the error, it does not know whether an operation comes from
2640 * the device or the block layer (from a job, for example).
2641 */
2642void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2643 bool is_read, int error)
2644{
2645 assert(error >= 0);
Paolo Bonzini2bd3bce2014-06-05 14:53:59 +02002646
Wenchao Xiaa5895692014-06-18 08:43:30 +02002647 if (action == BLOCK_ERROR_ACTION_STOP) {
Paolo Bonzini2bd3bce2014-06-05 14:53:59 +02002648 /* First set the iostatus, so that "info block" returns an iostatus
2649 * that matches the events raised so far (an additional error iostatus
2650 * is fine, but not a lost one).
2651 */
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002652 bdrv_iostatus_set_err(bs, error);
Paolo Bonzini2bd3bce2014-06-05 14:53:59 +02002653
2654 /* Then raise the request to stop the VM and the event.
2655 * qemu_system_vmstop_request_prepare has two effects. First,
2656 * it ensures that the STOP event always comes after the
2657 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2658 * can observe the STOP event and do a "cont" before the STOP
2659 * event is issued, the VM will not stop. In this case, vm_start()
2660 * also ensures that the STOP/RESUME pair of events is emitted.
2661 */
2662 qemu_system_vmstop_request_prepare();
Luiz Capitulinoc7c2ff02014-08-29 16:07:27 -04002663 send_qmp_error_event(bs, action, is_read, error);
Paolo Bonzini2bd3bce2014-06-05 14:53:59 +02002664 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2665 } else {
Luiz Capitulinoc7c2ff02014-08-29 16:07:27 -04002666 send_qmp_error_event(bs, action, is_read, error);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002667 }
2668}
2669
bellardb3380822004-03-14 21:38:54 +00002670int bdrv_is_read_only(BlockDriverState *bs)
2671{
2672 return bs->read_only;
2673}
2674
ths985a03b2007-12-24 16:10:43 +00002675int bdrv_is_sg(BlockDriverState *bs)
2676{
2677 return bs->sg;
2678}
2679
Christoph Hellwige900a7b2009-09-04 19:01:15 +02002680int bdrv_enable_write_cache(BlockDriverState *bs)
2681{
2682 return bs->enable_write_cache;
2683}
2684
Paolo Bonzini425b0142012-06-06 00:04:52 +02002685void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2686{
2687 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04002688
2689 /* so a reopen() will preserve wce */
2690 if (wce) {
2691 bs->open_flags |= BDRV_O_CACHE_WB;
2692 } else {
2693 bs->open_flags &= ~BDRV_O_CACHE_WB;
2694 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02002695}
2696
bellardea2384d2004-08-01 21:59:26 +00002697int bdrv_is_encrypted(BlockDriverState *bs)
2698{
2699 if (bs->backing_hd && bs->backing_hd->encrypted)
2700 return 1;
2701 return bs->encrypted;
2702}
2703
aliguoric0f4ce72009-03-05 23:01:01 +00002704int bdrv_key_required(BlockDriverState *bs)
2705{
2706 BlockDriverState *backing_hd = bs->backing_hd;
2707
2708 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2709 return 1;
2710 return (bs->encrypted && !bs->valid_key);
2711}
2712
bellardea2384d2004-08-01 21:59:26 +00002713int bdrv_set_key(BlockDriverState *bs, const char *key)
2714{
2715 int ret;
2716 if (bs->backing_hd && bs->backing_hd->encrypted) {
2717 ret = bdrv_set_key(bs->backing_hd, key);
2718 if (ret < 0)
2719 return ret;
2720 if (!bs->encrypted)
2721 return 0;
2722 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02002723 if (!bs->encrypted) {
2724 return -EINVAL;
2725 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2726 return -ENOMEDIUM;
2727 }
aliguoric0f4ce72009-03-05 23:01:01 +00002728 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00002729 if (ret < 0) {
2730 bs->valid_key = 0;
2731 } else if (!bs->valid_key) {
2732 bs->valid_key = 1;
Markus Armbrustera7f53e22014-10-07 13:59:25 +02002733 if (bs->blk) {
2734 /* call the change callback now, we skipped it on open */
2735 blk_dev_change_media_cb(bs->blk, true);
2736 }
aliguoribb5fc202009-03-05 23:01:15 +00002737 }
aliguoric0f4ce72009-03-05 23:01:01 +00002738 return ret;
bellardea2384d2004-08-01 21:59:26 +00002739}
2740
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002741/*
2742 * Provide an encryption key for @bs.
2743 * If @key is non-null:
2744 * If @bs is not encrypted, fail.
2745 * Else if the key is invalid, fail.
2746 * Else set @bs's key to @key, replacing the existing key, if any.
2747 * If @key is null:
2748 * If @bs is encrypted and still lacks a key, fail.
2749 * Else do nothing.
2750 * On failure, store an error object through @errp if non-null.
2751 */
2752void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2753{
2754 if (key) {
2755 if (!bdrv_is_encrypted(bs)) {
Alberto Garcia81e5f782015-04-08 12:29:19 +03002756 error_setg(errp, "Node '%s' is not encrypted",
2757 bdrv_get_device_or_node_name(bs));
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002758 } else if (bdrv_set_key(bs, key) < 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002759 error_setg(errp, QERR_INVALID_PASSWORD);
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002760 }
2761 } else {
2762 if (bdrv_key_required(bs)) {
Markus Armbrusterb1ca6392015-01-29 10:37:01 +01002763 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2764 "'%s' (%s) is encrypted",
Alberto Garcia81e5f782015-04-08 12:29:19 +03002765 bdrv_get_device_or_node_name(bs),
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002766 bdrv_get_encrypted_filename(bs));
2767 }
2768 }
2769}
2770
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02002771const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00002772{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02002773 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00002774}
2775
Stefan Hajnocziada42402014-08-27 12:08:55 +01002776static int qsort_strcmp(const void *a, const void *b)
2777{
2778 return strcmp(a, b);
2779}
2780
ths5fafdf22007-09-16 21:08:06 +00002781void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00002782 void *opaque)
2783{
2784 BlockDriver *drv;
Jeff Codye855e4f2014-04-28 18:29:54 -04002785 int count = 0;
Stefan Hajnocziada42402014-08-27 12:08:55 +01002786 int i;
Jeff Codye855e4f2014-04-28 18:29:54 -04002787 const char **formats = NULL;
bellardea2384d2004-08-01 21:59:26 +00002788
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01002789 QLIST_FOREACH(drv, &bdrv_drivers, list) {
Jeff Codye855e4f2014-04-28 18:29:54 -04002790 if (drv->format_name) {
2791 bool found = false;
2792 int i = count;
2793 while (formats && i && !found) {
2794 found = !strcmp(formats[--i], drv->format_name);
2795 }
2796
2797 if (!found) {
Markus Armbruster5839e532014-08-19 10:31:08 +02002798 formats = g_renew(const char *, formats, count + 1);
Jeff Codye855e4f2014-04-28 18:29:54 -04002799 formats[count++] = drv->format_name;
Jeff Codye855e4f2014-04-28 18:29:54 -04002800 }
2801 }
bellardea2384d2004-08-01 21:59:26 +00002802 }
Stefan Hajnocziada42402014-08-27 12:08:55 +01002803
2804 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2805
2806 for (i = 0; i < count; i++) {
2807 it(opaque, formats[i]);
2808 }
2809
Jeff Codye855e4f2014-04-28 18:29:54 -04002810 g_free(formats);
bellardea2384d2004-08-01 21:59:26 +00002811}
2812
Benoît Canetdc364f42014-01-23 21:31:32 +01002813/* This function is to find a node in the bs graph */
2814BlockDriverState *bdrv_find_node(const char *node_name)
2815{
2816 BlockDriverState *bs;
2817
2818 assert(node_name);
2819
2820 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2821 if (!strcmp(node_name, bs->node_name)) {
2822 return bs;
2823 }
2824 }
2825 return NULL;
2826}
2827
Benoît Canetc13163f2014-01-23 21:31:34 +01002828/* Put this QMP function here so it can access the static graph_bdrv_states. */
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002829BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
Benoît Canetc13163f2014-01-23 21:31:34 +01002830{
2831 BlockDeviceInfoList *list, *entry;
2832 BlockDriverState *bs;
2833
2834 list = NULL;
2835 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002836 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2837 if (!info) {
2838 qapi_free_BlockDeviceInfoList(list);
2839 return NULL;
2840 }
Benoît Canetc13163f2014-01-23 21:31:34 +01002841 entry = g_malloc0(sizeof(*entry));
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002842 entry->value = info;
Benoît Canetc13163f2014-01-23 21:31:34 +01002843 entry->next = list;
2844 list = entry;
2845 }
2846
2847 return list;
2848}
2849
Benoît Canet12d3ba82014-01-23 21:31:35 +01002850BlockDriverState *bdrv_lookup_bs(const char *device,
2851 const char *node_name,
2852 Error **errp)
2853{
Markus Armbruster7f06d472014-10-07 13:59:12 +02002854 BlockBackend *blk;
2855 BlockDriverState *bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01002856
Benoît Canet12d3ba82014-01-23 21:31:35 +01002857 if (device) {
Markus Armbruster7f06d472014-10-07 13:59:12 +02002858 blk = blk_by_name(device);
Benoît Canet12d3ba82014-01-23 21:31:35 +01002859
Markus Armbruster7f06d472014-10-07 13:59:12 +02002860 if (blk) {
2861 return blk_bs(blk);
Benoît Canet12d3ba82014-01-23 21:31:35 +01002862 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01002863 }
2864
Benoît Canetdd67fa52014-02-12 17:15:06 +01002865 if (node_name) {
2866 bs = bdrv_find_node(node_name);
Benoît Canet12d3ba82014-01-23 21:31:35 +01002867
Benoît Canetdd67fa52014-02-12 17:15:06 +01002868 if (bs) {
2869 return bs;
2870 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01002871 }
2872
Benoît Canetdd67fa52014-02-12 17:15:06 +01002873 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2874 device ? device : "",
2875 node_name ? node_name : "");
2876 return NULL;
Benoît Canet12d3ba82014-01-23 21:31:35 +01002877}
2878
Jeff Cody5a6684d2014-06-25 15:40:09 -04002879/* If 'base' is in the same chain as 'top', return true. Otherwise,
2880 * return false. If either argument is NULL, return false. */
2881bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2882{
2883 while (top && top != base) {
2884 top = top->backing_hd;
2885 }
2886
2887 return top != NULL;
2888}
2889
Fam Zheng04df7652014-10-31 11:32:54 +08002890BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2891{
2892 if (!bs) {
2893 return QTAILQ_FIRST(&graph_bdrv_states);
2894 }
2895 return QTAILQ_NEXT(bs, node_list);
2896}
2897
Markus Armbruster2f399b02010-06-02 18:55:20 +02002898BlockDriverState *bdrv_next(BlockDriverState *bs)
2899{
2900 if (!bs) {
2901 return QTAILQ_FIRST(&bdrv_states);
2902 }
Benoît Canetdc364f42014-01-23 21:31:32 +01002903 return QTAILQ_NEXT(bs, device_list);
Markus Armbruster2f399b02010-06-02 18:55:20 +02002904}
2905
Fam Zheng20a9e772014-10-31 11:32:55 +08002906const char *bdrv_get_node_name(const BlockDriverState *bs)
2907{
2908 return bs->node_name;
2909}
2910
Markus Armbruster7f06d472014-10-07 13:59:12 +02002911/* TODO check what callers really want: bs->node_name or blk_name() */
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002912const char *bdrv_get_device_name(const BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00002913{
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002914 return bs->blk ? blk_name(bs->blk) : "";
bellardea2384d2004-08-01 21:59:26 +00002915}
2916
Alberto Garcia9b2aa842015-04-08 12:29:18 +03002917/* This can be used to identify nodes that might not have a device
2918 * name associated. Since node and device names live in the same
2919 * namespace, the result is unambiguous. The exception is if both are
2920 * absent, then this returns an empty (non-null) string. */
2921const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2922{
2923 return bs->blk ? blk_name(bs->blk) : bs->node_name;
2924}
2925
Markus Armbrusterc8433282012-06-05 16:49:24 +02002926int bdrv_get_flags(BlockDriverState *bs)
2927{
2928 return bs->open_flags;
2929}
2930
Peter Lieven3ac21622013-06-28 12:47:42 +02002931int bdrv_has_zero_init_1(BlockDriverState *bs)
2932{
2933 return 1;
2934}
2935
Kevin Wolff2feebb2010-04-14 17:30:35 +02002936int bdrv_has_zero_init(BlockDriverState *bs)
2937{
2938 assert(bs->drv);
2939
Paolo Bonzini11212d82013-09-04 19:00:27 +02002940 /* If BS is a copy on write image, it is initialized to
2941 the contents of the base image, which may not be zeroes. */
2942 if (bs->backing_hd) {
2943 return 0;
2944 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02002945 if (bs->drv->bdrv_has_zero_init) {
2946 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02002947 }
2948
Peter Lieven3ac21622013-06-28 12:47:42 +02002949 /* safe default */
2950 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02002951}
2952
Peter Lieven4ce78692013-10-24 12:06:54 +02002953bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2954{
2955 BlockDriverInfo bdi;
2956
2957 if (bs->backing_hd) {
2958 return false;
2959 }
2960
2961 if (bdrv_get_info(bs, &bdi) == 0) {
2962 return bdi.unallocated_blocks_are_zero;
2963 }
2964
2965 return false;
2966}
2967
2968bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2969{
2970 BlockDriverInfo bdi;
2971
2972 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
2973 return false;
2974 }
2975
2976 if (bdrv_get_info(bs, &bdi) == 0) {
2977 return bdi.can_write_zeroes_with_unmap;
2978 }
2979
2980 return false;
2981}
2982
aliguori045df332009-03-05 23:00:48 +00002983const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2984{
2985 if (bs->backing_hd && bs->backing_hd->encrypted)
2986 return bs->backing_file;
2987 else if (bs->encrypted)
2988 return bs->filename;
2989 else
2990 return NULL;
2991}
2992
ths5fafdf22007-09-16 21:08:06 +00002993void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00002994 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00002995{
Kevin Wolf3574c602011-10-26 11:02:11 +02002996 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00002997}
2998
bellardfaea38e2006-08-05 21:31:00 +00002999int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3000{
3001 BlockDriver *drv = bs->drv;
3002 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003003 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003004 if (!drv->bdrv_get_info)
3005 return -ENOTSUP;
3006 memset(bdi, 0, sizeof(*bdi));
3007 return drv->bdrv_get_info(bs, bdi);
3008}
3009
Max Reitzeae041f2013-10-09 10:46:16 +02003010ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3011{
3012 BlockDriver *drv = bs->drv;
3013 if (drv && drv->bdrv_get_specific_info) {
3014 return drv->bdrv_get_specific_info(bs);
3015 }
3016 return NULL;
3017}
3018
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003019void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3020{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003021 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003022 return;
3023 }
3024
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003025 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01003026}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003027
Kevin Wolf41c695c2012-12-06 14:32:58 +01003028int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3029 const char *tag)
3030{
3031 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3032 bs = bs->file;
3033 }
3034
3035 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3036 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3037 }
3038
3039 return -ENOTSUP;
3040}
3041
Fam Zheng4cc70e92013-11-20 10:01:54 +08003042int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3043{
3044 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3045 bs = bs->file;
3046 }
3047
3048 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3049 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3050 }
3051
3052 return -ENOTSUP;
3053}
3054
Kevin Wolf41c695c2012-12-06 14:32:58 +01003055int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3056{
Max Reitz938789e2014-03-10 23:44:08 +01003057 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
Kevin Wolf41c695c2012-12-06 14:32:58 +01003058 bs = bs->file;
3059 }
3060
3061 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3062 return bs->drv->bdrv_debug_resume(bs, tag);
3063 }
3064
3065 return -ENOTSUP;
3066}
3067
3068bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3069{
3070 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3071 bs = bs->file;
3072 }
3073
3074 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3075 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3076 }
3077
3078 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003079}
3080
Blue Swirl199630b2010-07-25 20:49:34 +00003081int bdrv_is_snapshot(BlockDriverState *bs)
3082{
3083 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3084}
3085
Jeff Codyb1b1d782012-10-16 15:49:09 -04003086/* backing_file can either be relative, or absolute, or a protocol. If it is
3087 * relative, it must be relative to the chain. So, passing in bs->filename
3088 * from a BDS as backing_file should not be done, as that may be relative to
3089 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003090BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3091 const char *backing_file)
3092{
Jeff Codyb1b1d782012-10-16 15:49:09 -04003093 char *filename_full = NULL;
3094 char *backing_file_full = NULL;
3095 char *filename_tmp = NULL;
3096 int is_protocol = 0;
3097 BlockDriverState *curr_bs = NULL;
3098 BlockDriverState *retval = NULL;
3099
3100 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003101 return NULL;
3102 }
3103
Jeff Codyb1b1d782012-10-16 15:49:09 -04003104 filename_full = g_malloc(PATH_MAX);
3105 backing_file_full = g_malloc(PATH_MAX);
3106 filename_tmp = g_malloc(PATH_MAX);
3107
3108 is_protocol = path_has_protocol(backing_file);
3109
3110 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3111
3112 /* If either of the filename paths is actually a protocol, then
3113 * compare unmodified paths; otherwise make paths relative */
3114 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3115 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3116 retval = curr_bs->backing_hd;
3117 break;
3118 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003119 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04003120 /* If not an absolute filename path, make it relative to the current
3121 * image's filename path */
3122 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3123 backing_file);
3124
3125 /* We are going to compare absolute pathnames */
3126 if (!realpath(filename_tmp, filename_full)) {
3127 continue;
3128 }
3129
3130 /* We need to make sure the backing filename we are comparing against
3131 * is relative to the current image filename (or absolute) */
3132 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3133 curr_bs->backing_file);
3134
3135 if (!realpath(filename_tmp, backing_file_full)) {
3136 continue;
3137 }
3138
3139 if (strcmp(backing_file_full, filename_full) == 0) {
3140 retval = curr_bs->backing_hd;
3141 break;
3142 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003143 }
3144 }
3145
Jeff Codyb1b1d782012-10-16 15:49:09 -04003146 g_free(filename_full);
3147 g_free(backing_file_full);
3148 g_free(filename_tmp);
3149 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003150}
3151
Benoît Canetf198fd12012-08-02 10:22:47 +02003152int bdrv_get_backing_file_depth(BlockDriverState *bs)
3153{
3154 if (!bs->drv) {
3155 return 0;
3156 }
3157
3158 if (!bs->backing_hd) {
3159 return 0;
3160 }
3161
3162 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3163}
3164
bellardea2384d2004-08-01 21:59:26 +00003165void bdrv_init(void)
3166{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003167 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00003168}
pbrookce1a14d2006-08-07 02:38:06 +00003169
Markus Armbrustereb852012009-10-27 18:41:44 +01003170void bdrv_init_with_whitelist(void)
3171{
3172 use_bdrv_whitelist = 1;
3173 bdrv_init();
3174}
3175
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003176void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06003177{
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003178 Error *local_err = NULL;
3179 int ret;
3180
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003181 if (!bs->drv) {
3182 return;
Anthony Liguori0f154232011-11-14 15:09:45 -06003183 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003184
Alexey Kardashevskiy7ea2d262014-10-09 13:50:46 +11003185 if (!(bs->open_flags & BDRV_O_INCOMING)) {
3186 return;
3187 }
3188 bs->open_flags &= ~BDRV_O_INCOMING;
3189
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003190 if (bs->drv->bdrv_invalidate_cache) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003191 bs->drv->bdrv_invalidate_cache(bs, &local_err);
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003192 } else if (bs->file) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003193 bdrv_invalidate_cache(bs->file, &local_err);
3194 }
3195 if (local_err) {
3196 error_propagate(errp, local_err);
3197 return;
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003198 }
3199
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003200 ret = refresh_total_sectors(bs, bs->total_sectors);
3201 if (ret < 0) {
3202 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3203 return;
3204 }
Anthony Liguori0f154232011-11-14 15:09:45 -06003205}
3206
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003207void bdrv_invalidate_cache_all(Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06003208{
3209 BlockDriverState *bs;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003210 Error *local_err = NULL;
Anthony Liguori0f154232011-11-14 15:09:45 -06003211
Benoît Canetdc364f42014-01-23 21:31:32 +01003212 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003213 AioContext *aio_context = bdrv_get_aio_context(bs);
3214
3215 aio_context_acquire(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003216 bdrv_invalidate_cache(bs, &local_err);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003217 aio_context_release(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003218 if (local_err) {
3219 error_propagate(errp, local_err);
3220 return;
3221 }
Anthony Liguori0f154232011-11-14 15:09:45 -06003222 }
3223}
3224
Kevin Wolff9f05dc2011-07-15 13:50:26 +02003225/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00003226/* removable device support */
3227
3228/**
3229 * Return TRUE if the media is present
3230 */
3231int bdrv_is_inserted(BlockDriverState *bs)
3232{
3233 BlockDriver *drv = bs->drv;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02003234
bellard19cb3732006-08-19 11:45:59 +00003235 if (!drv)
3236 return 0;
3237 if (!drv->bdrv_is_inserted)
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02003238 return 1;
3239 return drv->bdrv_is_inserted(bs);
bellard19cb3732006-08-19 11:45:59 +00003240}
3241
3242/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02003243 * Return whether the media changed since the last call to this
3244 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00003245 */
3246int bdrv_media_changed(BlockDriverState *bs)
3247{
3248 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00003249
Markus Armbruster8e49ca42011-08-03 15:08:08 +02003250 if (drv && drv->bdrv_media_changed) {
3251 return drv->bdrv_media_changed(bs);
3252 }
3253 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00003254}
3255
3256/**
3257 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3258 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02003259void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00003260{
3261 BlockDriver *drv = bs->drv;
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003262 const char *device_name;
bellard19cb3732006-08-19 11:45:59 +00003263
Markus Armbruster822e1cd2011-07-20 18:23:42 +02003264 if (drv && drv->bdrv_eject) {
3265 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00003266 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02003267
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003268 device_name = bdrv_get_device_name(bs);
3269 if (device_name[0] != '\0') {
3270 qapi_event_send_device_tray_moved(device_name,
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +02003271 eject_flag, &error_abort);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02003272 }
bellard19cb3732006-08-19 11:45:59 +00003273}
3274
bellard19cb3732006-08-19 11:45:59 +00003275/**
3276 * Lock or unlock the media (if it is locked, the user won't be able
3277 * to eject it manually).
3278 */
Markus Armbruster025e8492011-09-06 18:58:47 +02003279void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00003280{
3281 BlockDriver *drv = bs->drv;
3282
Markus Armbruster025e8492011-09-06 18:58:47 +02003283 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01003284
Markus Armbruster025e8492011-09-06 18:58:47 +02003285 if (drv && drv->bdrv_lock_medium) {
3286 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00003287 }
3288}
ths985a03b2007-12-24 16:10:43 +00003289
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01003290void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
Markus Armbruster7b6f9302011-09-06 18:58:56 +02003291{
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01003292 bs->guest_block_size = align;
Markus Armbruster7b6f9302011-09-06 18:58:56 +02003293}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003294
Fam Zheng0db6e542015-04-17 19:49:50 -04003295BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3296{
3297 BdrvDirtyBitmap *bm;
3298
3299 assert(name);
3300 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3301 if (bm->name && !strcmp(name, bm->name)) {
3302 return bm;
3303 }
3304 }
3305 return NULL;
3306}
3307
John Snow20dca812015-04-17 19:50:02 -04003308void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
Fam Zheng0db6e542015-04-17 19:49:50 -04003309{
John Snow9bd2b082015-04-17 19:49:57 -04003310 assert(!bdrv_dirty_bitmap_frozen(bitmap));
Fam Zheng0db6e542015-04-17 19:49:50 -04003311 g_free(bitmap->name);
3312 bitmap->name = NULL;
3313}
3314
3315BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
John Snow5fba6c02015-04-17 19:49:51 -04003316 uint32_t granularity,
Fam Zheng0db6e542015-04-17 19:49:50 -04003317 const char *name,
Fam Zhengb8afb522014-04-16 09:34:30 +08003318 Error **errp)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003319{
3320 int64_t bitmap_size;
Fam Zhenge4654d22013-11-13 18:29:43 +08003321 BdrvDirtyBitmap *bitmap;
John Snow5fba6c02015-04-17 19:49:51 -04003322 uint32_t sector_granularity;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003323
Paolo Bonzini50717e92013-01-21 17:09:45 +01003324 assert((granularity & (granularity - 1)) == 0);
3325
Fam Zheng0db6e542015-04-17 19:49:50 -04003326 if (name && bdrv_find_dirty_bitmap(bs, name)) {
3327 error_setg(errp, "Bitmap already exists: %s", name);
3328 return NULL;
3329 }
John Snow5fba6c02015-04-17 19:49:51 -04003330 sector_granularity = granularity >> BDRV_SECTOR_BITS;
3331 assert(sector_granularity);
Markus Armbruster57322b72014-06-26 13:23:22 +02003332 bitmap_size = bdrv_nb_sectors(bs);
Fam Zhengb8afb522014-04-16 09:34:30 +08003333 if (bitmap_size < 0) {
3334 error_setg_errno(errp, -bitmap_size, "could not get length of device");
3335 errno = -bitmap_size;
3336 return NULL;
3337 }
Markus Armbruster5839e532014-08-19 10:31:08 +02003338 bitmap = g_new0(BdrvDirtyBitmap, 1);
John Snow5fba6c02015-04-17 19:49:51 -04003339 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
John Snowe74e6b72015-04-17 19:49:59 -04003340 bitmap->size = bitmap_size;
Fam Zheng0db6e542015-04-17 19:49:50 -04003341 bitmap->name = g_strdup(name);
John Snowb8e6fb72015-04-17 19:49:56 -04003342 bitmap->disabled = false;
Fam Zhenge4654d22013-11-13 18:29:43 +08003343 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3344 return bitmap;
3345}
3346
John Snow9bd2b082015-04-17 19:49:57 -04003347bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3348{
3349 return bitmap->successor;
3350}
3351
John Snowb8e6fb72015-04-17 19:49:56 -04003352bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3353{
John Snow9bd2b082015-04-17 19:49:57 -04003354 return !(bitmap->disabled || bitmap->successor);
3355}
3356
John Snow9abe3bd2015-05-12 15:53:01 -04003357DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3358{
3359 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3360 return DIRTY_BITMAP_STATUS_FROZEN;
3361 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3362 return DIRTY_BITMAP_STATUS_DISABLED;
3363 } else {
3364 return DIRTY_BITMAP_STATUS_ACTIVE;
3365 }
3366}
3367
John Snow9bd2b082015-04-17 19:49:57 -04003368/**
3369 * Create a successor bitmap destined to replace this bitmap after an operation.
3370 * Requires that the bitmap is not frozen and has no successor.
3371 */
3372int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3373 BdrvDirtyBitmap *bitmap, Error **errp)
3374{
3375 uint64_t granularity;
3376 BdrvDirtyBitmap *child;
3377
3378 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3379 error_setg(errp, "Cannot create a successor for a bitmap that is "
3380 "currently frozen");
3381 return -1;
3382 }
3383 assert(!bitmap->successor);
3384
3385 /* Create an anonymous successor */
3386 granularity = bdrv_dirty_bitmap_granularity(bitmap);
3387 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3388 if (!child) {
3389 return -1;
3390 }
3391
3392 /* Successor will be on or off based on our current state. */
3393 child->disabled = bitmap->disabled;
3394
3395 /* Install the successor and freeze the parent */
3396 bitmap->successor = child;
3397 return 0;
3398}
3399
3400/**
3401 * For a bitmap with a successor, yield our name to the successor,
3402 * delete the old bitmap, and return a handle to the new bitmap.
3403 */
3404BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3405 BdrvDirtyBitmap *bitmap,
3406 Error **errp)
3407{
3408 char *name;
3409 BdrvDirtyBitmap *successor = bitmap->successor;
3410
3411 if (successor == NULL) {
3412 error_setg(errp, "Cannot relinquish control if "
3413 "there's no successor present");
3414 return NULL;
3415 }
3416
3417 name = bitmap->name;
3418 bitmap->name = NULL;
3419 successor->name = name;
3420 bitmap->successor = NULL;
3421 bdrv_release_dirty_bitmap(bs, bitmap);
3422
3423 return successor;
3424}
3425
3426/**
3427 * In cases of failure where we can no longer safely delete the parent,
3428 * we may wish to re-join the parent and child/successor.
3429 * The merged parent will be un-frozen, but not explicitly re-enabled.
3430 */
3431BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3432 BdrvDirtyBitmap *parent,
3433 Error **errp)
3434{
3435 BdrvDirtyBitmap *successor = parent->successor;
3436
3437 if (!successor) {
3438 error_setg(errp, "Cannot reclaim a successor when none is present");
3439 return NULL;
3440 }
3441
3442 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3443 error_setg(errp, "Merging of parent and successor bitmap failed");
3444 return NULL;
3445 }
3446 bdrv_release_dirty_bitmap(bs, successor);
3447 parent->successor = NULL;
3448
3449 return parent;
John Snowb8e6fb72015-04-17 19:49:56 -04003450}
3451
John Snowce1ffea2015-04-17 19:50:03 -04003452/**
3453 * Truncates _all_ bitmaps attached to a BDS.
3454 */
3455static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3456{
3457 BdrvDirtyBitmap *bitmap;
3458 uint64_t size = bdrv_nb_sectors(bs);
3459
3460 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
John Snow06207b02015-06-10 13:24:54 -04003461 assert(!bdrv_dirty_bitmap_frozen(bitmap));
John Snowce1ffea2015-04-17 19:50:03 -04003462 hbitmap_truncate(bitmap->bitmap, size);
John Snow5270b6a2015-06-08 16:49:15 -04003463 bitmap->size = size;
John Snowce1ffea2015-04-17 19:50:03 -04003464 }
3465}
3466
Fam Zhenge4654d22013-11-13 18:29:43 +08003467void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3468{
3469 BdrvDirtyBitmap *bm, *next;
3470 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3471 if (bm == bitmap) {
John Snow9bd2b082015-04-17 19:49:57 -04003472 assert(!bdrv_dirty_bitmap_frozen(bm));
Fam Zhenge4654d22013-11-13 18:29:43 +08003473 QLIST_REMOVE(bitmap, list);
3474 hbitmap_free(bitmap->bitmap);
Fam Zheng0db6e542015-04-17 19:49:50 -04003475 g_free(bitmap->name);
Fam Zhenge4654d22013-11-13 18:29:43 +08003476 g_free(bitmap);
3477 return;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003478 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003479 }
3480}
3481
John Snowb8e6fb72015-04-17 19:49:56 -04003482void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3483{
John Snow9bd2b082015-04-17 19:49:57 -04003484 assert(!bdrv_dirty_bitmap_frozen(bitmap));
John Snowb8e6fb72015-04-17 19:49:56 -04003485 bitmap->disabled = true;
3486}
3487
3488void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3489{
John Snow9bd2b082015-04-17 19:49:57 -04003490 assert(!bdrv_dirty_bitmap_frozen(bitmap));
John Snowb8e6fb72015-04-17 19:49:56 -04003491 bitmap->disabled = false;
3492}
3493
Fam Zheng21b56832013-11-13 18:29:44 +08003494BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3495{
3496 BdrvDirtyBitmap *bm;
3497 BlockDirtyInfoList *list = NULL;
3498 BlockDirtyInfoList **plist = &list;
3499
3500 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
Markus Armbruster5839e532014-08-19 10:31:08 +02003501 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3502 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
John Snow20dca812015-04-17 19:50:02 -04003503 info->count = bdrv_get_dirty_count(bm);
John Snow592fdd02015-04-17 19:49:53 -04003504 info->granularity = bdrv_dirty_bitmap_granularity(bm);
Fam Zheng0db6e542015-04-17 19:49:50 -04003505 info->has_name = !!bm->name;
3506 info->name = g_strdup(bm->name);
John Snow9abe3bd2015-05-12 15:53:01 -04003507 info->status = bdrv_dirty_bitmap_status(bm);
Fam Zheng21b56832013-11-13 18:29:44 +08003508 entry->value = info;
3509 *plist = entry;
3510 plist = &entry->next;
3511 }
3512
3513 return list;
3514}
3515
Fam Zhenge4654d22013-11-13 18:29:43 +08003516int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003517{
Fam Zhenge4654d22013-11-13 18:29:43 +08003518 if (bitmap) {
3519 return hbitmap_get(bitmap->bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003520 } else {
3521 return 0;
3522 }
3523}
3524
John Snow341ebc22015-04-17 19:49:52 -04003525/**
3526 * Chooses a default granularity based on the existing cluster size,
3527 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3528 * is no cluster size information available.
3529 */
3530uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3531{
3532 BlockDriverInfo bdi;
3533 uint32_t granularity;
3534
3535 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3536 granularity = MAX(4096, bdi.cluster_size);
3537 granularity = MIN(65536, granularity);
3538 } else {
3539 granularity = 65536;
3540 }
3541
3542 return granularity;
3543}
3544
John Snow592fdd02015-04-17 19:49:53 -04003545uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3546{
3547 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3548}
3549
John Snow20dca812015-04-17 19:50:02 -04003550void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02003551{
Fam Zhenge4654d22013-11-13 18:29:43 +08003552 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02003553}
3554
John Snow20dca812015-04-17 19:50:02 -04003555void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
Vladimir Sementsov-Ogievskiyc4237df2014-11-27 12:40:46 +03003556 int64_t cur_sector, int nr_sectors)
3557{
John Snowb8e6fb72015-04-17 19:49:56 -04003558 assert(bdrv_dirty_bitmap_enabled(bitmap));
Vladimir Sementsov-Ogievskiyc4237df2014-11-27 12:40:46 +03003559 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3560}
3561
John Snow20dca812015-04-17 19:50:02 -04003562void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
Vladimir Sementsov-Ogievskiyc4237df2014-11-27 12:40:46 +03003563 int64_t cur_sector, int nr_sectors)
3564{
John Snowb8e6fb72015-04-17 19:49:56 -04003565 assert(bdrv_dirty_bitmap_enabled(bitmap));
Vladimir Sementsov-Ogievskiyc4237df2014-11-27 12:40:46 +03003566 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3567}
3568
John Snowe74e6b72015-04-17 19:49:59 -04003569void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3570{
3571 assert(bdrv_dirty_bitmap_enabled(bitmap));
Wen Congyangc6a8c322015-05-22 09:29:46 +08003572 hbitmap_reset_all(bitmap->bitmap);
John Snowe74e6b72015-04-17 19:49:59 -04003573}
3574
Stefan Hajnoczie0c47b62015-04-28 14:27:50 +01003575void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3576 int nr_sectors)
Paolo Bonzini1755da12012-10-18 16:49:18 +02003577{
Fam Zhenge4654d22013-11-13 18:29:43 +08003578 BdrvDirtyBitmap *bitmap;
3579 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
John Snowb8e6fb72015-04-17 19:49:56 -04003580 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3581 continue;
3582 }
Fam Zhenge4654d22013-11-13 18:29:43 +08003583 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01003584 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02003585}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003586
John Snowd58d8452015-04-17 19:49:58 -04003587/**
3588 * Advance an HBitmapIter to an arbitrary offset.
3589 */
3590void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3591{
3592 assert(hbi->hb);
3593 hbitmap_iter_init(hbi, hbi->hb, offset);
3594}
3595
John Snow20dca812015-04-17 19:50:02 -04003596int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
Fam Zhenge4654d22013-11-13 18:29:43 +08003597{
3598 return hbitmap_count(bitmap->bitmap);
3599}
3600
Fam Zheng9fcb0252013-08-23 09:14:46 +08003601/* Get a reference to bs */
3602void bdrv_ref(BlockDriverState *bs)
3603{
3604 bs->refcnt++;
3605}
3606
3607/* Release a previously grabbed reference to bs.
3608 * If after releasing, reference count is zero, the BlockDriverState is
3609 * deleted. */
3610void bdrv_unref(BlockDriverState *bs)
3611{
Jeff Cody9a4d5ca2014-07-23 17:22:57 -04003612 if (!bs) {
3613 return;
3614 }
Fam Zheng9fcb0252013-08-23 09:14:46 +08003615 assert(bs->refcnt > 0);
3616 if (--bs->refcnt == 0) {
3617 bdrv_delete(bs);
3618 }
3619}
3620
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003621struct BdrvOpBlocker {
3622 Error *reason;
3623 QLIST_ENTRY(BdrvOpBlocker) list;
3624};
3625
3626bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3627{
3628 BdrvOpBlocker *blocker;
3629 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3630 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3631 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3632 if (errp) {
Alberto Garcia81e5f782015-04-08 12:29:19 +03003633 error_setg(errp, "Node '%s' is busy: %s",
3634 bdrv_get_device_or_node_name(bs),
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003635 error_get_pretty(blocker->reason));
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003636 }
3637 return true;
3638 }
3639 return false;
3640}
3641
3642void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3643{
3644 BdrvOpBlocker *blocker;
3645 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3646
Markus Armbruster5839e532014-08-19 10:31:08 +02003647 blocker = g_new0(BdrvOpBlocker, 1);
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003648 blocker->reason = reason;
3649 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3650}
3651
3652void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3653{
3654 BdrvOpBlocker *blocker, *next;
3655 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3656 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3657 if (blocker->reason == reason) {
3658 QLIST_REMOVE(blocker, list);
3659 g_free(blocker);
3660 }
3661 }
3662}
3663
3664void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3665{
3666 int i;
3667 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3668 bdrv_op_block(bs, i, reason);
3669 }
3670}
3671
3672void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3673{
3674 int i;
3675 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3676 bdrv_op_unblock(bs, i, reason);
3677 }
3678}
3679
3680bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3681{
3682 int i;
3683
3684 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3685 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3686 return false;
3687 }
3688 }
3689 return true;
3690}
3691
Luiz Capitulino28a72822011-09-26 17:43:50 -03003692void bdrv_iostatus_enable(BlockDriverState *bs)
3693{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03003694 bs->iostatus_enabled = true;
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03003695 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Luiz Capitulino28a72822011-09-26 17:43:50 -03003696}
3697
3698/* The I/O status is only enabled if the drive explicitly
3699 * enables it _and_ the VM is configured to stop on errors */
3700bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3701{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03003702 return (bs->iostatus_enabled &&
Paolo Bonzini92aa5c62012-09-28 17:22:55 +02003703 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
3704 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
3705 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
Luiz Capitulino28a72822011-09-26 17:43:50 -03003706}
3707
3708void bdrv_iostatus_disable(BlockDriverState *bs)
3709{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03003710 bs->iostatus_enabled = false;
Luiz Capitulino28a72822011-09-26 17:43:50 -03003711}
3712
3713void bdrv_iostatus_reset(BlockDriverState *bs)
3714{
3715 if (bdrv_iostatus_is_enabled(bs)) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03003716 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Paolo Bonzini3bd293c2012-10-18 16:49:27 +02003717 if (bs->job) {
3718 block_job_iostatus_reset(bs->job);
3719 }
Luiz Capitulino28a72822011-09-26 17:43:50 -03003720 }
3721}
3722
Luiz Capitulino28a72822011-09-26 17:43:50 -03003723void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3724{
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003725 assert(bdrv_iostatus_is_enabled(bs));
3726 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03003727 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3728 BLOCK_DEVICE_IO_STATUS_FAILED;
Luiz Capitulino28a72822011-09-26 17:43:50 -03003729 }
3730}
3731
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003732void bdrv_img_create(const char *filename, const char *fmt,
3733 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01003734 char *options, uint64_t img_size, int flags,
3735 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003736{
Chunyan Liu83d05212014-06-05 17:20:51 +08003737 QemuOptsList *create_opts = NULL;
3738 QemuOpts *opts = NULL;
3739 const char *backing_fmt, *backing_file;
3740 int64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003741 BlockDriver *drv, *proto_drv;
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00003742 BlockDriver *backing_drv = NULL;
Max Reitzcc84d902013-09-06 17:14:26 +02003743 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003744 int ret = 0;
3745
3746 /* Find driver and parse its options */
3747 drv = bdrv_find_format(fmt);
3748 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003749 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003750 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003751 }
3752
Max Reitzb65a5e12015-02-05 13:58:12 -05003753 proto_drv = bdrv_find_protocol(filename, true, errp);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003754 if (!proto_drv) {
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003755 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003756 }
3757
Max Reitzc6149722014-12-02 18:32:45 +01003758 if (!drv->create_opts) {
3759 error_setg(errp, "Format driver '%s' does not support image creation",
3760 drv->format_name);
3761 return;
3762 }
3763
3764 if (!proto_drv->create_opts) {
3765 error_setg(errp, "Protocol driver '%s' does not support image creation",
3766 proto_drv->format_name);
3767 return;
3768 }
3769
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003770 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3771 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003772
3773 /* Create parameter list with default values */
Chunyan Liu83d05212014-06-05 17:20:51 +08003774 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
Markus Armbruster39101f22015-02-12 16:46:36 +01003775 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003776
3777 /* Parse -o options */
3778 if (options) {
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01003779 qemu_opts_do_parse(opts, options, NULL, &local_err);
3780 if (local_err) {
3781 error_report_err(local_err);
3782 local_err = NULL;
Chunyan Liu83d05212014-06-05 17:20:51 +08003783 error_setg(errp, "Invalid options for file format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003784 goto out;
3785 }
3786 }
3787
3788 if (base_filename) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01003789 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
Markus Armbruster6be41942015-02-12 17:49:02 +01003790 if (local_err) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003791 error_setg(errp, "Backing file not supported for file format '%s'",
3792 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003793 goto out;
3794 }
3795 }
3796
3797 if (base_fmt) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01003798 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
Markus Armbruster6be41942015-02-12 17:49:02 +01003799 if (local_err) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003800 error_setg(errp, "Backing file format not supported for file "
3801 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003802 goto out;
3803 }
3804 }
3805
Chunyan Liu83d05212014-06-05 17:20:51 +08003806 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3807 if (backing_file) {
3808 if (!strcmp(filename, backing_file)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003809 error_setg(errp, "Error: Trying to create an image with the "
3810 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01003811 goto out;
3812 }
3813 }
3814
Chunyan Liu83d05212014-06-05 17:20:51 +08003815 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3816 if (backing_fmt) {
3817 backing_drv = bdrv_find_format(backing_fmt);
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00003818 if (!backing_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003819 error_setg(errp, "Unknown backing file format '%s'",
Chunyan Liu83d05212014-06-05 17:20:51 +08003820 backing_fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003821 goto out;
3822 }
3823 }
3824
3825 // The size for the image must always be specified, with one exception:
3826 // If we are using a backing file, we can obtain the size from there
Chunyan Liu83d05212014-06-05 17:20:51 +08003827 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3828 if (size == -1) {
3829 if (backing_file) {
Max Reitz66f6b812013-12-03 14:57:52 +01003830 BlockDriverState *bs;
Max Reitz29168012014-11-26 17:20:27 +01003831 char *full_backing = g_new0(char, PATH_MAX);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02003832 int64_t size;
Paolo Bonzini63090da2012-04-12 14:01:03 +02003833 int back_flags;
3834
Max Reitz29168012014-11-26 17:20:27 +01003835 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3836 full_backing, PATH_MAX,
3837 &local_err);
3838 if (local_err) {
3839 g_free(full_backing);
3840 goto out;
3841 }
3842
Paolo Bonzini63090da2012-04-12 14:01:03 +02003843 /* backing files always opened read-only */
3844 back_flags =
3845 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003846
Max Reitzf67503e2014-02-18 18:33:05 +01003847 bs = NULL;
Max Reitz29168012014-11-26 17:20:27 +01003848 ret = bdrv_open(&bs, full_backing, NULL, NULL, back_flags,
Max Reitzcc84d902013-09-06 17:14:26 +02003849 backing_drv, &local_err);
Max Reitz29168012014-11-26 17:20:27 +01003850 g_free(full_backing);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003851 if (ret < 0) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003852 goto out;
3853 }
Markus Armbruster52bf1e72014-06-26 13:23:25 +02003854 size = bdrv_getlength(bs);
3855 if (size < 0) {
3856 error_setg_errno(errp, -size, "Could not get size of '%s'",
3857 backing_file);
3858 bdrv_unref(bs);
3859 goto out;
3860 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003861
Markus Armbruster39101f22015-02-12 16:46:36 +01003862 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
Max Reitz66f6b812013-12-03 14:57:52 +01003863
3864 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003865 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003866 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003867 goto out;
3868 }
3869 }
3870
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01003871 if (!quiet) {
Kővágó, Zoltánfe646692015-07-07 16:42:10 +02003872 printf("Formatting '%s', fmt=%s ", filename, fmt);
Fam Zheng43c5d8f2014-12-09 15:38:04 +08003873 qemu_opts_print(opts, " ");
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01003874 puts("");
3875 }
Chunyan Liu83d05212014-06-05 17:20:51 +08003876
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003877 ret = bdrv_create(drv, filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08003878
Max Reitzcc84d902013-09-06 17:14:26 +02003879 if (ret == -EFBIG) {
3880 /* This is generally a better message than whatever the driver would
3881 * deliver (especially because of the cluster_size_hint), since that
3882 * is most probably not much different from "image too large". */
3883 const char *cluster_size_hint = "";
Chunyan Liu83d05212014-06-05 17:20:51 +08003884 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
Max Reitzcc84d902013-09-06 17:14:26 +02003885 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003886 }
Max Reitzcc84d902013-09-06 17:14:26 +02003887 error_setg(errp, "The image size is too large for file format '%s'"
3888 "%s", fmt, cluster_size_hint);
3889 error_free(local_err);
3890 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003891 }
3892
3893out:
Chunyan Liu83d05212014-06-05 17:20:51 +08003894 qemu_opts_del(opts);
3895 qemu_opts_free(create_opts);
Markus Armbruster84d18f02014-01-30 15:07:28 +01003896 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +02003897 error_propagate(errp, local_err);
3898 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003899}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01003900
3901AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3902{
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003903 return bs->aio_context;
3904}
3905
3906void bdrv_detach_aio_context(BlockDriverState *bs)
3907{
Max Reitz33384422014-06-20 21:57:33 +02003908 BdrvAioNotifier *baf;
3909
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003910 if (!bs->drv) {
3911 return;
3912 }
3913
Max Reitz33384422014-06-20 21:57:33 +02003914 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3915 baf->detach_aio_context(baf->opaque);
3916 }
3917
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02003918 if (bs->io_limits_enabled) {
Benoît Canet0e5b0a22015-06-08 18:17:41 +02003919 throttle_timers_detach_aio_context(&bs->throttle_timers);
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02003920 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003921 if (bs->drv->bdrv_detach_aio_context) {
3922 bs->drv->bdrv_detach_aio_context(bs);
3923 }
3924 if (bs->file) {
3925 bdrv_detach_aio_context(bs->file);
3926 }
3927 if (bs->backing_hd) {
3928 bdrv_detach_aio_context(bs->backing_hd);
3929 }
3930
3931 bs->aio_context = NULL;
3932}
3933
3934void bdrv_attach_aio_context(BlockDriverState *bs,
3935 AioContext *new_context)
3936{
Max Reitz33384422014-06-20 21:57:33 +02003937 BdrvAioNotifier *ban;
3938
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003939 if (!bs->drv) {
3940 return;
3941 }
3942
3943 bs->aio_context = new_context;
3944
3945 if (bs->backing_hd) {
3946 bdrv_attach_aio_context(bs->backing_hd, new_context);
3947 }
3948 if (bs->file) {
3949 bdrv_attach_aio_context(bs->file, new_context);
3950 }
3951 if (bs->drv->bdrv_attach_aio_context) {
3952 bs->drv->bdrv_attach_aio_context(bs, new_context);
3953 }
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02003954 if (bs->io_limits_enabled) {
Benoît Canet0e5b0a22015-06-08 18:17:41 +02003955 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02003956 }
Max Reitz33384422014-06-20 21:57:33 +02003957
3958 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3959 ban->attached_aio_context(new_context, ban->opaque);
3960 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003961}
3962
3963void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3964{
Fam Zheng53ec73e2015-05-29 18:53:14 +08003965 bdrv_drain(bs); /* ensure there are no in-flight requests */
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003966
3967 bdrv_detach_aio_context(bs);
3968
3969 /* This function executes in the old AioContext so acquire the new one in
3970 * case it runs in a different thread.
3971 */
3972 aio_context_acquire(new_context);
3973 bdrv_attach_aio_context(bs, new_context);
3974 aio_context_release(new_context);
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01003975}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003976
Max Reitz33384422014-06-20 21:57:33 +02003977void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3978 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3979 void (*detach_aio_context)(void *opaque), void *opaque)
3980{
3981 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3982 *ban = (BdrvAioNotifier){
3983 .attached_aio_context = attached_aio_context,
3984 .detach_aio_context = detach_aio_context,
3985 .opaque = opaque
3986 };
3987
3988 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3989}
3990
3991void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3992 void (*attached_aio_context)(AioContext *,
3993 void *),
3994 void (*detach_aio_context)(void *),
3995 void *opaque)
3996{
3997 BdrvAioNotifier *ban, *ban_next;
3998
3999 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4000 if (ban->attached_aio_context == attached_aio_context &&
4001 ban->detach_aio_context == detach_aio_context &&
4002 ban->opaque == opaque)
4003 {
4004 QLIST_REMOVE(ban, list);
4005 g_free(ban);
4006
4007 return;
4008 }
4009 }
4010
4011 abort();
4012}
4013
Max Reitz77485432014-10-27 11:12:50 +01004014int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
4015 BlockDriverAmendStatusCB *status_cb)
Max Reitz6f176b42013-09-03 10:09:50 +02004016{
Chunyan Liuc282e1f2014-06-05 17:21:11 +08004017 if (!bs->drv->bdrv_amend_options) {
Max Reitz6f176b42013-09-03 10:09:50 +02004018 return -ENOTSUP;
4019 }
Max Reitz77485432014-10-27 11:12:50 +01004020 return bs->drv->bdrv_amend_options(bs, opts, status_cb);
Max Reitz6f176b42013-09-03 10:09:50 +02004021}
Benoît Canetf6186f42013-10-02 14:33:48 +02004022
Benoît Canetb5042a32014-03-03 19:11:34 +01004023/* This function will be called by the bdrv_recurse_is_first_non_filter method
4024 * of block filter and by bdrv_is_first_non_filter.
4025 * It is used to test if the given bs is the candidate or recurse more in the
4026 * node graph.
Benoît Canet212a5a82014-01-23 21:31:36 +01004027 */
Benoît Canet212a5a82014-01-23 21:31:36 +01004028bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
4029 BlockDriverState *candidate)
Benoît Canetf6186f42013-10-02 14:33:48 +02004030{
Benoît Canetb5042a32014-03-03 19:11:34 +01004031 /* return false if basic checks fails */
4032 if (!bs || !bs->drv) {
4033 return false;
4034 }
4035
4036 /* the code reached a non block filter driver -> check if the bs is
4037 * the same as the candidate. It's the recursion termination condition.
4038 */
4039 if (!bs->drv->is_filter) {
4040 return bs == candidate;
4041 }
4042 /* Down this path the driver is a block filter driver */
4043
4044 /* If the block filter recursion method is defined use it to recurse down
4045 * the node graph.
4046 */
4047 if (bs->drv->bdrv_recurse_is_first_non_filter) {
Benoît Canet212a5a82014-01-23 21:31:36 +01004048 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4049 }
4050
Benoît Canetb5042a32014-03-03 19:11:34 +01004051 /* the driver is a block filter but don't allow to recurse -> return false
4052 */
4053 return false;
Benoît Canet212a5a82014-01-23 21:31:36 +01004054}
4055
4056/* This function checks if the candidate is the first non filter bs down it's
4057 * bs chain. Since we don't have pointers to parents it explore all bs chains
4058 * from the top. Some filters can choose not to pass down the recursion.
4059 */
4060bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4061{
4062 BlockDriverState *bs;
4063
4064 /* walk down the bs forest recursively */
4065 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4066 bool perm;
4067
Benoît Canetb5042a32014-03-03 19:11:34 +01004068 /* try to recurse in this top level bs */
Kevin Wolfe6dc8a12014-02-04 11:45:31 +01004069 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
Benoît Canet212a5a82014-01-23 21:31:36 +01004070
4071 /* candidate is the first non filter */
4072 if (perm) {
4073 return true;
4074 }
4075 }
4076
4077 return false;
Benoît Canetf6186f42013-10-02 14:33:48 +02004078}
Benoît Canet09158f02014-06-27 18:25:25 +02004079
Wen Congyange12f3782015-07-17 10:12:22 +08004080BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
4081 const char *node_name, Error **errp)
Benoît Canet09158f02014-06-27 18:25:25 +02004082{
4083 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004084 AioContext *aio_context;
4085
Benoît Canet09158f02014-06-27 18:25:25 +02004086 if (!to_replace_bs) {
4087 error_setg(errp, "Node name '%s' not found", node_name);
4088 return NULL;
4089 }
4090
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004091 aio_context = bdrv_get_aio_context(to_replace_bs);
4092 aio_context_acquire(aio_context);
4093
Benoît Canet09158f02014-06-27 18:25:25 +02004094 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004095 to_replace_bs = NULL;
4096 goto out;
Benoît Canet09158f02014-06-27 18:25:25 +02004097 }
4098
4099 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4100 * most non filter in order to prevent data corruption.
4101 * Another benefit is that this tests exclude backing files which are
4102 * blocked by the backing blockers.
4103 */
Wen Congyange12f3782015-07-17 10:12:22 +08004104 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
Benoît Canet09158f02014-06-27 18:25:25 +02004105 error_setg(errp, "Only top most non filter can be replaced");
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004106 to_replace_bs = NULL;
4107 goto out;
Benoît Canet09158f02014-06-27 18:25:25 +02004108 }
4109
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004110out:
4111 aio_context_release(aio_context);
Benoît Canet09158f02014-06-27 18:25:25 +02004112 return to_replace_bs;
4113}
Ming Lei448ad912014-07-04 18:04:33 +08004114
Max Reitz91af7012014-07-18 20:24:56 +02004115static bool append_open_options(QDict *d, BlockDriverState *bs)
4116{
4117 const QDictEntry *entry;
4118 bool found_any = false;
4119
4120 for (entry = qdict_first(bs->options); entry;
4121 entry = qdict_next(bs->options, entry))
4122 {
4123 /* Only take options for this level and exclude all non-driver-specific
4124 * options */
4125 if (!strchr(qdict_entry_key(entry), '.') &&
4126 strcmp(qdict_entry_key(entry), "node-name"))
4127 {
4128 qobject_incref(qdict_entry_value(entry));
4129 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4130 found_any = true;
4131 }
4132 }
4133
4134 return found_any;
4135}
4136
4137/* Updates the following BDS fields:
4138 * - exact_filename: A filename which may be used for opening a block device
4139 * which (mostly) equals the given BDS (even without any
4140 * other options; so reading and writing must return the same
4141 * results, but caching etc. may be different)
4142 * - full_open_options: Options which, when given when opening a block device
4143 * (without a filename), result in a BDS (mostly)
4144 * equalling the given one
4145 * - filename: If exact_filename is set, it is copied here. Otherwise,
4146 * full_open_options is converted to a JSON object, prefixed with
4147 * "json:" (for use through the JSON pseudo protocol) and put here.
4148 */
4149void bdrv_refresh_filename(BlockDriverState *bs)
4150{
4151 BlockDriver *drv = bs->drv;
4152 QDict *opts;
4153
4154 if (!drv) {
4155 return;
4156 }
4157
4158 /* This BDS's file name will most probably depend on its file's name, so
4159 * refresh that first */
4160 if (bs->file) {
4161 bdrv_refresh_filename(bs->file);
4162 }
4163
4164 if (drv->bdrv_refresh_filename) {
4165 /* Obsolete information is of no use here, so drop the old file name
4166 * information before refreshing it */
4167 bs->exact_filename[0] = '\0';
4168 if (bs->full_open_options) {
4169 QDECREF(bs->full_open_options);
4170 bs->full_open_options = NULL;
4171 }
4172
4173 drv->bdrv_refresh_filename(bs);
4174 } else if (bs->file) {
4175 /* Try to reconstruct valid information from the underlying file */
4176 bool has_open_options;
4177
4178 bs->exact_filename[0] = '\0';
4179 if (bs->full_open_options) {
4180 QDECREF(bs->full_open_options);
4181 bs->full_open_options = NULL;
4182 }
4183
4184 opts = qdict_new();
4185 has_open_options = append_open_options(opts, bs);
4186
4187 /* If no specific options have been given for this BDS, the filename of
4188 * the underlying file should suffice for this one as well */
4189 if (bs->file->exact_filename[0] && !has_open_options) {
4190 strcpy(bs->exact_filename, bs->file->exact_filename);
4191 }
4192 /* Reconstructing the full options QDict is simple for most format block
4193 * drivers, as long as the full options are known for the underlying
4194 * file BDS. The full options QDict of that file BDS should somehow
4195 * contain a representation of the filename, therefore the following
4196 * suffices without querying the (exact_)filename of this BDS. */
4197 if (bs->file->full_open_options) {
4198 qdict_put_obj(opts, "driver",
4199 QOBJECT(qstring_from_str(drv->format_name)));
4200 QINCREF(bs->file->full_open_options);
4201 qdict_put_obj(opts, "file", QOBJECT(bs->file->full_open_options));
4202
4203 bs->full_open_options = opts;
4204 } else {
4205 QDECREF(opts);
4206 }
4207 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4208 /* There is no underlying file BDS (at least referenced by BDS.file),
4209 * so the full options QDict should be equal to the options given
4210 * specifically for this block device when it was opened (plus the
4211 * driver specification).
4212 * Because those options don't change, there is no need to update
4213 * full_open_options when it's already set. */
4214
4215 opts = qdict_new();
4216 append_open_options(opts, bs);
4217 qdict_put_obj(opts, "driver",
4218 QOBJECT(qstring_from_str(drv->format_name)));
4219
4220 if (bs->exact_filename[0]) {
4221 /* This may not work for all block protocol drivers (some may
4222 * require this filename to be parsed), but we have to find some
4223 * default solution here, so just include it. If some block driver
4224 * does not support pure options without any filename at all or
4225 * needs some special format of the options QDict, it needs to
4226 * implement the driver-specific bdrv_refresh_filename() function.
4227 */
4228 qdict_put_obj(opts, "filename",
4229 QOBJECT(qstring_from_str(bs->exact_filename)));
4230 }
4231
4232 bs->full_open_options = opts;
4233 }
4234
4235 if (bs->exact_filename[0]) {
4236 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4237 } else if (bs->full_open_options) {
4238 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4239 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4240 qstring_get_str(json));
4241 QDECREF(json);
4242 }
4243}
Benoît Canet5366d0c2014-09-05 15:46:18 +02004244
4245/* This accessor function purpose is to allow the device models to access the
4246 * BlockAcctStats structure embedded inside a BlockDriverState without being
4247 * aware of the BlockDriverState structure layout.
4248 * It will go away when the BlockAcctStats structure will be moved inside
4249 * the device models.
4250 */
4251BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)
4252{
4253 return &bs->stats;
4254}