blob: efc3c43f891111167bc527d4144535a947d2b9b4 [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 */
Peter Maydelld38ea872016-01-29 17:50:05 +000024#include "qemu/osdep.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"
Kevin Wolf91a097e2015-05-08 17:49:53 +020032#include "qapi/qmp/qbool.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010033#include "qapi/qmp/qjson.h"
Markus Armbrusterbfb197e2014-10-07 13:59:11 +020034#include "sysemu/block-backend.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010035#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010036#include "qemu/notify.h"
Daniel P. Berrange10817bf2015-09-01 14:48:02 +010037#include "qemu/coroutine.h"
Benoît Canetc13163f2014-01-23 21:31:34 +010038#include "block/qapi.h"
Luiz Capitulinob2023812011-09-21 17:16:47 -030039#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010040#include "qemu/timer.h"
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +020041#include "qapi-event.h"
Alberto Garciadb628332015-06-08 18:17:45 +020042#include "block/throttle-groups.h"
bellardfc01f7e2003-06-30 10:03:06 +000043
Juan Quintela71e72a12009-07-27 16:12:56 +020044#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000045#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000046#include <sys/queue.h>
blueswir1c5e97232009-03-07 20:06:23 +000047#ifndef __DragonFly__
bellard7674e7b2005-04-26 21:59:26 +000048#include <sys/disk.h>
49#endif
blueswir1c5e97232009-03-07 20:06:23 +000050#endif
bellard7674e7b2005-04-26 21:59:26 +000051
aliguori49dc7682009-03-08 16:26:59 +000052#ifdef _WIN32
53#include <windows.h>
54#endif
55
John Snow9bd2b082015-04-17 19:49:57 -040056/**
57 * A BdrvDirtyBitmap can be in three possible states:
58 * (1) successor is NULL and disabled is false: full r/w mode
59 * (2) successor is NULL and disabled is true: read only mode ("disabled")
60 * (3) successor is set: frozen mode.
61 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
62 * or enabled. A frozen bitmap can only abdicate() or reclaim().
63 */
Fam Zhenge4654d22013-11-13 18:29:43 +080064struct BdrvDirtyBitmap {
John Snowaa0c7ca2015-04-17 19:50:01 -040065 HBitmap *bitmap; /* Dirty sector bitmap implementation */
66 BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
67 char *name; /* Optional non-empty unique ID */
68 int64_t size; /* Size of the bitmap (Number of sectors) */
69 bool disabled; /* Bitmap is read-only */
Fam Zhenge4654d22013-11-13 18:29:43 +080070 QLIST_ENTRY(BdrvDirtyBitmap) list;
71};
72
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010073#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
74
Max Reitzc69a4dd2015-10-26 21:39:06 +010075struct BdrvStates bdrv_states = QTAILQ_HEAD_INITIALIZER(bdrv_states);
blueswir17ee930d2008-09-17 19:04:14 +000076
Benoît Canetdc364f42014-01-23 21:31:32 +010077static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
78 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
79
Max Reitz2c1d04e2016-01-29 16:36:11 +010080static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
81 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
82
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010083static QLIST_HEAD(, BlockDriver) bdrv_drivers =
84 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +000085
Kevin Wolff3930ed2015-04-08 13:43:47 +020086static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
87 const char *reference, QDict *options, int flags,
88 BlockDriverState *parent,
Max Reitzce343772015-08-26 19:47:50 +020089 const BdrvChildRole *child_role, Error **errp);
Kevin Wolff3930ed2015-04-08 13:43:47 +020090
John Snowce1ffea2015-04-17 19:50:03 -040091static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
Max Reitzc5acdc92016-01-29 16:36:01 +010092static void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs);
93
Markus Armbrustereb852012009-10-27 18:41:44 +010094/* If non-zero, use only whitelisted block drivers */
95static int use_bdrv_whitelist;
96
Max Reitz64dff522016-01-29 16:36:10 +010097static void bdrv_close(BlockDriverState *bs);
98
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +000099#ifdef _WIN32
100static int is_windows_drive_prefix(const char *filename)
101{
102 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
103 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
104 filename[1] == ':');
105}
106
107int is_windows_drive(const char *filename)
108{
109 if (is_windows_drive_prefix(filename) &&
110 filename[2] == '\0')
111 return 1;
112 if (strstart(filename, "\\\\.\\", NULL) ||
113 strstart(filename, "//./", NULL))
114 return 1;
115 return 0;
116}
117#endif
118
Kevin Wolf339064d2013-11-28 10:23:32 +0100119size_t bdrv_opt_mem_align(BlockDriverState *bs)
120{
121 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300122 /* page size or 4k (hdd sector size) should be on the safe side */
123 return MAX(4096, getpagesize());
Kevin Wolf339064d2013-11-28 10:23:32 +0100124 }
125
126 return bs->bl.opt_mem_alignment;
127}
128
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300129size_t bdrv_min_mem_align(BlockDriverState *bs)
130{
131 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300132 /* page size or 4k (hdd sector size) should be on the safe side */
133 return MAX(4096, getpagesize());
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300134 }
135
136 return bs->bl.min_mem_alignment;
137}
138
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000139/* check if the path starts with "<protocol>:" */
Max Reitz5c984152014-12-03 14:57:22 +0100140int path_has_protocol(const char *path)
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000141{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200142 const char *p;
143
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000144#ifdef _WIN32
145 if (is_windows_drive(path) ||
146 is_windows_drive_prefix(path)) {
147 return 0;
148 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200149 p = path + strcspn(path, ":/\\");
150#else
151 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000152#endif
153
Paolo Bonzini947995c2012-05-08 16:51:48 +0200154 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000155}
156
bellard83f64092006-08-01 16:21:11 +0000157int path_is_absolute(const char *path)
158{
bellard21664422007-01-07 18:22:37 +0000159#ifdef _WIN32
160 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200161 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000162 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200163 }
164 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000165#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200166 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000167#endif
bellard83f64092006-08-01 16:21:11 +0000168}
169
170/* if filename is absolute, just copy it to dest. Otherwise, build a
171 path to it by considering it is relative to base_path. URL are
172 supported. */
173void path_combine(char *dest, int dest_size,
174 const char *base_path,
175 const char *filename)
176{
177 const char *p, *p1;
178 int len;
179
180 if (dest_size <= 0)
181 return;
182 if (path_is_absolute(filename)) {
183 pstrcpy(dest, dest_size, filename);
184 } else {
185 p = strchr(base_path, ':');
186 if (p)
187 p++;
188 else
189 p = base_path;
bellard3b9f94e2007-01-07 17:27:07 +0000190 p1 = strrchr(base_path, '/');
191#ifdef _WIN32
192 {
193 const char *p2;
194 p2 = strrchr(base_path, '\\');
195 if (!p1 || p2 > p1)
196 p1 = p2;
197 }
198#endif
bellard83f64092006-08-01 16:21:11 +0000199 if (p1)
200 p1++;
201 else
202 p1 = base_path;
203 if (p1 > p)
204 p = p1;
205 len = p - base_path;
206 if (len > dest_size - 1)
207 len = dest_size - 1;
208 memcpy(dest, base_path, len);
209 dest[len] = '\0';
210 pstrcat(dest, dest_size, filename);
211 }
212}
213
Max Reitz0a828552014-11-26 17:20:25 +0100214void bdrv_get_full_backing_filename_from_filename(const char *backed,
215 const char *backing,
Max Reitz9f074292014-11-26 17:20:26 +0100216 char *dest, size_t sz,
217 Error **errp)
Max Reitz0a828552014-11-26 17:20:25 +0100218{
Max Reitz9f074292014-11-26 17:20:26 +0100219 if (backing[0] == '\0' || path_has_protocol(backing) ||
220 path_is_absolute(backing))
221 {
Max Reitz0a828552014-11-26 17:20:25 +0100222 pstrcpy(dest, sz, backing);
Max Reitz9f074292014-11-26 17:20:26 +0100223 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
224 error_setg(errp, "Cannot use relative backing file names for '%s'",
225 backed);
Max Reitz0a828552014-11-26 17:20:25 +0100226 } else {
227 path_combine(dest, sz, backed, backing);
228 }
229}
230
Max Reitz9f074292014-11-26 17:20:26 +0100231void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
232 Error **errp)
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200233{
Max Reitz9f074292014-11-26 17:20:26 +0100234 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
235
236 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
237 dest, sz, errp);
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200238}
239
Stefan Hajnoczi0eb72172015-04-28 14:27:51 +0100240void bdrv_register(BlockDriver *bdrv)
241{
242 bdrv_setup_io_funcs(bdrv);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +0200243
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100244 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000245}
bellardb3380822004-03-14 21:38:54 +0000246
Markus Armbruster7f06d472014-10-07 13:59:12 +0200247BlockDriverState *bdrv_new_root(void)
bellardfc01f7e2003-06-30 10:03:06 +0000248{
Markus Armbruster7f06d472014-10-07 13:59:12 +0200249 BlockDriverState *bs = bdrv_new();
Markus Armbrustere4e99862014-10-07 13:59:03 +0200250
Markus Armbrustere4e99862014-10-07 13:59:03 +0200251 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
Markus Armbrustere4e99862014-10-07 13:59:03 +0200252 return bs;
253}
254
255BlockDriverState *bdrv_new(void)
256{
257 BlockDriverState *bs;
258 int i;
259
Markus Armbruster5839e532014-08-19 10:31:08 +0200260 bs = g_new0(BlockDriverState, 1);
Fam Zhenge4654d22013-11-13 18:29:43 +0800261 QLIST_INIT(&bs->dirty_bitmaps);
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800262 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
263 QLIST_INIT(&bs->op_blockers[i]);
264 }
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200265 notifier_with_return_list_init(&bs->before_write_notifiers);
Benoît Canetcc0681c2013-09-02 14:14:39 +0200266 qemu_co_queue_init(&bs->throttled_reqs[0]);
267 qemu_co_queue_init(&bs->throttled_reqs[1]);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800268 bs->refcnt = 1;
Stefan Hajnoczidcd04222014-05-08 16:34:37 +0200269 bs->aio_context = qemu_get_aio_context();
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200270
Max Reitz2c1d04e2016-01-29 16:36:11 +0100271 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
272
bellardb3380822004-03-14 21:38:54 +0000273 return bs;
274}
275
bellardea2384d2004-08-01 21:59:26 +0000276BlockDriver *bdrv_find_format(const char *format_name)
277{
278 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100279 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
280 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000281 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100282 }
bellardea2384d2004-08-01 21:59:26 +0000283 }
284 return NULL;
285}
286
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800287static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100288{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800289 static const char *whitelist_rw[] = {
290 CONFIG_BDRV_RW_WHITELIST
291 };
292 static const char *whitelist_ro[] = {
293 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100294 };
295 const char **p;
296
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800297 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100298 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800299 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100300
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800301 for (p = whitelist_rw; *p; p++) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100302 if (!strcmp(drv->format_name, *p)) {
303 return 1;
304 }
305 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800306 if (read_only) {
307 for (p = whitelist_ro; *p; p++) {
308 if (!strcmp(drv->format_name, *p)) {
309 return 1;
310 }
311 }
312 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100313 return 0;
314}
315
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800316typedef struct CreateCo {
317 BlockDriver *drv;
318 char *filename;
Chunyan Liu83d05212014-06-05 17:20:51 +0800319 QemuOpts *opts;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800320 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200321 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800322} CreateCo;
323
324static void coroutine_fn bdrv_create_co_entry(void *opaque)
325{
Max Reitzcc84d902013-09-06 17:14:26 +0200326 Error *local_err = NULL;
327 int ret;
328
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800329 CreateCo *cco = opaque;
330 assert(cco->drv);
331
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800332 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100333 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200334 error_propagate(&cco->err, local_err);
335 }
336 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800337}
338
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200339int bdrv_create(BlockDriver *drv, const char* filename,
Chunyan Liu83d05212014-06-05 17:20:51 +0800340 QemuOpts *opts, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000341{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800342 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200343
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800344 Coroutine *co;
345 CreateCo cco = {
346 .drv = drv,
347 .filename = g_strdup(filename),
Chunyan Liu83d05212014-06-05 17:20:51 +0800348 .opts = opts,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800349 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200350 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800351 };
352
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800353 if (!drv->bdrv_create) {
Max Reitzcc84d902013-09-06 17:14:26 +0200354 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300355 ret = -ENOTSUP;
356 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800357 }
358
359 if (qemu_in_coroutine()) {
360 /* Fast-path if already in coroutine context */
361 bdrv_create_co_entry(&cco);
362 } else {
363 co = qemu_coroutine_create(bdrv_create_co_entry);
364 qemu_coroutine_enter(co, &cco);
365 while (cco.ret == NOT_DONE) {
Paolo Bonzinib47ec2c2014-07-07 15:18:01 +0200366 aio_poll(qemu_get_aio_context(), true);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800367 }
368 }
369
370 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200371 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100372 if (cco.err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200373 error_propagate(errp, cco.err);
374 } else {
375 error_setg_errno(errp, -ret, "Could not create image");
376 }
377 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800378
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300379out:
380 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800381 return ret;
bellardea2384d2004-08-01 21:59:26 +0000382}
383
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800384int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200385{
386 BlockDriver *drv;
Max Reitzcc84d902013-09-06 17:14:26 +0200387 Error *local_err = NULL;
388 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200389
Max Reitzb65a5e12015-02-05 13:58:12 -0500390 drv = bdrv_find_protocol(filename, true, errp);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200391 if (drv == NULL) {
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000392 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200393 }
394
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800395 ret = bdrv_create(drv, filename, opts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100396 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200397 error_propagate(errp, local_err);
398 }
399 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200400}
401
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100402/**
403 * Try to get @bs's logical and physical block size.
404 * On success, store them in @bsz struct and return 0.
405 * On failure return -errno.
406 * @bs must not be empty.
407 */
408int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
409{
410 BlockDriver *drv = bs->drv;
411
412 if (drv && drv->bdrv_probe_blocksizes) {
413 return drv->bdrv_probe_blocksizes(bs, bsz);
414 }
415
416 return -ENOTSUP;
417}
418
419/**
420 * Try to get @bs's geometry (cyls, heads, sectors).
421 * On success, store them in @geo struct and return 0.
422 * On failure return -errno.
423 * @bs must not be empty.
424 */
425int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
426{
427 BlockDriver *drv = bs->drv;
428
429 if (drv && drv->bdrv_probe_geometry) {
430 return drv->bdrv_probe_geometry(bs, geo);
431 }
432
433 return -ENOTSUP;
434}
435
Jim Meyeringeba25052012-05-28 09:27:54 +0200436/*
437 * Create a uniquely-named empty temporary file.
438 * Return 0 upon success, otherwise a negative errno value.
439 */
440int get_tmp_filename(char *filename, int size)
441{
bellardd5249392004-08-03 21:14:23 +0000442#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000443 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200444 /* GetTempFileName requires that its output buffer (4th param)
445 have length MAX_PATH or greater. */
446 assert(size >= MAX_PATH);
447 return (GetTempPath(MAX_PATH, temp_dir)
448 && GetTempFileName(temp_dir, "qem", 0, filename)
449 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000450#else
bellardea2384d2004-08-01 21:59:26 +0000451 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000452 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000453 tmpdir = getenv("TMPDIR");
Amit Shah69bef792014-02-26 15:12:37 +0530454 if (!tmpdir) {
455 tmpdir = "/var/tmp";
456 }
Jim Meyeringeba25052012-05-28 09:27:54 +0200457 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
458 return -EOVERFLOW;
459 }
bellardea2384d2004-08-01 21:59:26 +0000460 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800461 if (fd < 0) {
462 return -errno;
463 }
464 if (close(fd) != 0) {
465 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200466 return -errno;
467 }
468 return 0;
bellardd5249392004-08-03 21:14:23 +0000469#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200470}
bellardea2384d2004-08-01 21:59:26 +0000471
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200472/*
473 * Detect host devices. By convention, /dev/cdrom[N] is always
474 * recognized as a host CDROM.
475 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200476static BlockDriver *find_hdev_driver(const char *filename)
477{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200478 int score_max = 0, score;
479 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200480
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100481 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200482 if (d->bdrv_probe_device) {
483 score = d->bdrv_probe_device(filename);
484 if (score > score_max) {
485 score_max = score;
486 drv = d;
487 }
488 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200489 }
490
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200491 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200492}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200493
Kevin Wolf98289622013-07-10 15:47:39 +0200494BlockDriver *bdrv_find_protocol(const char *filename,
Max Reitzb65a5e12015-02-05 13:58:12 -0500495 bool allow_protocol_prefix,
496 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200497{
498 BlockDriver *drv1;
499 char protocol[128];
500 int len;
501 const char *p;
502
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200503 /* TODO Drivers without bdrv_file_open must be specified explicitly */
504
Christoph Hellwig39508e72010-06-23 12:25:17 +0200505 /*
506 * XXX(hch): we really should not let host device detection
507 * override an explicit protocol specification, but moving this
508 * later breaks access to device names with colons in them.
509 * Thanks to the brain-dead persistent naming schemes on udev-
510 * based Linux systems those actually are quite common.
511 */
512 drv1 = find_hdev_driver(filename);
513 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200514 return drv1;
515 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200516
Kevin Wolf98289622013-07-10 15:47:39 +0200517 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Max Reitzef810432014-12-02 18:32:42 +0100518 return &bdrv_file;
Christoph Hellwig39508e72010-06-23 12:25:17 +0200519 }
Kevin Wolf98289622013-07-10 15:47:39 +0200520
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000521 p = strchr(filename, ':');
522 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200523 len = p - filename;
524 if (len > sizeof(protocol) - 1)
525 len = sizeof(protocol) - 1;
526 memcpy(protocol, filename, len);
527 protocol[len] = '\0';
528 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
529 if (drv1->protocol_name &&
530 !strcmp(drv1->protocol_name, protocol)) {
531 return drv1;
532 }
533 }
Max Reitzb65a5e12015-02-05 13:58:12 -0500534
535 error_setg(errp, "Unknown protocol '%s'", protocol);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200536 return NULL;
537}
538
Markus Armbrusterc6684242014-11-20 16:27:10 +0100539/*
540 * Guess image format by probing its contents.
541 * This is not a good idea when your image is raw (CVE-2008-2004), but
542 * we do it anyway for backward compatibility.
543 *
544 * @buf contains the image's first @buf_size bytes.
Kevin Wolf7cddd372014-11-20 16:27:11 +0100545 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
546 * but can be smaller if the image file is smaller)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100547 * @filename is its filename.
548 *
549 * For all block drivers, call the bdrv_probe() method to get its
550 * probing score.
551 * Return the first block driver with the highest probing score.
552 */
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100553BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
554 const char *filename)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100555{
556 int score_max = 0, score;
557 BlockDriver *drv = NULL, *d;
558
559 QLIST_FOREACH(d, &bdrv_drivers, list) {
560 if (d->bdrv_probe) {
561 score = d->bdrv_probe(buf, buf_size, filename);
562 if (score > score_max) {
563 score_max = score;
564 drv = d;
565 }
566 }
567 }
568
569 return drv;
570}
571
Kevin Wolff500a6d2012-11-12 17:35:27 +0100572static int find_image_format(BlockDriverState *bs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200573 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000574{
Markus Armbrusterc6684242014-11-20 16:27:10 +0100575 BlockDriver *drv;
Kevin Wolf7cddd372014-11-20 16:27:11 +0100576 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100577 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700578
Kevin Wolf08a00552010-06-01 18:37:31 +0200579 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300580 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Max Reitzef810432014-12-02 18:32:42 +0100581 *pdrv = &bdrv_raw;
Stefan Weilc98ac352010-07-21 21:51:51 +0200582 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700583 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700584
bellard83f64092006-08-01 16:21:11 +0000585 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000586 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200587 error_setg_errno(errp, -ret, "Could not read image for determining its "
588 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200589 *pdrv = NULL;
590 return ret;
bellard83f64092006-08-01 16:21:11 +0000591 }
592
Markus Armbrusterc6684242014-11-20 16:27:10 +0100593 drv = bdrv_probe_all(buf, ret, filename);
Stefan Weilc98ac352010-07-21 21:51:51 +0200594 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200595 error_setg(errp, "Could not determine image format: No compatible "
596 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200597 ret = -ENOENT;
598 }
599 *pdrv = drv;
600 return ret;
bellardea2384d2004-08-01 21:59:26 +0000601}
602
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100603/**
604 * Set the current 'total_sectors' value
Markus Armbruster65a9bb22014-06-26 13:23:17 +0200605 * Return 0 on success, -errno on error.
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100606 */
607static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
608{
609 BlockDriver *drv = bs->drv;
610
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700611 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300612 if (bdrv_is_sg(bs))
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700613 return 0;
614
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100615 /* query actual device if possible, otherwise just trust the hint */
616 if (drv->bdrv_getlength) {
617 int64_t length = drv->bdrv_getlength(bs);
618 if (length < 0) {
619 return length;
620 }
Fam Zheng7e382002013-11-06 19:48:06 +0800621 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100622 }
623
624 bs->total_sectors = hint;
625 return 0;
626}
627
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100628/**
Kevin Wolfcddff5b2015-11-16 16:43:27 +0100629 * Combines a QDict of new block driver @options with any missing options taken
630 * from @old_options, so that leaving out an option defaults to its old value.
631 */
632static void bdrv_join_options(BlockDriverState *bs, QDict *options,
633 QDict *old_options)
634{
635 if (bs->drv && bs->drv->bdrv_join_options) {
636 bs->drv->bdrv_join_options(options, old_options);
637 } else {
638 qdict_join(options, old_options, false);
639 }
640}
641
642/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100643 * Set open flags for a given discard mode
644 *
645 * Return 0 on success, -1 if the discard mode was invalid.
646 */
647int bdrv_parse_discard_flags(const char *mode, int *flags)
648{
649 *flags &= ~BDRV_O_UNMAP;
650
651 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
652 /* do nothing */
653 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
654 *flags |= BDRV_O_UNMAP;
655 } else {
656 return -1;
657 }
658
659 return 0;
660}
661
662/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100663 * Set open flags for a given cache mode
664 *
665 * Return 0 on success, -1 if the cache mode was invalid.
666 */
667int bdrv_parse_cache_flags(const char *mode, int *flags)
668{
669 *flags &= ~BDRV_O_CACHE_MASK;
670
671 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
672 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100673 } else if (!strcmp(mode, "directsync")) {
674 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100675 } else if (!strcmp(mode, "writeback")) {
676 *flags |= BDRV_O_CACHE_WB;
677 } else if (!strcmp(mode, "unsafe")) {
678 *flags |= BDRV_O_CACHE_WB;
679 *flags |= BDRV_O_NO_FLUSH;
680 } else if (!strcmp(mode, "writethrough")) {
681 /* this is the default */
682 } else {
683 return -1;
684 }
685
686 return 0;
687}
688
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200689/*
Kevin Wolfb1e6fc02014-05-06 12:11:42 +0200690 * Returns the flags that a temporary snapshot should get, based on the
691 * originally requested flags (the originally requested image will have flags
692 * like a backing file)
693 */
694static int bdrv_temp_snapshot_flags(int flags)
695{
696 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
697}
698
699/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200700 * Returns the options and flags that bs->file should get if a protocol driver
701 * is expected, based on the given options and flags for the parent BDS
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200702 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200703static void bdrv_inherited_options(int *child_flags, QDict *child_options,
704 int parent_flags, QDict *parent_options)
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200705{
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200706 int flags = parent_flags;
707
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200708 /* Enable protocol handling, disable format probing for bs->file */
709 flags |= BDRV_O_PROTOCOL;
710
Kevin Wolf91a097e2015-05-08 17:49:53 +0200711 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
712 * the parent. */
713 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
714 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
715
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200716 /* Our block drivers take care to send flushes and respect unmap policy,
Kevin Wolf91a097e2015-05-08 17:49:53 +0200717 * so we can default to enable both on lower layers regardless of the
718 * corresponding parent options. */
719 qdict_set_default_str(child_options, BDRV_OPT_CACHE_WB, "on");
720 flags |= BDRV_O_UNMAP;
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200721
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200722 /* Clear flags that only apply to the top layer */
Kevin Wolf5669b442014-04-11 21:36:45 +0200723 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200724
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200725 *child_flags = flags;
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200726}
727
Kevin Wolff3930ed2015-04-08 13:43:47 +0200728const BdrvChildRole child_file = {
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200729 .inherit_options = bdrv_inherited_options,
Kevin Wolff3930ed2015-04-08 13:43:47 +0200730};
731
732/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200733 * Returns the options and flags that bs->file should get if the use of formats
734 * (and not only protocols) is permitted for it, based on the given options and
735 * flags for the parent BDS
Kevin Wolff3930ed2015-04-08 13:43:47 +0200736 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200737static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
738 int parent_flags, QDict *parent_options)
Kevin Wolff3930ed2015-04-08 13:43:47 +0200739{
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200740 child_file.inherit_options(child_flags, child_options,
741 parent_flags, parent_options);
742
743 *child_flags &= ~BDRV_O_PROTOCOL;
Kevin Wolff3930ed2015-04-08 13:43:47 +0200744}
745
746const BdrvChildRole child_format = {
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200747 .inherit_options = bdrv_inherited_fmt_options,
Kevin Wolff3930ed2015-04-08 13:43:47 +0200748};
749
Kevin Wolf317fc442014-04-25 13:27:34 +0200750/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200751 * Returns the options and flags that bs->backing should get, based on the
752 * given options and flags for the parent BDS
Kevin Wolf317fc442014-04-25 13:27:34 +0200753 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200754static void bdrv_backing_options(int *child_flags, QDict *child_options,
755 int parent_flags, QDict *parent_options)
Kevin Wolf317fc442014-04-25 13:27:34 +0200756{
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200757 int flags = parent_flags;
758
Kevin Wolf91a097e2015-05-08 17:49:53 +0200759 /* The cache mode is inherited unmodified for backing files */
760 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_WB);
761 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
762 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
763
Kevin Wolf317fc442014-04-25 13:27:34 +0200764 /* backing files always opened read-only */
765 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
766
767 /* snapshot=on is handled on the top layer */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200768 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
Kevin Wolf317fc442014-04-25 13:27:34 +0200769
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200770 *child_flags = flags;
Kevin Wolf317fc442014-04-25 13:27:34 +0200771}
772
Kevin Wolff3930ed2015-04-08 13:43:47 +0200773static const BdrvChildRole child_backing = {
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200774 .inherit_options = bdrv_backing_options,
Kevin Wolff3930ed2015-04-08 13:43:47 +0200775};
776
Kevin Wolf7b272452012-11-12 17:05:39 +0100777static int bdrv_open_flags(BlockDriverState *bs, int flags)
778{
779 int open_flags = flags | BDRV_O_CACHE_WB;
780
781 /*
782 * Clear flags that are internal to the block layer before opening the
783 * image.
784 */
Kevin Wolf20cca272014-06-04 14:33:27 +0200785 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
Kevin Wolf7b272452012-11-12 17:05:39 +0100786
787 /*
788 * Snapshots should be writable.
789 */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200790 if (flags & BDRV_O_TEMPORARY) {
Kevin Wolf7b272452012-11-12 17:05:39 +0100791 open_flags |= BDRV_O_RDWR;
792 }
793
794 return open_flags;
795}
796
Kevin Wolf91a097e2015-05-08 17:49:53 +0200797static void update_flags_from_options(int *flags, QemuOpts *opts)
798{
799 *flags &= ~BDRV_O_CACHE_MASK;
800
801 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_WB));
802 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, false)) {
803 *flags |= BDRV_O_CACHE_WB;
804 }
805
806 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
807 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
808 *flags |= BDRV_O_NO_FLUSH;
809 }
810
811 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
812 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
813 *flags |= BDRV_O_NOCACHE;
814 }
815}
816
817static void update_options_from_flags(QDict *options, int flags)
818{
819 if (!qdict_haskey(options, BDRV_OPT_CACHE_WB)) {
820 qdict_put(options, BDRV_OPT_CACHE_WB,
821 qbool_from_bool(flags & BDRV_O_CACHE_WB));
822 }
823 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
824 qdict_put(options, BDRV_OPT_CACHE_DIRECT,
825 qbool_from_bool(flags & BDRV_O_NOCACHE));
826 }
827 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
828 qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH,
829 qbool_from_bool(flags & BDRV_O_NO_FLUSH));
830 }
831}
832
Kevin Wolf636ea372014-01-24 14:11:52 +0100833static void bdrv_assign_node_name(BlockDriverState *bs,
834 const char *node_name,
835 Error **errp)
Benoît Canet6913c0c2014-01-23 21:31:33 +0100836{
Jeff Cody15489c72015-10-12 19:36:50 -0400837 char *gen_node_name = NULL;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100838
Jeff Cody15489c72015-10-12 19:36:50 -0400839 if (!node_name) {
840 node_name = gen_node_name = id_generate(ID_BLOCK);
841 } else if (!id_wellformed(node_name)) {
842 /*
843 * Check for empty string or invalid characters, but not if it is
844 * generated (generated names use characters not available to the user)
845 */
Kevin Wolf9aebf3b2014-09-25 09:54:02 +0200846 error_setg(errp, "Invalid node name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100847 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100848 }
849
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100850 /* takes care of avoiding namespaces collisions */
Markus Armbruster7f06d472014-10-07 13:59:12 +0200851 if (blk_by_name(node_name)) {
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100852 error_setg(errp, "node-name=%s is conflicting with a device id",
853 node_name);
Jeff Cody15489c72015-10-12 19:36:50 -0400854 goto out;
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100855 }
856
Benoît Canet6913c0c2014-01-23 21:31:33 +0100857 /* takes care of avoiding duplicates node names */
858 if (bdrv_find_node(node_name)) {
859 error_setg(errp, "Duplicate node name");
Jeff Cody15489c72015-10-12 19:36:50 -0400860 goto out;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100861 }
862
863 /* copy node name into the bs and insert it into the graph list */
864 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
865 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
Jeff Cody15489c72015-10-12 19:36:50 -0400866out:
867 g_free(gen_node_name);
Benoît Canet6913c0c2014-01-23 21:31:33 +0100868}
869
Kevin Wolf18edf282015-04-07 17:12:56 +0200870static QemuOptsList bdrv_runtime_opts = {
871 .name = "bdrv_common",
872 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
873 .desc = {
874 {
875 .name = "node-name",
876 .type = QEMU_OPT_STRING,
877 .help = "Node name of the block device node",
878 },
Kevin Wolf62392eb2015-04-24 16:38:02 +0200879 {
880 .name = "driver",
881 .type = QEMU_OPT_STRING,
882 .help = "Block driver to use for the node",
883 },
Kevin Wolf91a097e2015-05-08 17:49:53 +0200884 {
885 .name = BDRV_OPT_CACHE_WB,
886 .type = QEMU_OPT_BOOL,
887 .help = "Enable writeback mode",
888 },
889 {
890 .name = BDRV_OPT_CACHE_DIRECT,
891 .type = QEMU_OPT_BOOL,
892 .help = "Bypass software writeback cache on the host",
893 },
894 {
895 .name = BDRV_OPT_CACHE_NO_FLUSH,
896 .type = QEMU_OPT_BOOL,
897 .help = "Ignore flush requests",
898 },
Kevin Wolf18edf282015-04-07 17:12:56 +0200899 { /* end of list */ }
900 },
901};
902
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200903/*
Kevin Wolf57915332010-04-14 15:24:50 +0200904 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +0100905 *
906 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +0200907 */
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200908static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100909 QDict *options, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +0200910{
911 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200912 const char *filename;
Kevin Wolf62392eb2015-04-24 16:38:02 +0200913 const char *driver_name = NULL;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100914 const char *node_name = NULL;
Kevin Wolf18edf282015-04-07 17:12:56 +0200915 QemuOpts *opts;
Kevin Wolf62392eb2015-04-24 16:38:02 +0200916 BlockDriver *drv;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200917 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +0200918
Paolo Bonzini64058752012-05-08 16:51:49 +0200919 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +0100920 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +0200921
Kevin Wolf62392eb2015-04-24 16:38:02 +0200922 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
923 qemu_opts_absorb_qdict(opts, options, &local_err);
924 if (local_err) {
925 error_propagate(errp, local_err);
926 ret = -EINVAL;
927 goto fail_opts;
928 }
929
930 driver_name = qemu_opt_get(opts, "driver");
931 drv = bdrv_find_format(driver_name);
932 assert(drv != NULL);
933
Kevin Wolf45673672013-04-22 17:48:40 +0200934 if (file != NULL) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200935 filename = file->bs->filename;
Kevin Wolf45673672013-04-22 17:48:40 +0200936 } else {
937 filename = qdict_get_try_str(options, "filename");
938 }
939
Kevin Wolf765003d2014-02-03 14:49:42 +0100940 if (drv->bdrv_needs_filename && !filename) {
941 error_setg(errp, "The '%s' block driver requires a file name",
942 drv->format_name);
Kevin Wolf18edf282015-04-07 17:12:56 +0200943 ret = -EINVAL;
944 goto fail_opts;
945 }
946
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100947 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
948 drv->format_name);
Kevin Wolf62392eb2015-04-24 16:38:02 +0200949
Kevin Wolf18edf282015-04-07 17:12:56 +0200950 node_name = qemu_opt_get(opts, "node-name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100951 bdrv_assign_node_name(bs, node_name, &local_err);
Markus Armbruster0fb63952014-04-25 16:50:31 +0200952 if (local_err) {
Kevin Wolf636ea372014-01-24 14:11:52 +0100953 error_propagate(errp, local_err);
Kevin Wolf18edf282015-04-07 17:12:56 +0200954 ret = -EINVAL;
955 goto fail_opts;
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100956 }
957
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100958 bs->request_alignment = 512;
Asias He0d51b4d2013-08-22 15:24:14 +0800959 bs->zero_beyond_eof = true;
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100960 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800961
962 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200963 error_setg(errp,
964 !bs->read_only && bdrv_is_whitelisted(drv, true)
965 ? "Driver '%s' can only be used for read-only devices"
966 : "Driver '%s' is not whitelisted",
967 drv->format_name);
Kevin Wolf18edf282015-04-07 17:12:56 +0200968 ret = -ENOTSUP;
969 goto fail_opts;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800970 }
Kevin Wolf57915332010-04-14 15:24:50 +0200971
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000972 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100973 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200974 if (!bs->read_only) {
975 bdrv_enable_copy_on_read(bs);
976 } else {
977 error_setg(errp, "Can't use copy-on-read on read-only device");
Kevin Wolf18edf282015-04-07 17:12:56 +0200978 ret = -EINVAL;
979 goto fail_opts;
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200980 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000981 }
982
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100983 if (filename != NULL) {
984 pstrcpy(bs->filename, sizeof(bs->filename), filename);
985 } else {
986 bs->filename[0] = '\0';
987 }
Max Reitz91af7012014-07-18 20:24:56 +0200988 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
Kevin Wolf57915332010-04-14 15:24:50 +0200989
Kevin Wolf57915332010-04-14 15:24:50 +0200990 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500991 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200992
Kevin Wolf91a097e2015-05-08 17:49:53 +0200993 /* Apply cache mode options */
994 update_flags_from_options(&bs->open_flags, opts);
995 bdrv_set_enable_write_cache(bs, bs->open_flags & BDRV_O_CACHE_WB);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100996
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200997 /* Open the image, either directly or using a protocol */
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100998 open_flags = bdrv_open_flags(bs, bs->open_flags);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200999 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +01001000 assert(file == NULL);
Benoît Canet030be322013-09-24 17:07:04 +02001001 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001002 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001003 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +02001004 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001005 error_setg(errp, "Can't use '%s' as a block driver for the "
1006 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +02001007 ret = -EINVAL;
1008 goto free_and_fail;
1009 }
Kevin Wolff500a6d2012-11-12 17:35:27 +01001010 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001011 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001012 }
1013
Kevin Wolf57915332010-04-14 15:24:50 +02001014 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +01001015 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001016 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +08001017 } else if (bs->filename[0]) {
1018 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001019 } else {
1020 error_setg_errno(errp, -ret, "Could not open image");
1021 }
Kevin Wolf57915332010-04-14 15:24:50 +02001022 goto free_and_fail;
1023 }
1024
Markus Armbrustera1f688f2015-03-13 21:09:40 +01001025 if (bs->encrypted) {
1026 error_report("Encrypted images are deprecated");
1027 error_printf("Support for them will be removed in a future release.\n"
1028 "You can use 'qemu-img convert' to convert your image"
1029 " to an unencrypted one.\n");
1030 }
1031
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001032 ret = refresh_total_sectors(bs, bs->total_sectors);
1033 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001034 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001035 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +02001036 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001037
Kevin Wolf3baca892014-07-16 17:48:16 +02001038 bdrv_refresh_limits(bs, &local_err);
1039 if (local_err) {
1040 error_propagate(errp, local_err);
1041 ret = -EINVAL;
1042 goto free_and_fail;
1043 }
1044
Paolo Bonzinic25f53b2011-11-29 12:42:20 +01001045 assert(bdrv_opt_mem_align(bs) != 0);
Denis V. Lunev4196d2f2015-05-12 17:30:55 +03001046 assert(bdrv_min_mem_align(bs) != 0);
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +03001047 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
Kevin Wolf18edf282015-04-07 17:12:56 +02001048
1049 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +02001050 return 0;
1051
1052free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001053 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -05001054 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +02001055 bs->opaque = NULL;
1056 bs->drv = NULL;
Kevin Wolf18edf282015-04-07 17:12:56 +02001057fail_opts:
1058 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +02001059 return ret;
1060}
1061
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001062static QDict *parse_json_filename(const char *filename, Error **errp)
1063{
1064 QObject *options_obj;
1065 QDict *options;
1066 int ret;
1067
1068 ret = strstart(filename, "json:", &filename);
1069 assert(ret);
1070
1071 options_obj = qobject_from_json(filename);
1072 if (!options_obj) {
1073 error_setg(errp, "Could not parse the JSON options");
1074 return NULL;
1075 }
1076
1077 if (qobject_type(options_obj) != QTYPE_QDICT) {
1078 qobject_decref(options_obj);
1079 error_setg(errp, "Invalid JSON object given");
1080 return NULL;
1081 }
1082
1083 options = qobject_to_qdict(options_obj);
1084 qdict_flatten(options);
1085
1086 return options;
1087}
1088
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001089static void parse_json_protocol(QDict *options, const char **pfilename,
1090 Error **errp)
1091{
1092 QDict *json_options;
1093 Error *local_err = NULL;
1094
1095 /* Parse json: pseudo-protocol */
1096 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1097 return;
1098 }
1099
1100 json_options = parse_json_filename(*pfilename, &local_err);
1101 if (local_err) {
1102 error_propagate(errp, local_err);
1103 return;
1104 }
1105
1106 /* Options given in the filename have lower priority than options
1107 * specified directly */
1108 qdict_join(options, json_options, false);
1109 QDECREF(json_options);
1110 *pfilename = NULL;
1111}
1112
Kevin Wolf57915332010-04-14 15:24:50 +02001113/*
Kevin Wolff54120f2014-05-26 11:09:59 +02001114 * Fills in default options for opening images and converts the legacy
1115 * filename/flags pair to option QDict entries.
Max Reitz53a29512015-03-19 14:53:16 -04001116 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1117 * block driver has been specified explicitly.
Kevin Wolff54120f2014-05-26 11:09:59 +02001118 */
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001119static int bdrv_fill_options(QDict **options, const char *filename,
Max Reitz053e1572015-08-26 19:47:51 +02001120 int *flags, Error **errp)
Kevin Wolff54120f2014-05-26 11:09:59 +02001121{
1122 const char *drvname;
Max Reitz53a29512015-03-19 14:53:16 -04001123 bool protocol = *flags & BDRV_O_PROTOCOL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001124 bool parse_filename = false;
Max Reitz053e1572015-08-26 19:47:51 +02001125 BlockDriver *drv = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001126 Error *local_err = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001127
Max Reitz53a29512015-03-19 14:53:16 -04001128 drvname = qdict_get_try_str(*options, "driver");
Max Reitz053e1572015-08-26 19:47:51 +02001129 if (drvname) {
1130 drv = bdrv_find_format(drvname);
1131 if (!drv) {
1132 error_setg(errp, "Unknown driver '%s'", drvname);
1133 return -ENOENT;
1134 }
1135 /* If the user has explicitly specified the driver, this choice should
1136 * override the BDRV_O_PROTOCOL flag */
1137 protocol = drv->bdrv_file_open;
Max Reitz53a29512015-03-19 14:53:16 -04001138 }
1139
1140 if (protocol) {
1141 *flags |= BDRV_O_PROTOCOL;
1142 } else {
1143 *flags &= ~BDRV_O_PROTOCOL;
1144 }
1145
Kevin Wolf91a097e2015-05-08 17:49:53 +02001146 /* Translate cache options from flags into options */
1147 update_options_from_flags(*options, *flags);
1148
Kevin Wolff54120f2014-05-26 11:09:59 +02001149 /* Fetch the file name from the options QDict if necessary */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001150 if (protocol && filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001151 if (!qdict_haskey(*options, "filename")) {
1152 qdict_put(*options, "filename", qstring_from_str(filename));
1153 parse_filename = true;
1154 } else {
1155 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1156 "the same time");
1157 return -EINVAL;
1158 }
1159 }
1160
1161 /* Find the right block driver */
1162 filename = qdict_get_try_str(*options, "filename");
Kevin Wolff54120f2014-05-26 11:09:59 +02001163
Max Reitz053e1572015-08-26 19:47:51 +02001164 if (!drvname && protocol) {
1165 if (filename) {
1166 drv = bdrv_find_protocol(filename, parse_filename, errp);
1167 if (!drv) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001168 return -EINVAL;
1169 }
Max Reitz053e1572015-08-26 19:47:51 +02001170
1171 drvname = drv->format_name;
1172 qdict_put(*options, "driver", qstring_from_str(drvname));
1173 } else {
1174 error_setg(errp, "Must specify either driver or file");
1175 return -EINVAL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001176 }
1177 }
1178
Kevin Wolf17b005f2014-05-27 10:50:29 +02001179 assert(drv || !protocol);
Kevin Wolff54120f2014-05-26 11:09:59 +02001180
1181 /* Driver-specific filename parsing */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001182 if (drv && drv->bdrv_parse_filename && parse_filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001183 drv->bdrv_parse_filename(filename, *options, &local_err);
1184 if (local_err) {
1185 error_propagate(errp, local_err);
1186 return -EINVAL;
1187 }
1188
1189 if (!drv->bdrv_needs_filename) {
1190 qdict_del(*options, "filename");
1191 }
1192 }
1193
Max Reitzd44f9282015-10-19 17:53:08 +02001194 if (runstate_check(RUN_STATE_INMIGRATE)) {
Kevin Wolf04c01a52016-01-13 15:56:06 +01001195 *flags |= BDRV_O_INACTIVE;
Max Reitzd44f9282015-10-19 17:53:08 +02001196 }
1197
Kevin Wolff54120f2014-05-26 11:09:59 +02001198 return 0;
1199}
1200
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001201static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1202 BlockDriverState *child_bs,
Kevin Wolf260fecf2015-04-27 13:46:22 +02001203 const char *child_name,
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001204 const BdrvChildRole *child_role)
Kevin Wolfdf581792015-06-15 11:53:47 +02001205{
1206 BdrvChild *child = g_new(BdrvChild, 1);
1207 *child = (BdrvChild) {
1208 .bs = child_bs,
Kevin Wolf260fecf2015-04-27 13:46:22 +02001209 .name = g_strdup(child_name),
Kevin Wolfdf581792015-06-15 11:53:47 +02001210 .role = child_role,
1211 };
1212
1213 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
Kevin Wolfd42a8a92015-09-17 13:18:23 +02001214 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001215
1216 return child;
Kevin Wolfdf581792015-06-15 11:53:47 +02001217}
1218
Kevin Wolf3f09bfb2015-09-15 11:58:23 +02001219static void bdrv_detach_child(BdrvChild *child)
Kevin Wolf33a60402015-06-15 13:51:04 +02001220{
1221 QLIST_REMOVE(child, next);
Kevin Wolfd42a8a92015-09-17 13:18:23 +02001222 QLIST_REMOVE(child, next_parent);
Kevin Wolf260fecf2015-04-27 13:46:22 +02001223 g_free(child->name);
Kevin Wolf33a60402015-06-15 13:51:04 +02001224 g_free(child);
1225}
1226
1227void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1228{
Kevin Wolf779020c2015-10-13 14:09:44 +02001229 BlockDriverState *child_bs;
1230
1231 if (child == NULL) {
1232 return;
1233 }
Kevin Wolf33a60402015-06-15 13:51:04 +02001234
1235 if (child->bs->inherits_from == parent) {
1236 child->bs->inherits_from = NULL;
1237 }
1238
Kevin Wolf779020c2015-10-13 14:09:44 +02001239 child_bs = child->bs;
Kevin Wolf33a60402015-06-15 13:51:04 +02001240 bdrv_detach_child(child);
1241 bdrv_unref(child_bs);
1242}
1243
Kevin Wolf5db15a52015-09-14 15:33:33 +02001244/*
1245 * Sets the backing file link of a BDS. A new reference is created; callers
1246 * which don't need their own reference any more must call bdrv_unref().
1247 */
Fam Zheng8d24cce2014-05-23 21:29:45 +08001248void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1249{
Kevin Wolf5db15a52015-09-14 15:33:33 +02001250 if (backing_hd) {
1251 bdrv_ref(backing_hd);
1252 }
Fam Zheng8d24cce2014-05-23 21:29:45 +08001253
Kevin Wolf760e0062015-06-17 14:55:21 +02001254 if (bs->backing) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001255 assert(bs->backing_blocker);
Kevin Wolf760e0062015-06-17 14:55:21 +02001256 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
Kevin Wolf5db15a52015-09-14 15:33:33 +02001257 bdrv_unref_child(bs, bs->backing);
Fam Zheng826b6ca2014-05-23 21:29:47 +08001258 } else if (backing_hd) {
1259 error_setg(&bs->backing_blocker,
Alberto Garcia81e5f782015-04-08 12:29:19 +03001260 "node is used as backing hd of '%s'",
1261 bdrv_get_device_or_node_name(bs));
Fam Zheng826b6ca2014-05-23 21:29:47 +08001262 }
1263
Fam Zheng8d24cce2014-05-23 21:29:45 +08001264 if (!backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001265 error_free(bs->backing_blocker);
1266 bs->backing_blocker = NULL;
Kevin Wolf760e0062015-06-17 14:55:21 +02001267 bs->backing = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001268 goto out;
1269 }
Kevin Wolf260fecf2015-04-27 13:46:22 +02001270 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001271 bs->open_flags &= ~BDRV_O_NO_BACKING;
1272 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1273 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1274 backing_hd->drv ? backing_hd->drv->format_name : "");
Fam Zheng826b6ca2014-05-23 21:29:47 +08001275
Kevin Wolf760e0062015-06-17 14:55:21 +02001276 bdrv_op_block_all(backing_hd, bs->backing_blocker);
Fam Zheng826b6ca2014-05-23 21:29:47 +08001277 /* Otherwise we won't be able to commit due to check in bdrv_commit */
Kevin Wolf760e0062015-06-17 14:55:21 +02001278 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
Fam Zheng826b6ca2014-05-23 21:29:47 +08001279 bs->backing_blocker);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001280out:
Kevin Wolf3baca892014-07-16 17:48:16 +02001281 bdrv_refresh_limits(bs, NULL);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001282}
1283
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001284/*
1285 * Opens the backing file for a BlockDriverState if not yet open
1286 *
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001287 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1288 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1289 * itself, all options starting with "${bdref_key}." are considered part of the
1290 * BlockdevRef.
1291 *
1292 * TODO Can this be unified with bdrv_open_image()?
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001293 */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001294int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
1295 const char *bdref_key, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02001296{
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001297 char *backing_filename = g_malloc0(PATH_MAX);
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001298 char *bdref_key_dot;
1299 const char *reference = NULL;
Kevin Wolf317fc442014-04-25 13:27:34 +02001300 int ret = 0;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001301 BlockDriverState *backing_hd;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001302 QDict *options;
1303 QDict *tmp_parent_options = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001304 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001305
Kevin Wolf760e0062015-06-17 14:55:21 +02001306 if (bs->backing != NULL) {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001307 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001308 }
1309
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001310 /* NULL means an empty set of options */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001311 if (parent_options == NULL) {
1312 tmp_parent_options = qdict_new();
1313 parent_options = tmp_parent_options;
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001314 }
1315
Paolo Bonzini9156df12012-10-18 16:49:17 +02001316 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001317
1318 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1319 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
1320 g_free(bdref_key_dot);
1321
1322 reference = qdict_get_try_str(parent_options, bdref_key);
1323 if (reference || qdict_haskey(options, "file.filename")) {
Kevin Wolf1cb6f502013-04-12 20:27:07 +02001324 backing_filename[0] = '\0';
1325 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001326 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001327 goto free_exit;
Fam Zhengdbecebd2013-09-22 20:05:06 +08001328 } else {
Max Reitz9f074292014-11-26 17:20:26 +01001329 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1330 &local_err);
1331 if (local_err) {
1332 ret = -EINVAL;
1333 error_propagate(errp, local_err);
1334 QDECREF(options);
1335 goto free_exit;
1336 }
Paolo Bonzini9156df12012-10-18 16:49:17 +02001337 }
1338
Kevin Wolf8ee79e72014-06-04 15:09:35 +02001339 if (!bs->drv || !bs->drv->supports_backing) {
1340 ret = -EINVAL;
1341 error_setg(errp, "Driver doesn't support backing files");
1342 QDECREF(options);
1343 goto free_exit;
1344 }
1345
Kevin Wolfc5f6e492014-11-25 18:12:42 +01001346 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1347 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
Paolo Bonzini9156df12012-10-18 16:49:17 +02001348 }
1349
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001350 backing_hd = NULL;
Kevin Wolff3930ed2015-04-08 13:43:47 +02001351 ret = bdrv_open_inherit(&backing_hd,
1352 *backing_filename ? backing_filename : NULL,
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001353 reference, options, 0, bs, &child_backing,
Markus Armbrustere43bfd92015-12-18 16:35:15 +01001354 errp);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001355 if (ret < 0) {
Paolo Bonzini9156df12012-10-18 16:49:17 +02001356 bs->open_flags |= BDRV_O_NO_BACKING;
Markus Armbrustere43bfd92015-12-18 16:35:15 +01001357 error_prepend(errp, "Could not open backing file: ");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001358 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001359 }
Kevin Wolfdf581792015-06-15 11:53:47 +02001360
Kevin Wolf5db15a52015-09-14 15:33:33 +02001361 /* Hook up the backing file link; drop our reference, bs owns the
1362 * backing_hd reference now */
Fam Zheng8d24cce2014-05-23 21:29:45 +08001363 bdrv_set_backing_hd(bs, backing_hd);
Kevin Wolf5db15a52015-09-14 15:33:33 +02001364 bdrv_unref(backing_hd);
Peter Feinerd80ac652014-01-08 19:43:25 +00001365
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001366 qdict_del(parent_options, bdref_key);
1367
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001368free_exit:
1369 g_free(backing_filename);
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001370 QDECREF(tmp_parent_options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001371 return ret;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001372}
1373
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001374/*
Max Reitzda557aa2013-12-20 19:28:11 +01001375 * Opens a disk image whose options are given as BlockdevRef in another block
1376 * device's options.
1377 *
Max Reitzda557aa2013-12-20 19:28:11 +01001378 * If allow_none is true, no image will be opened if filename is false and no
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001379 * BlockdevRef is given. NULL will be returned, but errp remains unset.
Max Reitzda557aa2013-12-20 19:28:11 +01001380 *
1381 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1382 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1383 * itself, all options starting with "${bdref_key}." are considered part of the
1384 * BlockdevRef.
1385 *
1386 * The BlockdevRef will be removed from the options QDict.
1387 */
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001388BdrvChild *bdrv_open_child(const char *filename,
1389 QDict *options, const char *bdref_key,
1390 BlockDriverState* parent,
1391 const BdrvChildRole *child_role,
1392 bool allow_none, Error **errp)
Max Reitzda557aa2013-12-20 19:28:11 +01001393{
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001394 BdrvChild *c = NULL;
1395 BlockDriverState *bs;
Max Reitzda557aa2013-12-20 19:28:11 +01001396 QDict *image_options;
1397 int ret;
1398 char *bdref_key_dot;
1399 const char *reference;
1400
Kevin Wolfdf581792015-06-15 11:53:47 +02001401 assert(child_role != NULL);
Max Reitzf67503e2014-02-18 18:33:05 +01001402
Max Reitzda557aa2013-12-20 19:28:11 +01001403 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1404 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1405 g_free(bdref_key_dot);
1406
1407 reference = qdict_get_try_str(options, bdref_key);
1408 if (!filename && !reference && !qdict_size(image_options)) {
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001409 if (!allow_none) {
Max Reitzda557aa2013-12-20 19:28:11 +01001410 error_setg(errp, "A block device must be specified for \"%s\"",
1411 bdref_key);
Max Reitzda557aa2013-12-20 19:28:11 +01001412 }
Markus Armbrusterb20e61e2014-05-28 11:16:57 +02001413 QDECREF(image_options);
Max Reitzda557aa2013-12-20 19:28:11 +01001414 goto done;
1415 }
1416
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001417 bs = NULL;
1418 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
Max Reitzce343772015-08-26 19:47:50 +02001419 parent, child_role, errp);
Kevin Wolfdf581792015-06-15 11:53:47 +02001420 if (ret < 0) {
1421 goto done;
1422 }
1423
Kevin Wolf260fecf2015-04-27 13:46:22 +02001424 c = bdrv_attach_child(parent, bs, bdref_key, child_role);
Max Reitzda557aa2013-12-20 19:28:11 +01001425
1426done:
1427 qdict_del(options, bdref_key);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001428 return c;
1429}
1430
Chen Gang6b8aeca2014-06-23 23:28:23 +08001431int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
Kevin Wolfb9988752014-04-03 12:09:34 +02001432{
1433 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001434 char *tmp_filename = g_malloc0(PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001435 int64_t total_size;
Chunyan Liu83d05212014-06-05 17:20:51 +08001436 QemuOpts *opts = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001437 QDict *snapshot_options;
1438 BlockDriverState *bs_snapshot;
Fam Zhengc2e0dbb2015-07-06 12:24:44 +08001439 Error *local_err = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001440 int ret;
1441
1442 /* if snapshot, we create a temporary backing file and open it
1443 instead of opening 'filename' directly */
1444
1445 /* Get the required size from the image */
Kevin Wolff1877432014-04-04 17:07:19 +02001446 total_size = bdrv_getlength(bs);
1447 if (total_size < 0) {
Chen Gang6b8aeca2014-06-23 23:28:23 +08001448 ret = total_size;
Kevin Wolff1877432014-04-04 17:07:19 +02001449 error_setg_errno(errp, -total_size, "Could not get image size");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001450 goto out;
Kevin Wolff1877432014-04-04 17:07:19 +02001451 }
Kevin Wolfb9988752014-04-03 12:09:34 +02001452
1453 /* Create the temporary image */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001454 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001455 if (ret < 0) {
1456 error_setg_errno(errp, -ret, "Could not get temporary filename");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001457 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001458 }
1459
Max Reitzef810432014-12-02 18:32:42 +01001460 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001461 &error_abort);
Markus Armbruster39101f22015-02-12 16:46:36 +01001462 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
Markus Armbrustere43bfd92015-12-18 16:35:15 +01001463 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
Chunyan Liu83d05212014-06-05 17:20:51 +08001464 qemu_opts_del(opts);
Kevin Wolfb9988752014-04-03 12:09:34 +02001465 if (ret < 0) {
Markus Armbrustere43bfd92015-12-18 16:35:15 +01001466 error_prepend(errp, "Could not create temporary overlay '%s': ",
1467 tmp_filename);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001468 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001469 }
1470
1471 /* Prepare a new options QDict for the temporary file */
1472 snapshot_options = qdict_new();
1473 qdict_put(snapshot_options, "file.driver",
1474 qstring_from_str("file"));
1475 qdict_put(snapshot_options, "file.filename",
1476 qstring_from_str(tmp_filename));
Max Reitze6641712015-08-26 19:47:48 +02001477 qdict_put(snapshot_options, "driver",
1478 qstring_from_str("qcow2"));
Kevin Wolfb9988752014-04-03 12:09:34 +02001479
Markus Armbrustere4e99862014-10-07 13:59:03 +02001480 bs_snapshot = bdrv_new();
Kevin Wolfb9988752014-04-03 12:09:34 +02001481
1482 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
Max Reitz6ebf9aa2015-08-26 19:47:49 +02001483 flags, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001484 if (ret < 0) {
1485 error_propagate(errp, local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001486 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001487 }
1488
1489 bdrv_append(bs_snapshot, bs);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001490
1491out:
1492 g_free(tmp_filename);
Chen Gang6b8aeca2014-06-23 23:28:23 +08001493 return ret;
Kevin Wolfb9988752014-04-03 12:09:34 +02001494}
1495
Max Reitzda557aa2013-12-20 19:28:11 +01001496/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001497 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001498 *
1499 * options is a QDict of options to pass to the block drivers, or NULL for an
1500 * empty set of options. The reference to the QDict belongs to the block layer
1501 * after the call (even on failure), so if the caller intends to reuse the
1502 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Max Reitzf67503e2014-02-18 18:33:05 +01001503 *
1504 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1505 * If it is not NULL, the referenced BDS will be reused.
Max Reitzddf56362014-02-18 18:33:06 +01001506 *
1507 * The reference parameter may be used to specify an existing block device which
1508 * should be opened. If specified, neither options nor a filename may be given,
1509 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001510 */
Kevin Wolff3930ed2015-04-08 13:43:47 +02001511static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1512 const char *reference, QDict *options, int flags,
1513 BlockDriverState *parent,
Max Reitzce343772015-08-26 19:47:50 +02001514 const BdrvChildRole *child_role, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001515{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001516 int ret;
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001517 BdrvChild *file = NULL;
1518 BlockDriverState *bs;
Max Reitzce343772015-08-26 19:47:50 +02001519 BlockDriver *drv = NULL;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001520 const char *drvname;
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02001521 const char *backing;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001522 Error *local_err = NULL;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001523 int snapshot_flags = 0;
bellard712e7872005-04-28 21:09:32 +00001524
Max Reitzf67503e2014-02-18 18:33:05 +01001525 assert(pbs);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001526 assert(!child_role || !flags);
1527 assert(!child_role == !parent);
Max Reitzf67503e2014-02-18 18:33:05 +01001528
Max Reitzddf56362014-02-18 18:33:06 +01001529 if (reference) {
1530 bool options_non_empty = options ? qdict_size(options) : false;
1531 QDECREF(options);
1532
1533 if (*pbs) {
1534 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1535 "another block device");
1536 return -EINVAL;
1537 }
1538
1539 if (filename || options_non_empty) {
1540 error_setg(errp, "Cannot reference an existing block device with "
1541 "additional options or a new filename");
1542 return -EINVAL;
1543 }
1544
1545 bs = bdrv_lookup_bs(reference, reference, errp);
1546 if (!bs) {
1547 return -ENODEV;
1548 }
1549 bdrv_ref(bs);
1550 *pbs = bs;
1551 return 0;
1552 }
1553
Max Reitzf67503e2014-02-18 18:33:05 +01001554 if (*pbs) {
1555 bs = *pbs;
1556 } else {
Markus Armbrustere4e99862014-10-07 13:59:03 +02001557 bs = bdrv_new();
Max Reitzf67503e2014-02-18 18:33:05 +01001558 }
1559
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001560 /* NULL means an empty set of options */
1561 if (options == NULL) {
1562 options = qdict_new();
1563 }
1564
Kevin Wolf145f5982015-05-08 16:15:03 +02001565 /* json: syntax counts as explicit options, as if in the QDict */
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001566 parse_json_protocol(options, &filename, &local_err);
1567 if (local_err) {
1568 ret = -EINVAL;
1569 goto fail;
1570 }
1571
Kevin Wolf145f5982015-05-08 16:15:03 +02001572 bs->explicit_options = qdict_clone_shallow(options);
1573
Kevin Wolff3930ed2015-04-08 13:43:47 +02001574 if (child_role) {
Kevin Wolfbddcec32015-04-09 18:47:50 +02001575 bs->inherits_from = parent;
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001576 child_role->inherit_options(&flags, options,
1577 parent->open_flags, parent->options);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001578 }
1579
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001580 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
Kevin Wolf462f5bc2014-05-26 11:39:55 +02001581 if (local_err) {
1582 goto fail;
1583 }
1584
Kevin Wolf62392eb2015-04-24 16:38:02 +02001585 bs->open_flags = flags;
1586 bs->options = options;
1587 options = qdict_clone_shallow(options);
1588
Kevin Wolf76c591b2014-06-04 14:19:44 +02001589 /* Find the right image format driver */
Kevin Wolf76c591b2014-06-04 14:19:44 +02001590 drvname = qdict_get_try_str(options, "driver");
1591 if (drvname) {
1592 drv = bdrv_find_format(drvname);
Kevin Wolf76c591b2014-06-04 14:19:44 +02001593 if (!drv) {
1594 error_setg(errp, "Unknown driver: '%s'", drvname);
1595 ret = -EINVAL;
1596 goto fail;
1597 }
1598 }
1599
1600 assert(drvname || !(flags & BDRV_O_PROTOCOL));
Kevin Wolf76c591b2014-06-04 14:19:44 +02001601
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02001602 backing = qdict_get_try_str(options, "backing");
1603 if (backing && *backing == '\0') {
1604 flags |= BDRV_O_NO_BACKING;
1605 qdict_del(options, "backing");
1606 }
1607
Kevin Wolff4788ad2014-06-03 16:44:19 +02001608 /* Open image file without format layer */
1609 if ((flags & BDRV_O_PROTOCOL) == 0) {
1610 if (flags & BDRV_O_RDWR) {
1611 flags |= BDRV_O_ALLOW_RDWR;
1612 }
1613 if (flags & BDRV_O_SNAPSHOT) {
1614 snapshot_flags = bdrv_temp_snapshot_flags(flags);
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001615 bdrv_backing_options(&flags, options, flags, options);
Kevin Wolff4788ad2014-06-03 16:44:19 +02001616 }
1617
Kevin Wolff3930ed2015-04-08 13:43:47 +02001618 bs->open_flags = flags;
Kevin Wolf1fdd6932015-06-15 14:11:51 +02001619
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001620 file = bdrv_open_child(filename, options, "file", bs,
1621 &child_file, true, &local_err);
Kevin Wolf1fdd6932015-06-15 14:11:51 +02001622 if (local_err) {
1623 ret = -EINVAL;
Max Reitz5469a2a2014-02-18 18:33:10 +01001624 goto fail;
1625 }
1626 }
1627
Kevin Wolf76c591b2014-06-04 14:19:44 +02001628 /* Image format probing */
Kevin Wolf38f3ef52014-11-20 16:27:12 +01001629 bs->probed = !drv;
Kevin Wolf76c591b2014-06-04 14:19:44 +02001630 if (!drv && file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001631 ret = find_image_format(file->bs, filename, &drv, &local_err);
Kevin Wolf17b005f2014-05-27 10:50:29 +02001632 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001633 goto fail;
Max Reitz2a05cbe2013-12-20 19:28:10 +01001634 }
Kevin Wolf62392eb2015-04-24 16:38:02 +02001635 /*
1636 * This option update would logically belong in bdrv_fill_options(),
1637 * but we first need to open bs->file for the probing to work, while
1638 * opening bs->file already requires the (mostly) final set of options
1639 * so that cache mode etc. can be inherited.
1640 *
1641 * Adding the driver later is somewhat ugly, but it's not an option
1642 * that would ever be inherited, so it's correct. We just need to make
1643 * sure to update both bs->options (which has the full effective
1644 * options for bs) and options (which has file.* already removed).
1645 */
1646 qdict_put(bs->options, "driver", qstring_from_str(drv->format_name));
1647 qdict_put(options, "driver", qstring_from_str(drv->format_name));
Kevin Wolf76c591b2014-06-04 14:19:44 +02001648 } else if (!drv) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02001649 error_setg(errp, "Must specify either driver or file");
1650 ret = -EINVAL;
Kevin Wolf8bfea152014-04-11 19:16:36 +02001651 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001652 }
1653
Max Reitz53a29512015-03-19 14:53:16 -04001654 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1655 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1656 /* file must be NULL if a protocol BDS is about to be created
1657 * (the inverse results in an error message from bdrv_open_common()) */
1658 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1659
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001660 /* Open the image */
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001661 ret = bdrv_open_common(bs, file, options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001662 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001663 goto fail;
Christoph Hellwig69873072010-01-20 18:13:25 +01001664 }
1665
Max Reitz2a05cbe2013-12-20 19:28:10 +01001666 if (file && (bs->file != file)) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001667 bdrv_unref_child(bs, file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001668 file = NULL;
1669 }
1670
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001671 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001672 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001673 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001674 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001675 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001676 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001677 }
1678
Max Reitz91af7012014-07-18 20:24:56 +02001679 bdrv_refresh_filename(bs);
1680
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001681 /* Check if any unknown options were used */
Max Reitz5acd9d82014-02-18 18:33:11 +01001682 if (options && (qdict_size(options) != 0)) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001683 const QDictEntry *entry = qdict_first(options);
Max Reitz5acd9d82014-02-18 18:33:11 +01001684 if (flags & BDRV_O_PROTOCOL) {
1685 error_setg(errp, "Block protocol '%s' doesn't support the option "
1686 "'%s'", drv->format_name, entry->key);
1687 } else {
1688 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1689 "support the option '%s'", drv->format_name,
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02001690 bdrv_get_device_name(bs), entry->key);
Max Reitz5acd9d82014-02-18 18:33:11 +01001691 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001692
1693 ret = -EINVAL;
1694 goto close_and_fail;
1695 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001696
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001697 if (!bdrv_key_required(bs)) {
Markus Armbrustera7f53e22014-10-07 13:59:25 +02001698 if (bs->blk) {
1699 blk_dev_change_media_cb(bs->blk, true);
1700 }
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001701 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1702 && !runstate_check(RUN_STATE_INMIGRATE)
1703 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1704 error_setg(errp,
1705 "Guest must be stopped for opening of encrypted image");
1706 ret = -EBUSY;
1707 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001708 }
1709
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001710 QDECREF(options);
Max Reitzf67503e2014-02-18 18:33:05 +01001711 *pbs = bs;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02001712
1713 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1714 * temporary snapshot afterwards. */
1715 if (snapshot_flags) {
1716 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1717 if (local_err) {
1718 goto close_and_fail;
1719 }
1720 }
1721
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001722 return 0;
1723
Kevin Wolf8bfea152014-04-11 19:16:36 +02001724fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001725 if (file != NULL) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001726 bdrv_unref_child(bs, file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001727 }
Kevin Wolf145f5982015-05-08 16:15:03 +02001728 QDECREF(bs->explicit_options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001729 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001730 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001731 bs->options = NULL;
Max Reitzf67503e2014-02-18 18:33:05 +01001732 if (!*pbs) {
1733 /* If *pbs is NULL, a new BDS has been created in this function and
1734 needs to be freed now. Otherwise, it does not need to be closed,
1735 since it has not really been opened yet. */
1736 bdrv_unref(bs);
1737 }
Markus Armbruster84d18f02014-01-30 15:07:28 +01001738 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001739 error_propagate(errp, local_err);
1740 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001741 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001742
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001743close_and_fail:
Max Reitzf67503e2014-02-18 18:33:05 +01001744 /* See fail path, but now the BDS has to be always closed */
1745 if (*pbs) {
1746 bdrv_close(bs);
1747 } else {
1748 bdrv_unref(bs);
1749 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001750 QDECREF(options);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001751 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001752 error_propagate(errp, local_err);
1753 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001754 return ret;
1755}
1756
Kevin Wolff3930ed2015-04-08 13:43:47 +02001757int bdrv_open(BlockDriverState **pbs, const char *filename,
Max Reitz6ebf9aa2015-08-26 19:47:49 +02001758 const char *reference, QDict *options, int flags, Error **errp)
Kevin Wolff3930ed2015-04-08 13:43:47 +02001759{
1760 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
Max Reitzce343772015-08-26 19:47:50 +02001761 NULL, errp);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001762}
1763
Jeff Codye971aa12012-09-20 15:13:19 -04001764typedef struct BlockReopenQueueEntry {
1765 bool prepared;
1766 BDRVReopenState state;
1767 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1768} BlockReopenQueueEntry;
1769
1770/*
1771 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1772 * reopen of multiple devices.
1773 *
1774 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1775 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1776 * be created and initialized. This newly created BlockReopenQueue should be
1777 * passed back in for subsequent calls that are intended to be of the same
1778 * atomic 'set'.
1779 *
1780 * bs is the BlockDriverState to add to the reopen queue.
1781 *
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001782 * options contains the changed options for the associated bs
1783 * (the BlockReopenQueue takes ownership)
1784 *
Jeff Codye971aa12012-09-20 15:13:19 -04001785 * flags contains the open flags for the associated bs
1786 *
1787 * returns a pointer to bs_queue, which is either the newly allocated
1788 * bs_queue, or the existing bs_queue being used.
1789 *
1790 */
Kevin Wolf28518102015-05-08 17:07:31 +02001791static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
1792 BlockDriverState *bs,
1793 QDict *options,
1794 int flags,
1795 const BdrvChildRole *role,
1796 QDict *parent_options,
1797 int parent_flags)
Jeff Codye971aa12012-09-20 15:13:19 -04001798{
1799 assert(bs != NULL);
1800
1801 BlockReopenQueueEntry *bs_entry;
Kevin Wolf67251a32015-04-09 18:54:04 +02001802 BdrvChild *child;
Kevin Wolf145f5982015-05-08 16:15:03 +02001803 QDict *old_options, *explicit_options;
Kevin Wolf67251a32015-04-09 18:54:04 +02001804
Jeff Codye971aa12012-09-20 15:13:19 -04001805 if (bs_queue == NULL) {
1806 bs_queue = g_new0(BlockReopenQueue, 1);
1807 QSIMPLEQ_INIT(bs_queue);
1808 }
1809
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001810 if (!options) {
1811 options = qdict_new();
1812 }
1813
Kevin Wolf28518102015-05-08 17:07:31 +02001814 /*
1815 * Precedence of options:
1816 * 1. Explicitly passed in options (highest)
Kevin Wolf91a097e2015-05-08 17:49:53 +02001817 * 2. Set in flags (only for top level)
Kevin Wolf145f5982015-05-08 16:15:03 +02001818 * 3. Retained from explicitly set options of bs
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001819 * 4. Inherited from parent node
Kevin Wolf28518102015-05-08 17:07:31 +02001820 * 5. Retained from effective options of bs
1821 */
1822
Kevin Wolf91a097e2015-05-08 17:49:53 +02001823 if (!parent_options) {
1824 /*
1825 * Any setting represented by flags is always updated. If the
1826 * corresponding QDict option is set, it takes precedence. Otherwise
1827 * the flag is translated into a QDict option. The old setting of bs is
1828 * not considered.
1829 */
1830 update_options_from_flags(options, flags);
1831 }
1832
Kevin Wolf145f5982015-05-08 16:15:03 +02001833 /* Old explicitly set values (don't overwrite by inherited value) */
1834 old_options = qdict_clone_shallow(bs->explicit_options);
1835 bdrv_join_options(bs, options, old_options);
1836 QDECREF(old_options);
1837
1838 explicit_options = qdict_clone_shallow(options);
1839
Kevin Wolf28518102015-05-08 17:07:31 +02001840 /* Inherit from parent node */
1841 if (parent_options) {
1842 assert(!flags);
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001843 role->inherit_options(&flags, options, parent_flags, parent_options);
Kevin Wolf28518102015-05-08 17:07:31 +02001844 }
1845
1846 /* Old values are used for options that aren't set yet */
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001847 old_options = qdict_clone_shallow(bs->options);
Kevin Wolfcddff5b2015-11-16 16:43:27 +01001848 bdrv_join_options(bs, options, old_options);
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001849 QDECREF(old_options);
1850
Kevin Wolff1f25a22014-04-25 19:04:55 +02001851 /* bdrv_open() masks this flag out */
1852 flags &= ~BDRV_O_PROTOCOL;
1853
Kevin Wolf67251a32015-04-09 18:54:04 +02001854 QLIST_FOREACH(child, &bs->children, next) {
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02001855 QDict *new_child_options;
1856 char *child_key_dot;
Kevin Wolf67251a32015-04-09 18:54:04 +02001857
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02001858 /* reopen can only change the options of block devices that were
1859 * implicitly created and inherited options. For other (referenced)
1860 * block devices, a syntax like "backing.foo" results in an error. */
Kevin Wolf67251a32015-04-09 18:54:04 +02001861 if (child->bs->inherits_from != bs) {
1862 continue;
1863 }
1864
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02001865 child_key_dot = g_strdup_printf("%s.", child->name);
1866 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
1867 g_free(child_key_dot);
1868
Kevin Wolf28518102015-05-08 17:07:31 +02001869 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
1870 child->role, options, flags);
Jeff Codye971aa12012-09-20 15:13:19 -04001871 }
1872
1873 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1874 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1875
1876 bs_entry->state.bs = bs;
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001877 bs_entry->state.options = options;
Kevin Wolf145f5982015-05-08 16:15:03 +02001878 bs_entry->state.explicit_options = explicit_options;
Jeff Codye971aa12012-09-20 15:13:19 -04001879 bs_entry->state.flags = flags;
1880
1881 return bs_queue;
1882}
1883
Kevin Wolf28518102015-05-08 17:07:31 +02001884BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1885 BlockDriverState *bs,
1886 QDict *options, int flags)
1887{
1888 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
1889 NULL, NULL, 0);
1890}
1891
Jeff Codye971aa12012-09-20 15:13:19 -04001892/*
1893 * Reopen multiple BlockDriverStates atomically & transactionally.
1894 *
1895 * The queue passed in (bs_queue) must have been built up previous
1896 * via bdrv_reopen_queue().
1897 *
1898 * Reopens all BDS specified in the queue, with the appropriate
1899 * flags. All devices are prepared for reopen, and failure of any
1900 * device will cause all device changes to be abandonded, and intermediate
1901 * data cleaned up.
1902 *
1903 * If all devices prepare successfully, then the changes are committed
1904 * to all devices.
1905 *
1906 */
1907int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1908{
1909 int ret = -1;
1910 BlockReopenQueueEntry *bs_entry, *next;
1911 Error *local_err = NULL;
1912
1913 assert(bs_queue != NULL);
1914
1915 bdrv_drain_all();
1916
1917 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1918 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1919 error_propagate(errp, local_err);
1920 goto cleanup;
1921 }
1922 bs_entry->prepared = true;
1923 }
1924
1925 /* If we reach this point, we have success and just need to apply the
1926 * changes
1927 */
1928 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1929 bdrv_reopen_commit(&bs_entry->state);
1930 }
1931
1932 ret = 0;
1933
1934cleanup:
1935 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1936 if (ret && bs_entry->prepared) {
1937 bdrv_reopen_abort(&bs_entry->state);
Kevin Wolf145f5982015-05-08 16:15:03 +02001938 } else if (ret) {
1939 QDECREF(bs_entry->state.explicit_options);
Jeff Codye971aa12012-09-20 15:13:19 -04001940 }
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001941 QDECREF(bs_entry->state.options);
Jeff Codye971aa12012-09-20 15:13:19 -04001942 g_free(bs_entry);
1943 }
1944 g_free(bs_queue);
1945 return ret;
1946}
1947
1948
1949/* Reopen a single BlockDriverState with the specified flags. */
1950int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1951{
1952 int ret = -1;
1953 Error *local_err = NULL;
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001954 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
Jeff Codye971aa12012-09-20 15:13:19 -04001955
1956 ret = bdrv_reopen_multiple(queue, &local_err);
1957 if (local_err != NULL) {
1958 error_propagate(errp, local_err);
1959 }
1960 return ret;
1961}
1962
1963
1964/*
1965 * Prepares a BlockDriverState for reopen. All changes are staged in the
1966 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1967 * the block driver layer .bdrv_reopen_prepare()
1968 *
1969 * bs is the BlockDriverState to reopen
1970 * flags are the new open flags
1971 * queue is the reopen queue
1972 *
1973 * Returns 0 on success, non-zero on error. On error errp will be set
1974 * as well.
1975 *
1976 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1977 * It is the responsibility of the caller to then call the abort() or
1978 * commit() for any other BDS that have been left in a prepare() state
1979 *
1980 */
1981int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1982 Error **errp)
1983{
1984 int ret = -1;
1985 Error *local_err = NULL;
1986 BlockDriver *drv;
Kevin Wolfccf9dc02015-05-08 17:24:56 +02001987 QemuOpts *opts;
1988 const char *value;
Jeff Codye971aa12012-09-20 15:13:19 -04001989
1990 assert(reopen_state != NULL);
1991 assert(reopen_state->bs->drv != NULL);
1992 drv = reopen_state->bs->drv;
1993
Kevin Wolfccf9dc02015-05-08 17:24:56 +02001994 /* Process generic block layer options */
1995 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1996 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
1997 if (local_err) {
1998 error_propagate(errp, local_err);
1999 ret = -EINVAL;
2000 goto error;
2001 }
2002
Kevin Wolf91a097e2015-05-08 17:49:53 +02002003 update_flags_from_options(&reopen_state->flags, opts);
2004
2005 /* If a guest device is attached, it owns WCE */
2006 if (reopen_state->bs->blk && blk_get_attached_dev(reopen_state->bs->blk)) {
2007 bool old_wce = bdrv_enable_write_cache(reopen_state->bs);
2008 bool new_wce = (reopen_state->flags & BDRV_O_CACHE_WB);
2009 if (old_wce != new_wce) {
2010 error_setg(errp, "Cannot change cache.writeback: Device attached");
2011 ret = -EINVAL;
2012 goto error;
2013 }
2014 }
2015
Kevin Wolfccf9dc02015-05-08 17:24:56 +02002016 /* node-name and driver must be unchanged. Put them back into the QDict, so
2017 * that they are checked at the end of this function. */
2018 value = qemu_opt_get(opts, "node-name");
2019 if (value) {
2020 qdict_put(reopen_state->options, "node-name", qstring_from_str(value));
2021 }
2022
2023 value = qemu_opt_get(opts, "driver");
2024 if (value) {
2025 qdict_put(reopen_state->options, "driver", qstring_from_str(value));
2026 }
2027
Jeff Codye971aa12012-09-20 15:13:19 -04002028 /* if we are to stay read-only, do not allow permission change
2029 * to r/w */
2030 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
2031 reopen_state->flags & BDRV_O_RDWR) {
Alberto Garcia81e5f782015-04-08 12:29:19 +03002032 error_setg(errp, "Node '%s' is read only",
2033 bdrv_get_device_or_node_name(reopen_state->bs));
Jeff Codye971aa12012-09-20 15:13:19 -04002034 goto error;
2035 }
2036
2037
2038 ret = bdrv_flush(reopen_state->bs);
2039 if (ret) {
Eric Blake455b0fd2015-11-10 23:51:20 -07002040 error_setg_errno(errp, -ret, "Error flushing drive");
Jeff Codye971aa12012-09-20 15:13:19 -04002041 goto error;
2042 }
2043
2044 if (drv->bdrv_reopen_prepare) {
2045 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
2046 if (ret) {
2047 if (local_err != NULL) {
2048 error_propagate(errp, local_err);
2049 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04002050 error_setg(errp, "failed while preparing to reopen image '%s'",
2051 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04002052 }
2053 goto error;
2054 }
2055 } else {
2056 /* It is currently mandatory to have a bdrv_reopen_prepare()
2057 * handler for each supported drv. */
Alberto Garcia81e5f782015-04-08 12:29:19 +03002058 error_setg(errp, "Block format '%s' used by node '%s' "
2059 "does not support reopening files", drv->format_name,
2060 bdrv_get_device_or_node_name(reopen_state->bs));
Jeff Codye971aa12012-09-20 15:13:19 -04002061 ret = -1;
2062 goto error;
2063 }
2064
Kevin Wolf4d2cb092015-04-10 17:50:50 +02002065 /* Options that are not handled are only okay if they are unchanged
2066 * compared to the old state. It is expected that some options are only
2067 * used for the initial open, but not reopen (e.g. filename) */
2068 if (qdict_size(reopen_state->options)) {
2069 const QDictEntry *entry = qdict_first(reopen_state->options);
2070
2071 do {
2072 QString *new_obj = qobject_to_qstring(entry->value);
2073 const char *new = qstring_get_str(new_obj);
2074 const char *old = qdict_get_try_str(reopen_state->bs->options,
2075 entry->key);
2076
2077 if (!old || strcmp(new, old)) {
2078 error_setg(errp, "Cannot change the option '%s'", entry->key);
2079 ret = -EINVAL;
2080 goto error;
2081 }
2082 } while ((entry = qdict_next(reopen_state->options, entry)));
2083 }
2084
Jeff Codye971aa12012-09-20 15:13:19 -04002085 ret = 0;
2086
2087error:
Kevin Wolfccf9dc02015-05-08 17:24:56 +02002088 qemu_opts_del(opts);
Jeff Codye971aa12012-09-20 15:13:19 -04002089 return ret;
2090}
2091
2092/*
2093 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2094 * makes them final by swapping the staging BlockDriverState contents into
2095 * the active BlockDriverState contents.
2096 */
2097void bdrv_reopen_commit(BDRVReopenState *reopen_state)
2098{
2099 BlockDriver *drv;
2100
2101 assert(reopen_state != NULL);
2102 drv = reopen_state->bs->drv;
2103 assert(drv != NULL);
2104
2105 /* If there are any driver level actions to take */
2106 if (drv->bdrv_reopen_commit) {
2107 drv->bdrv_reopen_commit(reopen_state);
2108 }
2109
2110 /* set BDS specific flags now */
Kevin Wolf145f5982015-05-08 16:15:03 +02002111 QDECREF(reopen_state->bs->explicit_options);
2112
2113 reopen_state->bs->explicit_options = reopen_state->explicit_options;
Jeff Codye971aa12012-09-20 15:13:19 -04002114 reopen_state->bs->open_flags = reopen_state->flags;
2115 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
2116 BDRV_O_CACHE_WB);
2117 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf355ef4a2013-12-11 20:14:09 +01002118
Kevin Wolf3baca892014-07-16 17:48:16 +02002119 bdrv_refresh_limits(reopen_state->bs, NULL);
Jeff Codye971aa12012-09-20 15:13:19 -04002120}
2121
2122/*
2123 * Abort the reopen, and delete and free the staged changes in
2124 * reopen_state
2125 */
2126void bdrv_reopen_abort(BDRVReopenState *reopen_state)
2127{
2128 BlockDriver *drv;
2129
2130 assert(reopen_state != NULL);
2131 drv = reopen_state->bs->drv;
2132 assert(drv != NULL);
2133
2134 if (drv->bdrv_reopen_abort) {
2135 drv->bdrv_reopen_abort(reopen_state);
2136 }
Kevin Wolf145f5982015-05-08 16:15:03 +02002137
2138 QDECREF(reopen_state->explicit_options);
Jeff Codye971aa12012-09-20 15:13:19 -04002139}
2140
2141
Max Reitz64dff522016-01-29 16:36:10 +01002142static void bdrv_close(BlockDriverState *bs)
bellardfc01f7e2003-06-30 10:03:06 +00002143{
Max Reitz33384422014-06-20 21:57:33 +02002144 BdrvAioNotifier *ban, *ban_next;
2145
Max Reitzca9bd242016-01-29 16:36:14 +01002146 assert(!bs->job);
Alberto Garcia99b7e772015-09-25 16:41:44 +03002147
2148 /* Disable I/O limits and drain all pending throttled requests */
Alberto Garciaa0d64a62015-11-04 15:15:36 +02002149 if (bs->throttle_state) {
Alberto Garcia99b7e772015-09-25 16:41:44 +03002150 bdrv_io_limits_disable(bs);
2151 }
2152
Paolo Bonzinifc272912015-12-23 11:48:24 +01002153 bdrv_drained_begin(bs); /* complete I/O */
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02002154 bdrv_flush(bs);
Fam Zheng53ec73e2015-05-29 18:53:14 +08002155 bdrv_drain(bs); /* in case flush left pending I/O */
Paolo Bonzinifc272912015-12-23 11:48:24 +01002156
Max Reitzc5acdc92016-01-29 16:36:01 +01002157 bdrv_release_named_dirty_bitmaps(bs);
2158 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2159
Max Reitzb4d02822015-10-19 17:53:15 +02002160 if (bs->blk) {
2161 blk_dev_change_media_cb(bs->blk, false);
2162 }
2163
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02002164 if (bs->drv) {
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02002165 BdrvChild *child, *next;
2166
Kevin Wolf9a7dedb2015-06-16 10:58:20 +02002167 bs->drv->bdrv_close(bs);
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02002168 bs->drv = NULL;
Kevin Wolf9a7dedb2015-06-16 10:58:20 +02002169
Kevin Wolf5db15a52015-09-14 15:33:33 +02002170 bdrv_set_backing_hd(bs, NULL);
Kevin Wolf9a7dedb2015-06-16 10:58:20 +02002171
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02002172 if (bs->file != NULL) {
2173 bdrv_unref_child(bs, bs->file);
2174 bs->file = NULL;
2175 }
2176
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02002177 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
Kevin Wolf33a60402015-06-15 13:51:04 +02002178 /* TODO Remove bdrv_unref() from drivers' close function and use
2179 * bdrv_unref_child() here */
Kevin Wolfbddcec32015-04-09 18:47:50 +02002180 if (child->bs->inherits_from == bs) {
2181 child->bs->inherits_from = NULL;
2182 }
Kevin Wolf33a60402015-06-15 13:51:04 +02002183 bdrv_detach_child(child);
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02002184 }
2185
Anthony Liguori7267c092011-08-20 22:09:37 -05002186 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00002187 bs->opaque = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00002188 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02002189 bs->backing_file[0] = '\0';
2190 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02002191 bs->total_sectors = 0;
2192 bs->encrypted = 0;
2193 bs->valid_key = 0;
2194 bs->sg = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08002195 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01002196 QDECREF(bs->options);
Kevin Wolf145f5982015-05-08 16:15:03 +02002197 QDECREF(bs->explicit_options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01002198 bs->options = NULL;
Max Reitz91af7012014-07-18 20:24:56 +02002199 QDECREF(bs->full_open_options);
2200 bs->full_open_options = NULL;
bellardb3380822004-03-14 21:38:54 +00002201 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08002202
Max Reitz33384422014-06-20 21:57:33 +02002203 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
2204 g_free(ban);
2205 }
2206 QLIST_INIT(&bs->aio_notifiers);
Paolo Bonzinifc272912015-12-23 11:48:24 +01002207 bdrv_drained_end(bs);
bellardb3380822004-03-14 21:38:54 +00002208}
2209
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09002210void bdrv_close_all(void)
2211{
2212 BlockDriverState *bs;
Max Reitzca9bd242016-01-29 16:36:14 +01002213 AioContext *aio_context;
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09002214
Max Reitzca9bd242016-01-29 16:36:14 +01002215 /* Drop references from requests still in flight, such as canceled block
2216 * jobs whose AIO context has not been polled yet */
2217 bdrv_drain_all();
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002218
Max Reitzca9bd242016-01-29 16:36:14 +01002219 blk_remove_all_bs();
2220 blockdev_close_all_bdrv_states();
2221
2222 /* Cancel all block jobs */
2223 while (!QTAILQ_EMPTY(&all_bdrv_states)) {
2224 QTAILQ_FOREACH(bs, &all_bdrv_states, bs_list) {
2225 aio_context = bdrv_get_aio_context(bs);
2226
2227 aio_context_acquire(aio_context);
2228 if (bs->job) {
2229 block_job_cancel_sync(bs->job);
2230 aio_context_release(aio_context);
2231 break;
2232 }
2233 aio_context_release(aio_context);
2234 }
2235
2236 /* All the remaining BlockDriverStates are referenced directly or
2237 * indirectly from block jobs, so there needs to be at least one BDS
2238 * directly used by a block job */
2239 assert(bs);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09002240 }
2241}
2242
Jeff Codyf8aa9052016-02-01 20:33:10 -05002243/* Note that bs->device_list.tqe_prev is initially null,
2244 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
2245 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
2246 * resetting it to null on remove. */
2247void bdrv_device_remove(BlockDriverState *bs)
2248{
2249 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
2250 bs->device_list.tqe_prev = NULL;
2251}
2252
Benoît Canetdc364f42014-01-23 21:31:32 +01002253/* make a BlockDriverState anonymous by removing from bdrv_state and
2254 * graph_bdrv_state list.
Ryan Harperd22b2f42011-03-29 20:51:47 -05002255 Also, NULL terminate the device_name to prevent double remove */
2256void bdrv_make_anon(BlockDriverState *bs)
2257{
Jeff Codyf8aa9052016-02-01 20:33:10 -05002258 /* Take care to remove bs from bdrv_states only when it's actually
2259 * in it. */
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002260 if (bs->device_list.tqe_prev) {
Jeff Codyf8aa9052016-02-01 20:33:10 -05002261 bdrv_device_remove(bs);
Ryan Harperd22b2f42011-03-29 20:51:47 -05002262 }
Benoît Canetdc364f42014-01-23 21:31:32 +01002263 if (bs->node_name[0] != '\0') {
2264 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
2265 }
2266 bs->node_name[0] = '\0';
Ryan Harperd22b2f42011-03-29 20:51:47 -05002267}
2268
Kevin Wolf8e419ae2015-09-16 16:18:38 +02002269/* Fields that need to stay with the top-level BDS */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002270static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
2271 BlockDriverState *bs_src)
2272{
2273 /* move some fields that need to stay attached to the device */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002274
2275 /* dev info */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002276 bs_dest->copy_on_read = bs_src->copy_on_read;
2277
2278 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2279
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002280 /* dirty bitmap */
2281 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
2282}
2283
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002284static void change_parent_backing_link(BlockDriverState *from,
2285 BlockDriverState *to)
2286{
2287 BdrvChild *c, *next;
2288
2289 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2290 assert(c->role != &child_backing);
2291 c->bs = to;
2292 QLIST_REMOVE(c, next_parent);
2293 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2294 bdrv_ref(to);
2295 bdrv_unref(from);
2296 }
2297 if (from->blk) {
2298 blk_set_bs(from->blk, to);
2299 if (!to->device_list.tqe_prev) {
2300 QTAILQ_INSERT_BEFORE(from, to, device_list);
2301 }
Jeff Codyf8aa9052016-02-01 20:33:10 -05002302 bdrv_device_remove(from);
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002303 }
2304}
2305
2306static void swap_feature_fields(BlockDriverState *bs_top,
2307 BlockDriverState *bs_new)
2308{
2309 BlockDriverState tmp;
2310
2311 bdrv_move_feature_fields(&tmp, bs_top);
2312 bdrv_move_feature_fields(bs_top, bs_new);
2313 bdrv_move_feature_fields(bs_new, &tmp);
2314
2315 assert(!bs_new->throttle_state);
2316 if (bs_top->throttle_state) {
2317 assert(bs_top->io_limits_enabled);
2318 bdrv_io_limits_enable(bs_new, throttle_group_get_name(bs_top));
2319 bdrv_io_limits_disable(bs_top);
2320 }
2321}
2322
Jeff Cody8802d1f2012-02-28 15:54:06 -05002323/*
2324 * Add new bs contents at the top of an image chain while the chain is
2325 * live, while keeping required fields on the top layer.
2326 *
2327 * This will modify the BlockDriverState fields, and swap contents
2328 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2329 *
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002330 * bs_new must not be attached to a BlockBackend.
Jeff Codyf6801b82012-03-27 16:30:19 -04002331 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05002332 * This function does not create any image files.
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002333 *
2334 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2335 * that's what the callers commonly need. bs_new will be referenced by the old
2336 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2337 * reference of its own, it must call bdrv_ref().
Jeff Cody8802d1f2012-02-28 15:54:06 -05002338 */
2339void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2340{
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002341 assert(!bdrv_requests_pending(bs_top));
2342 assert(!bdrv_requests_pending(bs_new));
Jeff Cody8802d1f2012-02-28 15:54:06 -05002343
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002344 bdrv_ref(bs_top);
2345 change_parent_backing_link(bs_top, bs_new);
2346
2347 /* Some fields always stay on top of the backing file chain */
2348 swap_feature_fields(bs_top, bs_new);
2349
2350 bdrv_set_backing_hd(bs_new, bs_top);
2351 bdrv_unref(bs_top);
2352
2353 /* bs_new is now referenced by its new parents, we don't need the
2354 * additional reference any more. */
2355 bdrv_unref(bs_new);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002356}
2357
Kevin Wolf3f09bfb2015-09-15 11:58:23 +02002358void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2359{
2360 assert(!bdrv_requests_pending(old));
2361 assert(!bdrv_requests_pending(new));
2362
2363 bdrv_ref(old);
2364
2365 if (old->blk) {
2366 /* As long as these fields aren't in BlockBackend, but in the top-level
2367 * BlockDriverState, it's not possible for a BDS to have two BBs.
2368 *
2369 * We really want to copy the fields from old to new, but we go for a
2370 * swap instead so that pointers aren't duplicated and cause trouble.
2371 * (Also, bdrv_swap() used to do the same.) */
2372 assert(!new->blk);
2373 swap_feature_fields(old, new);
2374 }
2375 change_parent_backing_link(old, new);
2376
2377 /* Change backing files if a previously independent node is added to the
2378 * chain. For active commit, we replace top by its own (indirect) backing
2379 * file and don't do anything here so we don't build a loop. */
2380 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2381 bdrv_set_backing_hd(new, backing_bs(old));
2382 bdrv_set_backing_hd(old, NULL);
2383 }
2384
2385 bdrv_unref(old);
2386}
2387
Fam Zheng4f6fd342013-08-23 09:14:47 +08002388static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00002389{
Paolo Bonzini3e914652012-03-30 13:17:11 +02002390 assert(!bs->job);
Fam Zheng3718d8a2014-05-23 21:29:43 +08002391 assert(bdrv_op_blocker_is_empty(bs));
Fam Zheng4f6fd342013-08-23 09:14:47 +08002392 assert(!bs->refcnt);
Markus Armbruster18846de2010-06-29 16:58:30 +02002393
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02002394 bdrv_close(bs);
2395
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002396 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05002397 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00002398
Max Reitz2c1d04e2016-01-29 16:36:11 +01002399 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
2400
Anthony Liguori7267c092011-08-20 22:09:37 -05002401 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00002402}
2403
aliguorie97fc192009-04-21 23:11:50 +00002404/*
2405 * Run consistency checks on an image
2406 *
Kevin Wolfe076f332010-06-29 11:43:13 +02002407 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02002408 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02002409 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00002410 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02002411int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00002412{
Max Reitz908bcd52014-08-07 22:47:55 +02002413 if (bs->drv == NULL) {
2414 return -ENOMEDIUM;
2415 }
aliguorie97fc192009-04-21 23:11:50 +00002416 if (bs->drv->bdrv_check == NULL) {
2417 return -ENOTSUP;
2418 }
2419
Kevin Wolfe076f332010-06-29 11:43:13 +02002420 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02002421 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00002422}
2423
Kevin Wolf8a426612010-07-16 17:17:01 +02002424#define COMMIT_BUF_SECTORS 2048
2425
bellard33e39632003-07-06 17:15:21 +00002426/* commit COW file into the raw image */
2427int bdrv_commit(BlockDriverState *bs)
2428{
bellard19cb3732006-08-19 11:45:59 +00002429 BlockDriver *drv = bs->drv;
Jeff Cody72706ea2014-01-24 09:02:35 -05002430 int64_t sector, total_sectors, length, backing_length;
Kevin Wolf8a426612010-07-16 17:17:01 +02002431 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04002432 int ret = 0;
Jeff Cody72706ea2014-01-24 09:02:35 -05002433 uint8_t *buf = NULL;
bellard33e39632003-07-06 17:15:21 +00002434
bellard19cb3732006-08-19 11:45:59 +00002435 if (!drv)
2436 return -ENOMEDIUM;
Liu Yuan6bb45152014-09-01 13:35:21 +08002437
Kevin Wolf760e0062015-06-17 14:55:21 +02002438 if (!bs->backing) {
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002439 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00002440 }
2441
Fam Zhengbb000212014-09-11 13:14:00 +08002442 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
Kevin Wolf760e0062015-06-17 14:55:21 +02002443 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00002444 return -EBUSY;
2445 }
2446
Kevin Wolf760e0062015-06-17 14:55:21 +02002447 ro = bs->backing->bs->read_only;
2448 open_flags = bs->backing->bs->open_flags;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002449
2450 if (ro) {
Kevin Wolf760e0062015-06-17 14:55:21 +02002451 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002452 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002453 }
bellard33e39632003-07-06 17:15:21 +00002454 }
bellardea2384d2004-08-01 21:59:26 +00002455
Jeff Cody72706ea2014-01-24 09:02:35 -05002456 length = bdrv_getlength(bs);
2457 if (length < 0) {
2458 ret = length;
2459 goto ro_cleanup;
2460 }
2461
Kevin Wolf760e0062015-06-17 14:55:21 +02002462 backing_length = bdrv_getlength(bs->backing->bs);
Jeff Cody72706ea2014-01-24 09:02:35 -05002463 if (backing_length < 0) {
2464 ret = backing_length;
2465 goto ro_cleanup;
2466 }
2467
2468 /* If our top snapshot is larger than the backing file image,
2469 * grow the backing file image if possible. If not possible,
2470 * we must return an error */
2471 if (length > backing_length) {
Kevin Wolf760e0062015-06-17 14:55:21 +02002472 ret = bdrv_truncate(bs->backing->bs, length);
Jeff Cody72706ea2014-01-24 09:02:35 -05002473 if (ret < 0) {
2474 goto ro_cleanup;
2475 }
2476 }
2477
2478 total_sectors = length >> BDRV_SECTOR_BITS;
Kevin Wolf857d4f42014-05-20 13:16:51 +02002479
2480 /* qemu_try_blockalign() for bs will choose an alignment that works for
Kevin Wolf760e0062015-06-17 14:55:21 +02002481 * bs->backing->bs as well, so no need to compare the alignment manually. */
Kevin Wolf857d4f42014-05-20 13:16:51 +02002482 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2483 if (buf == NULL) {
2484 ret = -ENOMEM;
2485 goto ro_cleanup;
2486 }
bellardea2384d2004-08-01 21:59:26 +00002487
Kevin Wolf8a426612010-07-16 17:17:01 +02002488 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02002489 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2490 if (ret < 0) {
2491 goto ro_cleanup;
2492 }
2493 if (ret) {
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002494 ret = bdrv_read(bs, sector, buf, n);
2495 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002496 goto ro_cleanup;
2497 }
2498
Kevin Wolf760e0062015-06-17 14:55:21 +02002499 ret = bdrv_write(bs->backing->bs, sector, buf, n);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002500 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002501 goto ro_cleanup;
2502 }
bellardea2384d2004-08-01 21:59:26 +00002503 }
2504 }
bellard95389c82005-12-18 18:28:15 +00002505
Christoph Hellwig1d449522010-01-17 12:32:30 +01002506 if (drv->bdrv_make_empty) {
2507 ret = drv->bdrv_make_empty(bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002508 if (ret < 0) {
2509 goto ro_cleanup;
2510 }
Christoph Hellwig1d449522010-01-17 12:32:30 +01002511 bdrv_flush(bs);
2512 }
bellard95389c82005-12-18 18:28:15 +00002513
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002514 /*
2515 * Make sure all data we wrote to the backing device is actually
2516 * stable on disk.
2517 */
Kevin Wolf760e0062015-06-17 14:55:21 +02002518 if (bs->backing) {
2519 bdrv_flush(bs->backing->bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002520 }
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002521
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002522 ret = 0;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002523ro_cleanup:
Kevin Wolf857d4f42014-05-20 13:16:51 +02002524 qemu_vfree(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002525
2526 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002527 /* ignoring error return here */
Kevin Wolf760e0062015-06-17 14:55:21 +02002528 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002529 }
2530
Christoph Hellwig1d449522010-01-17 12:32:30 +01002531 return ret;
bellard33e39632003-07-06 17:15:21 +00002532}
2533
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002534int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002535{
2536 BlockDriverState *bs;
2537
Benoît Canetdc364f42014-01-23 21:31:32 +01002538 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002539 AioContext *aio_context = bdrv_get_aio_context(bs);
2540
2541 aio_context_acquire(aio_context);
Kevin Wolf760e0062015-06-17 14:55:21 +02002542 if (bs->drv && bs->backing) {
Jeff Cody272d2d82013-02-26 09:55:48 -05002543 int ret = bdrv_commit(bs);
2544 if (ret < 0) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002545 aio_context_release(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002546 return ret;
2547 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002548 }
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002549 aio_context_release(aio_context);
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002550 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002551 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002552}
2553
Kevin Wolf756e6732010-01-12 12:55:17 +01002554/*
2555 * Return values:
2556 * 0 - success
2557 * -EINVAL - backing format specified, but no file
2558 * -ENOSPC - can't update the backing file because no space is left in the
2559 * image file header
2560 * -ENOTSUP - format driver doesn't support changing the backing file
2561 */
2562int bdrv_change_backing_file(BlockDriverState *bs,
2563 const char *backing_file, const char *backing_fmt)
2564{
2565 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002566 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002567
Paolo Bonzini5f377792012-04-12 14:01:01 +02002568 /* Backing file format doesn't make sense without a backing file */
2569 if (backing_fmt && !backing_file) {
2570 return -EINVAL;
2571 }
2572
Kevin Wolf756e6732010-01-12 12:55:17 +01002573 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002574 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002575 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002576 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002577 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002578
2579 if (ret == 0) {
2580 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2581 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2582 }
2583 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002584}
2585
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002586/*
2587 * Finds the image layer in the chain that has 'bs' as its backing file.
2588 *
2589 * active is the current topmost image.
2590 *
2591 * Returns NULL if bs is not found in active's image chain,
2592 * or if active == bs.
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002593 *
2594 * Returns the bottommost base image if bs == NULL.
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002595 */
2596BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2597 BlockDriverState *bs)
2598{
Kevin Wolf760e0062015-06-17 14:55:21 +02002599 while (active && bs != backing_bs(active)) {
2600 active = backing_bs(active);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002601 }
2602
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002603 return active;
2604}
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002605
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002606/* Given a BDS, searches for the base layer. */
2607BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2608{
2609 return bdrv_find_overlay(bs, NULL);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002610}
2611
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002612/*
2613 * Drops images above 'base' up to and including 'top', and sets the image
2614 * above 'top' to have base as its backing file.
2615 *
2616 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2617 * information in 'bs' can be properly updated.
2618 *
2619 * E.g., this will convert the following chain:
2620 * bottom <- base <- intermediate <- top <- active
2621 *
2622 * to
2623 *
2624 * bottom <- base <- active
2625 *
2626 * It is allowed for bottom==base, in which case it converts:
2627 *
2628 * base <- intermediate <- top <- active
2629 *
2630 * to
2631 *
2632 * base <- active
2633 *
Jeff Cody54e26902014-06-25 15:40:10 -04002634 * If backing_file_str is non-NULL, it will be used when modifying top's
2635 * overlay image metadata.
2636 *
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002637 * Error conditions:
2638 * if active == top, that is considered an error
2639 *
2640 */
2641int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
Jeff Cody54e26902014-06-25 15:40:10 -04002642 BlockDriverState *base, const char *backing_file_str)
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002643{
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002644 BlockDriverState *new_top_bs = NULL;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002645 int ret = -EIO;
2646
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002647 if (!top->drv || !base->drv) {
2648 goto exit;
2649 }
2650
2651 new_top_bs = bdrv_find_overlay(active, top);
2652
2653 if (new_top_bs == NULL) {
2654 /* we could not find the image above 'top', this is an error */
2655 goto exit;
2656 }
2657
Kevin Wolf760e0062015-06-17 14:55:21 +02002658 /* special case of new_top_bs->backing->bs already pointing to base - nothing
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002659 * to do, no intermediate images */
Kevin Wolf760e0062015-06-17 14:55:21 +02002660 if (backing_bs(new_top_bs) == base) {
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002661 ret = 0;
2662 goto exit;
2663 }
2664
Kevin Wolf5db15a52015-09-14 15:33:33 +02002665 /* Make sure that base is in the backing chain of top */
2666 if (!bdrv_chain_contains(top, base)) {
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002667 goto exit;
2668 }
2669
2670 /* success - we can delete the intermediate states, and link top->base */
Kevin Wolf5db15a52015-09-14 15:33:33 +02002671 backing_file_str = backing_file_str ? backing_file_str : base->filename;
Jeff Cody54e26902014-06-25 15:40:10 -04002672 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
Kevin Wolf5db15a52015-09-14 15:33:33 +02002673 base->drv ? base->drv->format_name : "");
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002674 if (ret) {
2675 goto exit;
2676 }
Kevin Wolf5db15a52015-09-14 15:33:33 +02002677 bdrv_set_backing_hd(new_top_bs, base);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002678
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002679 ret = 0;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002680exit:
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002681 return ret;
2682}
2683
bellard83f64092006-08-01 16:21:11 +00002684/**
bellard83f64092006-08-01 16:21:11 +00002685 * Truncate file to 'offset' bytes (needed only for file protocols)
2686 */
2687int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2688{
2689 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002690 int ret;
bellard83f64092006-08-01 16:21:11 +00002691 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002692 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00002693 if (!drv->bdrv_truncate)
2694 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02002695 if (bs->read_only)
2696 return -EACCES;
Jeff Cody9c75e162014-06-25 16:55:30 -04002697
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002698 ret = drv->bdrv_truncate(bs, offset);
2699 if (ret == 0) {
2700 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
John Snowce1ffea2015-04-17 19:50:03 -04002701 bdrv_dirty_bitmap_truncate(bs);
Markus Armbrustera7f53e22014-10-07 13:59:25 +02002702 if (bs->blk) {
2703 blk_dev_resize_cb(bs->blk);
2704 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002705 }
2706 return ret;
bellard83f64092006-08-01 16:21:11 +00002707}
2708
2709/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002710 * Length of a allocated file in bytes. Sparse files are counted by actual
2711 * allocated space. Return < 0 if error or unknown.
2712 */
2713int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2714{
2715 BlockDriver *drv = bs->drv;
2716 if (!drv) {
2717 return -ENOMEDIUM;
2718 }
2719 if (drv->bdrv_get_allocated_file_size) {
2720 return drv->bdrv_get_allocated_file_size(bs);
2721 }
2722 if (bs->file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02002723 return bdrv_get_allocated_file_size(bs->file->bs);
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002724 }
2725 return -ENOTSUP;
2726}
2727
2728/**
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002729 * Return number of sectors on success, -errno on error.
bellard83f64092006-08-01 16:21:11 +00002730 */
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002731int64_t bdrv_nb_sectors(BlockDriverState *bs)
bellard83f64092006-08-01 16:21:11 +00002732{
2733 BlockDriver *drv = bs->drv;
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002734
bellard83f64092006-08-01 16:21:11 +00002735 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002736 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002737
Kevin Wolfb94a2612013-10-29 12:18:58 +01002738 if (drv->has_variable_length) {
2739 int ret = refresh_total_sectors(bs, bs->total_sectors);
2740 if (ret < 0) {
2741 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002742 }
bellard83f64092006-08-01 16:21:11 +00002743 }
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002744 return bs->total_sectors;
2745}
2746
2747/**
2748 * Return length in bytes on success, -errno on error.
2749 * The length is always a multiple of BDRV_SECTOR_SIZE.
2750 */
2751int64_t bdrv_getlength(BlockDriverState *bs)
2752{
2753 int64_t ret = bdrv_nb_sectors(bs);
2754
Fam Zheng4a9c9ea2015-05-15 16:36:05 +08002755 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002756 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00002757}
2758
bellard19cb3732006-08-19 11:45:59 +00002759/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00002760void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00002761{
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002762 int64_t nb_sectors = bdrv_nb_sectors(bs);
2763
2764 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
bellardfc01f7e2003-06-30 10:03:06 +00002765}
bellardcf989512004-02-16 21:56:36 +00002766
bellardb3380822004-03-14 21:38:54 +00002767int bdrv_is_read_only(BlockDriverState *bs)
2768{
2769 return bs->read_only;
2770}
2771
ths985a03b2007-12-24 16:10:43 +00002772int bdrv_is_sg(BlockDriverState *bs)
2773{
2774 return bs->sg;
2775}
2776
Christoph Hellwige900a7b2009-09-04 19:01:15 +02002777int bdrv_enable_write_cache(BlockDriverState *bs)
2778{
2779 return bs->enable_write_cache;
2780}
2781
Paolo Bonzini425b0142012-06-06 00:04:52 +02002782void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2783{
2784 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04002785
2786 /* so a reopen() will preserve wce */
2787 if (wce) {
2788 bs->open_flags |= BDRV_O_CACHE_WB;
2789 } else {
2790 bs->open_flags &= ~BDRV_O_CACHE_WB;
2791 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02002792}
2793
bellardea2384d2004-08-01 21:59:26 +00002794int bdrv_is_encrypted(BlockDriverState *bs)
2795{
Kevin Wolf760e0062015-06-17 14:55:21 +02002796 if (bs->backing && bs->backing->bs->encrypted) {
bellardea2384d2004-08-01 21:59:26 +00002797 return 1;
Kevin Wolf760e0062015-06-17 14:55:21 +02002798 }
bellardea2384d2004-08-01 21:59:26 +00002799 return bs->encrypted;
2800}
2801
aliguoric0f4ce72009-03-05 23:01:01 +00002802int bdrv_key_required(BlockDriverState *bs)
2803{
Kevin Wolf760e0062015-06-17 14:55:21 +02002804 BdrvChild *backing = bs->backing;
aliguoric0f4ce72009-03-05 23:01:01 +00002805
Kevin Wolf760e0062015-06-17 14:55:21 +02002806 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
aliguoric0f4ce72009-03-05 23:01:01 +00002807 return 1;
Kevin Wolf760e0062015-06-17 14:55:21 +02002808 }
aliguoric0f4ce72009-03-05 23:01:01 +00002809 return (bs->encrypted && !bs->valid_key);
2810}
2811
bellardea2384d2004-08-01 21:59:26 +00002812int bdrv_set_key(BlockDriverState *bs, const char *key)
2813{
2814 int ret;
Kevin Wolf760e0062015-06-17 14:55:21 +02002815 if (bs->backing && bs->backing->bs->encrypted) {
2816 ret = bdrv_set_key(bs->backing->bs, key);
bellardea2384d2004-08-01 21:59:26 +00002817 if (ret < 0)
2818 return ret;
2819 if (!bs->encrypted)
2820 return 0;
2821 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02002822 if (!bs->encrypted) {
2823 return -EINVAL;
2824 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2825 return -ENOMEDIUM;
2826 }
aliguoric0f4ce72009-03-05 23:01:01 +00002827 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00002828 if (ret < 0) {
2829 bs->valid_key = 0;
2830 } else if (!bs->valid_key) {
2831 bs->valid_key = 1;
Markus Armbrustera7f53e22014-10-07 13:59:25 +02002832 if (bs->blk) {
2833 /* call the change callback now, we skipped it on open */
2834 blk_dev_change_media_cb(bs->blk, true);
2835 }
aliguoribb5fc202009-03-05 23:01:15 +00002836 }
aliguoric0f4ce72009-03-05 23:01:01 +00002837 return ret;
bellardea2384d2004-08-01 21:59:26 +00002838}
2839
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002840/*
2841 * Provide an encryption key for @bs.
2842 * If @key is non-null:
2843 * If @bs is not encrypted, fail.
2844 * Else if the key is invalid, fail.
2845 * Else set @bs's key to @key, replacing the existing key, if any.
2846 * If @key is null:
2847 * If @bs is encrypted and still lacks a key, fail.
2848 * Else do nothing.
2849 * On failure, store an error object through @errp if non-null.
2850 */
2851void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2852{
2853 if (key) {
2854 if (!bdrv_is_encrypted(bs)) {
Alberto Garcia81e5f782015-04-08 12:29:19 +03002855 error_setg(errp, "Node '%s' is not encrypted",
2856 bdrv_get_device_or_node_name(bs));
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002857 } else if (bdrv_set_key(bs, key) < 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002858 error_setg(errp, QERR_INVALID_PASSWORD);
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002859 }
2860 } else {
2861 if (bdrv_key_required(bs)) {
Markus Armbrusterb1ca6392015-01-29 10:37:01 +01002862 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2863 "'%s' (%s) is encrypted",
Alberto Garcia81e5f782015-04-08 12:29:19 +03002864 bdrv_get_device_or_node_name(bs),
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002865 bdrv_get_encrypted_filename(bs));
2866 }
2867 }
2868}
2869
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02002870const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00002871{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02002872 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00002873}
2874
Stefan Hajnocziada42402014-08-27 12:08:55 +01002875static int qsort_strcmp(const void *a, const void *b)
2876{
2877 return strcmp(a, b);
2878}
2879
ths5fafdf22007-09-16 21:08:06 +00002880void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00002881 void *opaque)
2882{
2883 BlockDriver *drv;
Jeff Codye855e4f2014-04-28 18:29:54 -04002884 int count = 0;
Stefan Hajnocziada42402014-08-27 12:08:55 +01002885 int i;
Jeff Codye855e4f2014-04-28 18:29:54 -04002886 const char **formats = NULL;
bellardea2384d2004-08-01 21:59:26 +00002887
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01002888 QLIST_FOREACH(drv, &bdrv_drivers, list) {
Jeff Codye855e4f2014-04-28 18:29:54 -04002889 if (drv->format_name) {
2890 bool found = false;
2891 int i = count;
2892 while (formats && i && !found) {
2893 found = !strcmp(formats[--i], drv->format_name);
2894 }
2895
2896 if (!found) {
Markus Armbruster5839e532014-08-19 10:31:08 +02002897 formats = g_renew(const char *, formats, count + 1);
Jeff Codye855e4f2014-04-28 18:29:54 -04002898 formats[count++] = drv->format_name;
Jeff Codye855e4f2014-04-28 18:29:54 -04002899 }
2900 }
bellardea2384d2004-08-01 21:59:26 +00002901 }
Stefan Hajnocziada42402014-08-27 12:08:55 +01002902
2903 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2904
2905 for (i = 0; i < count; i++) {
2906 it(opaque, formats[i]);
2907 }
2908
Jeff Codye855e4f2014-04-28 18:29:54 -04002909 g_free(formats);
bellardea2384d2004-08-01 21:59:26 +00002910}
2911
Benoît Canetdc364f42014-01-23 21:31:32 +01002912/* This function is to find a node in the bs graph */
2913BlockDriverState *bdrv_find_node(const char *node_name)
2914{
2915 BlockDriverState *bs;
2916
2917 assert(node_name);
2918
2919 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2920 if (!strcmp(node_name, bs->node_name)) {
2921 return bs;
2922 }
2923 }
2924 return NULL;
2925}
2926
Benoît Canetc13163f2014-01-23 21:31:34 +01002927/* Put this QMP function here so it can access the static graph_bdrv_states. */
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002928BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
Benoît Canetc13163f2014-01-23 21:31:34 +01002929{
2930 BlockDeviceInfoList *list, *entry;
2931 BlockDriverState *bs;
2932
2933 list = NULL;
2934 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002935 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2936 if (!info) {
2937 qapi_free_BlockDeviceInfoList(list);
2938 return NULL;
2939 }
Benoît Canetc13163f2014-01-23 21:31:34 +01002940 entry = g_malloc0(sizeof(*entry));
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002941 entry->value = info;
Benoît Canetc13163f2014-01-23 21:31:34 +01002942 entry->next = list;
2943 list = entry;
2944 }
2945
2946 return list;
2947}
2948
Benoît Canet12d3ba82014-01-23 21:31:35 +01002949BlockDriverState *bdrv_lookup_bs(const char *device,
2950 const char *node_name,
2951 Error **errp)
2952{
Markus Armbruster7f06d472014-10-07 13:59:12 +02002953 BlockBackend *blk;
2954 BlockDriverState *bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01002955
Benoît Canet12d3ba82014-01-23 21:31:35 +01002956 if (device) {
Markus Armbruster7f06d472014-10-07 13:59:12 +02002957 blk = blk_by_name(device);
Benoît Canet12d3ba82014-01-23 21:31:35 +01002958
Markus Armbruster7f06d472014-10-07 13:59:12 +02002959 if (blk) {
Alberto Garcia9f4ed6f2015-10-26 16:46:49 +02002960 bs = blk_bs(blk);
2961 if (!bs) {
Max Reitz5433c242015-10-19 17:53:29 +02002962 error_setg(errp, "Device '%s' has no medium", device);
Max Reitz5433c242015-10-19 17:53:29 +02002963 }
2964
Alberto Garcia9f4ed6f2015-10-26 16:46:49 +02002965 return bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01002966 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01002967 }
2968
Benoît Canetdd67fa52014-02-12 17:15:06 +01002969 if (node_name) {
2970 bs = bdrv_find_node(node_name);
Benoît Canet12d3ba82014-01-23 21:31:35 +01002971
Benoît Canetdd67fa52014-02-12 17:15:06 +01002972 if (bs) {
2973 return bs;
2974 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01002975 }
2976
Benoît Canetdd67fa52014-02-12 17:15:06 +01002977 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2978 device ? device : "",
2979 node_name ? node_name : "");
2980 return NULL;
Benoît Canet12d3ba82014-01-23 21:31:35 +01002981}
2982
Jeff Cody5a6684d2014-06-25 15:40:09 -04002983/* If 'base' is in the same chain as 'top', return true. Otherwise,
2984 * return false. If either argument is NULL, return false. */
2985bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2986{
2987 while (top && top != base) {
Kevin Wolf760e0062015-06-17 14:55:21 +02002988 top = backing_bs(top);
Jeff Cody5a6684d2014-06-25 15:40:09 -04002989 }
2990
2991 return top != NULL;
2992}
2993
Fam Zheng04df7652014-10-31 11:32:54 +08002994BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2995{
2996 if (!bs) {
2997 return QTAILQ_FIRST(&graph_bdrv_states);
2998 }
2999 return QTAILQ_NEXT(bs, node_list);
3000}
3001
Markus Armbruster2f399b02010-06-02 18:55:20 +02003002BlockDriverState *bdrv_next(BlockDriverState *bs)
3003{
3004 if (!bs) {
3005 return QTAILQ_FIRST(&bdrv_states);
3006 }
Benoît Canetdc364f42014-01-23 21:31:32 +01003007 return QTAILQ_NEXT(bs, device_list);
Markus Armbruster2f399b02010-06-02 18:55:20 +02003008}
3009
Fam Zheng20a9e772014-10-31 11:32:55 +08003010const char *bdrv_get_node_name(const BlockDriverState *bs)
3011{
3012 return bs->node_name;
3013}
3014
Markus Armbruster7f06d472014-10-07 13:59:12 +02003015/* TODO check what callers really want: bs->node_name or blk_name() */
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003016const char *bdrv_get_device_name(const BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00003017{
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003018 return bs->blk ? blk_name(bs->blk) : "";
bellardea2384d2004-08-01 21:59:26 +00003019}
3020
Alberto Garcia9b2aa842015-04-08 12:29:18 +03003021/* This can be used to identify nodes that might not have a device
3022 * name associated. Since node and device names live in the same
3023 * namespace, the result is unambiguous. The exception is if both are
3024 * absent, then this returns an empty (non-null) string. */
3025const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
3026{
3027 return bs->blk ? blk_name(bs->blk) : bs->node_name;
3028}
3029
Markus Armbrusterc8433282012-06-05 16:49:24 +02003030int bdrv_get_flags(BlockDriverState *bs)
3031{
3032 return bs->open_flags;
3033}
3034
Peter Lieven3ac21622013-06-28 12:47:42 +02003035int bdrv_has_zero_init_1(BlockDriverState *bs)
3036{
3037 return 1;
3038}
3039
Kevin Wolff2feebb2010-04-14 17:30:35 +02003040int bdrv_has_zero_init(BlockDriverState *bs)
3041{
3042 assert(bs->drv);
3043
Paolo Bonzini11212d82013-09-04 19:00:27 +02003044 /* If BS is a copy on write image, it is initialized to
3045 the contents of the base image, which may not be zeroes. */
Kevin Wolf760e0062015-06-17 14:55:21 +02003046 if (bs->backing) {
Paolo Bonzini11212d82013-09-04 19:00:27 +02003047 return 0;
3048 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02003049 if (bs->drv->bdrv_has_zero_init) {
3050 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02003051 }
3052
Peter Lieven3ac21622013-06-28 12:47:42 +02003053 /* safe default */
3054 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02003055}
3056
Peter Lieven4ce78692013-10-24 12:06:54 +02003057bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3058{
3059 BlockDriverInfo bdi;
3060
Kevin Wolf760e0062015-06-17 14:55:21 +02003061 if (bs->backing) {
Peter Lieven4ce78692013-10-24 12:06:54 +02003062 return false;
3063 }
3064
3065 if (bdrv_get_info(bs, &bdi) == 0) {
3066 return bdi.unallocated_blocks_are_zero;
3067 }
3068
3069 return false;
3070}
3071
3072bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3073{
3074 BlockDriverInfo bdi;
3075
Kevin Wolf760e0062015-06-17 14:55:21 +02003076 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
Peter Lieven4ce78692013-10-24 12:06:54 +02003077 return false;
3078 }
3079
3080 if (bdrv_get_info(bs, &bdi) == 0) {
3081 return bdi.can_write_zeroes_with_unmap;
3082 }
3083
3084 return false;
3085}
3086
aliguori045df332009-03-05 23:00:48 +00003087const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3088{
Kevin Wolf760e0062015-06-17 14:55:21 +02003089 if (bs->backing && bs->backing->bs->encrypted)
aliguori045df332009-03-05 23:00:48 +00003090 return bs->backing_file;
3091 else if (bs->encrypted)
3092 return bs->filename;
3093 else
3094 return NULL;
3095}
3096
ths5fafdf22007-09-16 21:08:06 +00003097void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00003098 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00003099{
Kevin Wolf3574c602011-10-26 11:02:11 +02003100 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00003101}
3102
bellardfaea38e2006-08-05 21:31:00 +00003103int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3104{
3105 BlockDriver *drv = bs->drv;
3106 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003107 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003108 if (!drv->bdrv_get_info)
3109 return -ENOTSUP;
3110 memset(bdi, 0, sizeof(*bdi));
3111 return drv->bdrv_get_info(bs, bdi);
3112}
3113
Max Reitzeae041f2013-10-09 10:46:16 +02003114ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3115{
3116 BlockDriver *drv = bs->drv;
3117 if (drv && drv->bdrv_get_specific_info) {
3118 return drv->bdrv_get_specific_info(bs);
3119 }
3120 return NULL;
3121}
3122
Eric Blakea31939e2015-11-18 01:52:54 -07003123void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003124{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003125 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003126 return;
3127 }
3128
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003129 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01003130}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003131
Kevin Wolf41c695c2012-12-06 14:32:58 +01003132int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3133 const char *tag)
3134{
3135 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003136 bs = bs->file ? bs->file->bs : NULL;
Kevin Wolf41c695c2012-12-06 14:32:58 +01003137 }
3138
3139 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3140 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3141 }
3142
3143 return -ENOTSUP;
3144}
3145
Fam Zheng4cc70e92013-11-20 10:01:54 +08003146int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3147{
3148 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003149 bs = bs->file ? bs->file->bs : NULL;
Fam Zheng4cc70e92013-11-20 10:01:54 +08003150 }
3151
3152 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3153 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3154 }
3155
3156 return -ENOTSUP;
3157}
3158
Kevin Wolf41c695c2012-12-06 14:32:58 +01003159int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3160{
Max Reitz938789e2014-03-10 23:44:08 +01003161 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003162 bs = bs->file ? bs->file->bs : NULL;
Kevin Wolf41c695c2012-12-06 14:32:58 +01003163 }
3164
3165 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3166 return bs->drv->bdrv_debug_resume(bs, tag);
3167 }
3168
3169 return -ENOTSUP;
3170}
3171
3172bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3173{
3174 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003175 bs = bs->file ? bs->file->bs : NULL;
Kevin Wolf41c695c2012-12-06 14:32:58 +01003176 }
3177
3178 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3179 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3180 }
3181
3182 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003183}
3184
Blue Swirl199630b2010-07-25 20:49:34 +00003185int bdrv_is_snapshot(BlockDriverState *bs)
3186{
3187 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3188}
3189
Jeff Codyb1b1d782012-10-16 15:49:09 -04003190/* backing_file can either be relative, or absolute, or a protocol. If it is
3191 * relative, it must be relative to the chain. So, passing in bs->filename
3192 * from a BDS as backing_file should not be done, as that may be relative to
3193 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003194BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3195 const char *backing_file)
3196{
Jeff Codyb1b1d782012-10-16 15:49:09 -04003197 char *filename_full = NULL;
3198 char *backing_file_full = NULL;
3199 char *filename_tmp = NULL;
3200 int is_protocol = 0;
3201 BlockDriverState *curr_bs = NULL;
3202 BlockDriverState *retval = NULL;
3203
3204 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003205 return NULL;
3206 }
3207
Jeff Codyb1b1d782012-10-16 15:49:09 -04003208 filename_full = g_malloc(PATH_MAX);
3209 backing_file_full = g_malloc(PATH_MAX);
3210 filename_tmp = g_malloc(PATH_MAX);
3211
3212 is_protocol = path_has_protocol(backing_file);
3213
Kevin Wolf760e0062015-06-17 14:55:21 +02003214 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
Jeff Codyb1b1d782012-10-16 15:49:09 -04003215
3216 /* If either of the filename paths is actually a protocol, then
3217 * compare unmodified paths; otherwise make paths relative */
3218 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3219 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
Kevin Wolf760e0062015-06-17 14:55:21 +02003220 retval = curr_bs->backing->bs;
Jeff Codyb1b1d782012-10-16 15:49:09 -04003221 break;
3222 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003223 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04003224 /* If not an absolute filename path, make it relative to the current
3225 * image's filename path */
3226 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3227 backing_file);
3228
3229 /* We are going to compare absolute pathnames */
3230 if (!realpath(filename_tmp, filename_full)) {
3231 continue;
3232 }
3233
3234 /* We need to make sure the backing filename we are comparing against
3235 * is relative to the current image filename (or absolute) */
3236 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3237 curr_bs->backing_file);
3238
3239 if (!realpath(filename_tmp, backing_file_full)) {
3240 continue;
3241 }
3242
3243 if (strcmp(backing_file_full, filename_full) == 0) {
Kevin Wolf760e0062015-06-17 14:55:21 +02003244 retval = curr_bs->backing->bs;
Jeff Codyb1b1d782012-10-16 15:49:09 -04003245 break;
3246 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003247 }
3248 }
3249
Jeff Codyb1b1d782012-10-16 15:49:09 -04003250 g_free(filename_full);
3251 g_free(backing_file_full);
3252 g_free(filename_tmp);
3253 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003254}
3255
Benoît Canetf198fd12012-08-02 10:22:47 +02003256int bdrv_get_backing_file_depth(BlockDriverState *bs)
3257{
3258 if (!bs->drv) {
3259 return 0;
3260 }
3261
Kevin Wolf760e0062015-06-17 14:55:21 +02003262 if (!bs->backing) {
Benoît Canetf198fd12012-08-02 10:22:47 +02003263 return 0;
3264 }
3265
Kevin Wolf760e0062015-06-17 14:55:21 +02003266 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
Benoît Canetf198fd12012-08-02 10:22:47 +02003267}
3268
bellardea2384d2004-08-01 21:59:26 +00003269void bdrv_init(void)
3270{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003271 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00003272}
pbrookce1a14d2006-08-07 02:38:06 +00003273
Markus Armbrustereb852012009-10-27 18:41:44 +01003274void bdrv_init_with_whitelist(void)
3275{
3276 use_bdrv_whitelist = 1;
3277 bdrv_init();
3278}
3279
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003280void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06003281{
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003282 Error *local_err = NULL;
3283 int ret;
3284
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003285 if (!bs->drv) {
3286 return;
Anthony Liguori0f154232011-11-14 15:09:45 -06003287 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003288
Kevin Wolf04c01a52016-01-13 15:56:06 +01003289 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
Alexey Kardashevskiy7ea2d262014-10-09 13:50:46 +11003290 return;
3291 }
Kevin Wolf04c01a52016-01-13 15:56:06 +01003292 bs->open_flags &= ~BDRV_O_INACTIVE;
Alexey Kardashevskiy7ea2d262014-10-09 13:50:46 +11003293
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003294 if (bs->drv->bdrv_invalidate_cache) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003295 bs->drv->bdrv_invalidate_cache(bs, &local_err);
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003296 } else if (bs->file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003297 bdrv_invalidate_cache(bs->file->bs, &local_err);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003298 }
3299 if (local_err) {
Kevin Wolf04c01a52016-01-13 15:56:06 +01003300 bs->open_flags |= BDRV_O_INACTIVE;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003301 error_propagate(errp, local_err);
3302 return;
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003303 }
3304
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003305 ret = refresh_total_sectors(bs, bs->total_sectors);
3306 if (ret < 0) {
Kevin Wolf04c01a52016-01-13 15:56:06 +01003307 bs->open_flags |= BDRV_O_INACTIVE;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003308 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3309 return;
3310 }
Anthony Liguori0f154232011-11-14 15:09:45 -06003311}
3312
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003313void bdrv_invalidate_cache_all(Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06003314{
3315 BlockDriverState *bs;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003316 Error *local_err = NULL;
Anthony Liguori0f154232011-11-14 15:09:45 -06003317
Benoît Canetdc364f42014-01-23 21:31:32 +01003318 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003319 AioContext *aio_context = bdrv_get_aio_context(bs);
3320
3321 aio_context_acquire(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003322 bdrv_invalidate_cache(bs, &local_err);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003323 aio_context_release(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003324 if (local_err) {
3325 error_propagate(errp, local_err);
3326 return;
3327 }
Anthony Liguori0f154232011-11-14 15:09:45 -06003328 }
3329}
3330
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003331static int bdrv_inactivate(BlockDriverState *bs)
3332{
3333 int ret;
3334
3335 if (bs->drv->bdrv_inactivate) {
3336 ret = bs->drv->bdrv_inactivate(bs);
3337 if (ret < 0) {
3338 return ret;
3339 }
3340 }
3341
3342 bs->open_flags |= BDRV_O_INACTIVE;
3343 return 0;
3344}
3345
3346int bdrv_inactivate_all(void)
3347{
3348 BlockDriverState *bs;
3349 int ret;
3350
3351 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3352 AioContext *aio_context = bdrv_get_aio_context(bs);
3353
3354 aio_context_acquire(aio_context);
3355 ret = bdrv_inactivate(bs);
3356 aio_context_release(aio_context);
3357 if (ret < 0) {
3358 return ret;
3359 }
3360 }
3361
3362 return 0;
3363}
3364
Kevin Wolff9f05dc2011-07-15 13:50:26 +02003365/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00003366/* removable device support */
3367
3368/**
3369 * Return TRUE if the media is present
3370 */
Max Reitze031f752015-10-19 17:53:11 +02003371bool bdrv_is_inserted(BlockDriverState *bs)
bellard19cb3732006-08-19 11:45:59 +00003372{
3373 BlockDriver *drv = bs->drv;
Max Reitz28d7a782015-10-19 17:53:13 +02003374 BdrvChild *child;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02003375
Max Reitze031f752015-10-19 17:53:11 +02003376 if (!drv) {
3377 return false;
3378 }
Max Reitz28d7a782015-10-19 17:53:13 +02003379 if (drv->bdrv_is_inserted) {
3380 return drv->bdrv_is_inserted(bs);
Max Reitze031f752015-10-19 17:53:11 +02003381 }
Max Reitz28d7a782015-10-19 17:53:13 +02003382 QLIST_FOREACH(child, &bs->children, next) {
3383 if (!bdrv_is_inserted(child->bs)) {
3384 return false;
3385 }
3386 }
3387 return true;
bellard19cb3732006-08-19 11:45:59 +00003388}
3389
3390/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02003391 * Return whether the media changed since the last call to this
3392 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00003393 */
3394int bdrv_media_changed(BlockDriverState *bs)
3395{
3396 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00003397
Markus Armbruster8e49ca42011-08-03 15:08:08 +02003398 if (drv && drv->bdrv_media_changed) {
3399 return drv->bdrv_media_changed(bs);
3400 }
3401 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00003402}
3403
3404/**
3405 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3406 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02003407void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00003408{
3409 BlockDriver *drv = bs->drv;
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003410 const char *device_name;
bellard19cb3732006-08-19 11:45:59 +00003411
Markus Armbruster822e1cd2011-07-20 18:23:42 +02003412 if (drv && drv->bdrv_eject) {
3413 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00003414 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02003415
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003416 device_name = bdrv_get_device_name(bs);
3417 if (device_name[0] != '\0') {
3418 qapi_event_send_device_tray_moved(device_name,
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +02003419 eject_flag, &error_abort);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02003420 }
bellard19cb3732006-08-19 11:45:59 +00003421}
3422
bellard19cb3732006-08-19 11:45:59 +00003423/**
3424 * Lock or unlock the media (if it is locked, the user won't be able
3425 * to eject it manually).
3426 */
Markus Armbruster025e8492011-09-06 18:58:47 +02003427void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00003428{
3429 BlockDriver *drv = bs->drv;
3430
Markus Armbruster025e8492011-09-06 18:58:47 +02003431 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01003432
Markus Armbruster025e8492011-09-06 18:58:47 +02003433 if (drv && drv->bdrv_lock_medium) {
3434 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00003435 }
3436}
ths985a03b2007-12-24 16:10:43 +00003437
Fam Zheng0db6e542015-04-17 19:49:50 -04003438BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3439{
3440 BdrvDirtyBitmap *bm;
3441
3442 assert(name);
3443 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3444 if (bm->name && !strcmp(name, bm->name)) {
3445 return bm;
3446 }
3447 }
3448 return NULL;
3449}
3450
John Snow20dca812015-04-17 19:50:02 -04003451void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
Fam Zheng0db6e542015-04-17 19:49:50 -04003452{
John Snow9bd2b082015-04-17 19:49:57 -04003453 assert(!bdrv_dirty_bitmap_frozen(bitmap));
Fam Zheng0db6e542015-04-17 19:49:50 -04003454 g_free(bitmap->name);
3455 bitmap->name = NULL;
3456}
3457
3458BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
John Snow5fba6c02015-04-17 19:49:51 -04003459 uint32_t granularity,
Fam Zheng0db6e542015-04-17 19:49:50 -04003460 const char *name,
Fam Zhengb8afb522014-04-16 09:34:30 +08003461 Error **errp)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003462{
3463 int64_t bitmap_size;
Fam Zhenge4654d22013-11-13 18:29:43 +08003464 BdrvDirtyBitmap *bitmap;
John Snow5fba6c02015-04-17 19:49:51 -04003465 uint32_t sector_granularity;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003466
Paolo Bonzini50717e92013-01-21 17:09:45 +01003467 assert((granularity & (granularity - 1)) == 0);
3468
Fam Zheng0db6e542015-04-17 19:49:50 -04003469 if (name && bdrv_find_dirty_bitmap(bs, name)) {
3470 error_setg(errp, "Bitmap already exists: %s", name);
3471 return NULL;
3472 }
John Snow5fba6c02015-04-17 19:49:51 -04003473 sector_granularity = granularity >> BDRV_SECTOR_BITS;
3474 assert(sector_granularity);
Markus Armbruster57322b72014-06-26 13:23:22 +02003475 bitmap_size = bdrv_nb_sectors(bs);
Fam Zhengb8afb522014-04-16 09:34:30 +08003476 if (bitmap_size < 0) {
3477 error_setg_errno(errp, -bitmap_size, "could not get length of device");
3478 errno = -bitmap_size;
3479 return NULL;
3480 }
Markus Armbruster5839e532014-08-19 10:31:08 +02003481 bitmap = g_new0(BdrvDirtyBitmap, 1);
John Snow5fba6c02015-04-17 19:49:51 -04003482 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
John Snowe74e6b72015-04-17 19:49:59 -04003483 bitmap->size = bitmap_size;
Fam Zheng0db6e542015-04-17 19:49:50 -04003484 bitmap->name = g_strdup(name);
John Snowb8e6fb72015-04-17 19:49:56 -04003485 bitmap->disabled = false;
Fam Zhenge4654d22013-11-13 18:29:43 +08003486 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3487 return bitmap;
3488}
3489
John Snow9bd2b082015-04-17 19:49:57 -04003490bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3491{
3492 return bitmap->successor;
3493}
3494
John Snowb8e6fb72015-04-17 19:49:56 -04003495bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3496{
John Snow9bd2b082015-04-17 19:49:57 -04003497 return !(bitmap->disabled || bitmap->successor);
3498}
3499
John Snow9abe3bd2015-05-12 15:53:01 -04003500DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3501{
3502 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3503 return DIRTY_BITMAP_STATUS_FROZEN;
3504 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3505 return DIRTY_BITMAP_STATUS_DISABLED;
3506 } else {
3507 return DIRTY_BITMAP_STATUS_ACTIVE;
3508 }
3509}
3510
John Snow9bd2b082015-04-17 19:49:57 -04003511/**
3512 * Create a successor bitmap destined to replace this bitmap after an operation.
3513 * Requires that the bitmap is not frozen and has no successor.
3514 */
3515int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3516 BdrvDirtyBitmap *bitmap, Error **errp)
3517{
3518 uint64_t granularity;
3519 BdrvDirtyBitmap *child;
3520
3521 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3522 error_setg(errp, "Cannot create a successor for a bitmap that is "
3523 "currently frozen");
3524 return -1;
3525 }
3526 assert(!bitmap->successor);
3527
3528 /* Create an anonymous successor */
3529 granularity = bdrv_dirty_bitmap_granularity(bitmap);
3530 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3531 if (!child) {
3532 return -1;
3533 }
3534
3535 /* Successor will be on or off based on our current state. */
3536 child->disabled = bitmap->disabled;
3537
3538 /* Install the successor and freeze the parent */
3539 bitmap->successor = child;
3540 return 0;
3541}
3542
3543/**
3544 * For a bitmap with a successor, yield our name to the successor,
3545 * delete the old bitmap, and return a handle to the new bitmap.
3546 */
3547BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3548 BdrvDirtyBitmap *bitmap,
3549 Error **errp)
3550{
3551 char *name;
3552 BdrvDirtyBitmap *successor = bitmap->successor;
3553
3554 if (successor == NULL) {
3555 error_setg(errp, "Cannot relinquish control if "
3556 "there's no successor present");
3557 return NULL;
3558 }
3559
3560 name = bitmap->name;
3561 bitmap->name = NULL;
3562 successor->name = name;
3563 bitmap->successor = NULL;
3564 bdrv_release_dirty_bitmap(bs, bitmap);
3565
3566 return successor;
3567}
3568
3569/**
3570 * In cases of failure where we can no longer safely delete the parent,
3571 * we may wish to re-join the parent and child/successor.
3572 * The merged parent will be un-frozen, but not explicitly re-enabled.
3573 */
3574BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3575 BdrvDirtyBitmap *parent,
3576 Error **errp)
3577{
3578 BdrvDirtyBitmap *successor = parent->successor;
3579
3580 if (!successor) {
3581 error_setg(errp, "Cannot reclaim a successor when none is present");
3582 return NULL;
3583 }
3584
3585 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3586 error_setg(errp, "Merging of parent and successor bitmap failed");
3587 return NULL;
3588 }
3589 bdrv_release_dirty_bitmap(bs, successor);
3590 parent->successor = NULL;
3591
3592 return parent;
John Snowb8e6fb72015-04-17 19:49:56 -04003593}
3594
John Snowce1ffea2015-04-17 19:50:03 -04003595/**
3596 * Truncates _all_ bitmaps attached to a BDS.
3597 */
3598static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3599{
3600 BdrvDirtyBitmap *bitmap;
3601 uint64_t size = bdrv_nb_sectors(bs);
3602
3603 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
John Snow06207b02015-06-10 13:24:54 -04003604 assert(!bdrv_dirty_bitmap_frozen(bitmap));
John Snowce1ffea2015-04-17 19:50:03 -04003605 hbitmap_truncate(bitmap->bitmap, size);
John Snow5270b6a2015-06-08 16:49:15 -04003606 bitmap->size = size;
John Snowce1ffea2015-04-17 19:50:03 -04003607 }
3608}
3609
Max Reitzc5acdc92016-01-29 16:36:01 +01003610static void bdrv_do_release_matching_dirty_bitmap(BlockDriverState *bs,
3611 BdrvDirtyBitmap *bitmap,
3612 bool only_named)
Fam Zhenge4654d22013-11-13 18:29:43 +08003613{
3614 BdrvDirtyBitmap *bm, *next;
3615 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
Max Reitzc5acdc92016-01-29 16:36:01 +01003616 if ((!bitmap || bm == bitmap) && (!only_named || bm->name)) {
John Snow9bd2b082015-04-17 19:49:57 -04003617 assert(!bdrv_dirty_bitmap_frozen(bm));
Max Reitzc5acdc92016-01-29 16:36:01 +01003618 QLIST_REMOVE(bm, list);
3619 hbitmap_free(bm->bitmap);
3620 g_free(bm->name);
3621 g_free(bm);
3622
3623 if (bitmap) {
3624 return;
3625 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003626 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003627 }
3628}
3629
Max Reitzc5acdc92016-01-29 16:36:01 +01003630void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3631{
3632 bdrv_do_release_matching_dirty_bitmap(bs, bitmap, false);
3633}
3634
3635/**
3636 * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
3637 * There must not be any frozen bitmaps attached.
3638 */
3639static void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
3640{
3641 bdrv_do_release_matching_dirty_bitmap(bs, NULL, true);
3642}
3643
John Snowb8e6fb72015-04-17 19:49:56 -04003644void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3645{
John Snow9bd2b082015-04-17 19:49:57 -04003646 assert(!bdrv_dirty_bitmap_frozen(bitmap));
John Snowb8e6fb72015-04-17 19:49:56 -04003647 bitmap->disabled = true;
3648}
3649
3650void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3651{
John Snow9bd2b082015-04-17 19:49:57 -04003652 assert(!bdrv_dirty_bitmap_frozen(bitmap));
John Snowb8e6fb72015-04-17 19:49:56 -04003653 bitmap->disabled = false;
3654}
3655
Fam Zheng21b56832013-11-13 18:29:44 +08003656BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3657{
3658 BdrvDirtyBitmap *bm;
3659 BlockDirtyInfoList *list = NULL;
3660 BlockDirtyInfoList **plist = &list;
3661
3662 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
Markus Armbruster5839e532014-08-19 10:31:08 +02003663 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3664 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
John Snow20dca812015-04-17 19:50:02 -04003665 info->count = bdrv_get_dirty_count(bm);
John Snow592fdd02015-04-17 19:49:53 -04003666 info->granularity = bdrv_dirty_bitmap_granularity(bm);
Fam Zheng0db6e542015-04-17 19:49:50 -04003667 info->has_name = !!bm->name;
3668 info->name = g_strdup(bm->name);
John Snow9abe3bd2015-05-12 15:53:01 -04003669 info->status = bdrv_dirty_bitmap_status(bm);
Fam Zheng21b56832013-11-13 18:29:44 +08003670 entry->value = info;
3671 *plist = entry;
3672 plist = &entry->next;
3673 }
3674
3675 return list;
3676}
3677
Fam Zhenge4654d22013-11-13 18:29:43 +08003678int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003679{
Fam Zhenge4654d22013-11-13 18:29:43 +08003680 if (bitmap) {
3681 return hbitmap_get(bitmap->bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02003682 } else {
3683 return 0;
3684 }
3685}
3686
John Snow341ebc22015-04-17 19:49:52 -04003687/**
3688 * Chooses a default granularity based on the existing cluster size,
3689 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3690 * is no cluster size information available.
3691 */
3692uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3693{
3694 BlockDriverInfo bdi;
3695 uint32_t granularity;
3696
3697 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3698 granularity = MAX(4096, bdi.cluster_size);
3699 granularity = MIN(65536, granularity);
3700 } else {
3701 granularity = 65536;
3702 }
3703
3704 return granularity;
3705}
3706
John Snow592fdd02015-04-17 19:49:53 -04003707uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3708{
3709 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3710}
3711
John Snow20dca812015-04-17 19:50:02 -04003712void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02003713{
Fam Zhenge4654d22013-11-13 18:29:43 +08003714 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02003715}
3716
John Snow20dca812015-04-17 19:50:02 -04003717void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
Vladimir Sementsov-Ogievskiyc4237df2014-11-27 12:40:46 +03003718 int64_t cur_sector, int nr_sectors)
3719{
John Snowb8e6fb72015-04-17 19:49:56 -04003720 assert(bdrv_dirty_bitmap_enabled(bitmap));
Vladimir Sementsov-Ogievskiyc4237df2014-11-27 12:40:46 +03003721 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3722}
3723
John Snow20dca812015-04-17 19:50:02 -04003724void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
Vladimir Sementsov-Ogievskiyc4237df2014-11-27 12:40:46 +03003725 int64_t cur_sector, int nr_sectors)
3726{
John Snowb8e6fb72015-04-17 19:49:56 -04003727 assert(bdrv_dirty_bitmap_enabled(bitmap));
Vladimir Sementsov-Ogievskiyc4237df2014-11-27 12:40:46 +03003728 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3729}
3730
Fam Zhengdf9a6812015-11-09 18:16:54 +08003731void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
John Snowe74e6b72015-04-17 19:49:59 -04003732{
3733 assert(bdrv_dirty_bitmap_enabled(bitmap));
Fam Zhengdf9a6812015-11-09 18:16:54 +08003734 if (!out) {
3735 hbitmap_reset_all(bitmap->bitmap);
3736 } else {
3737 HBitmap *backup = bitmap->bitmap;
3738 bitmap->bitmap = hbitmap_alloc(bitmap->size,
3739 hbitmap_granularity(backup));
3740 *out = backup;
3741 }
3742}
3743
3744void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in)
3745{
3746 HBitmap *tmp = bitmap->bitmap;
3747 assert(bdrv_dirty_bitmap_enabled(bitmap));
3748 bitmap->bitmap = in;
3749 hbitmap_free(tmp);
John Snowe74e6b72015-04-17 19:49:59 -04003750}
3751
Stefan Hajnoczie0c47b62015-04-28 14:27:50 +01003752void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3753 int nr_sectors)
Paolo Bonzini1755da12012-10-18 16:49:18 +02003754{
Fam Zhenge4654d22013-11-13 18:29:43 +08003755 BdrvDirtyBitmap *bitmap;
3756 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
John Snowb8e6fb72015-04-17 19:49:56 -04003757 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3758 continue;
3759 }
Fam Zhenge4654d22013-11-13 18:29:43 +08003760 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01003761 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02003762}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003763
John Snowd58d8452015-04-17 19:49:58 -04003764/**
3765 * Advance an HBitmapIter to an arbitrary offset.
3766 */
3767void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3768{
3769 assert(hbi->hb);
3770 hbitmap_iter_init(hbi, hbi->hb, offset);
3771}
3772
John Snow20dca812015-04-17 19:50:02 -04003773int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
Fam Zhenge4654d22013-11-13 18:29:43 +08003774{
3775 return hbitmap_count(bitmap->bitmap);
3776}
3777
Fam Zheng9fcb0252013-08-23 09:14:46 +08003778/* Get a reference to bs */
3779void bdrv_ref(BlockDriverState *bs)
3780{
3781 bs->refcnt++;
3782}
3783
3784/* Release a previously grabbed reference to bs.
3785 * If after releasing, reference count is zero, the BlockDriverState is
3786 * deleted. */
3787void bdrv_unref(BlockDriverState *bs)
3788{
Jeff Cody9a4d5ca2014-07-23 17:22:57 -04003789 if (!bs) {
3790 return;
3791 }
Fam Zheng9fcb0252013-08-23 09:14:46 +08003792 assert(bs->refcnt > 0);
3793 if (--bs->refcnt == 0) {
3794 bdrv_delete(bs);
3795 }
3796}
3797
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003798struct BdrvOpBlocker {
3799 Error *reason;
3800 QLIST_ENTRY(BdrvOpBlocker) list;
3801};
3802
3803bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3804{
3805 BdrvOpBlocker *blocker;
3806 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3807 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3808 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3809 if (errp) {
Markus Armbrustere43bfd92015-12-18 16:35:15 +01003810 *errp = error_copy(blocker->reason);
3811 error_prepend(errp, "Node '%s' is busy: ",
3812 bdrv_get_device_or_node_name(bs));
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003813 }
3814 return true;
3815 }
3816 return false;
3817}
3818
3819void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3820{
3821 BdrvOpBlocker *blocker;
3822 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3823
Markus Armbruster5839e532014-08-19 10:31:08 +02003824 blocker = g_new0(BdrvOpBlocker, 1);
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003825 blocker->reason = reason;
3826 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3827}
3828
3829void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3830{
3831 BdrvOpBlocker *blocker, *next;
3832 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3833 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3834 if (blocker->reason == reason) {
3835 QLIST_REMOVE(blocker, list);
3836 g_free(blocker);
3837 }
3838 }
3839}
3840
3841void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3842{
3843 int i;
3844 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3845 bdrv_op_block(bs, i, reason);
3846 }
3847}
3848
3849void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3850{
3851 int i;
3852 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3853 bdrv_op_unblock(bs, i, reason);
3854 }
3855}
3856
3857bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3858{
3859 int i;
3860
3861 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3862 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3863 return false;
3864 }
3865 }
3866 return true;
3867}
3868
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003869void bdrv_img_create(const char *filename, const char *fmt,
3870 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01003871 char *options, uint64_t img_size, int flags,
3872 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003873{
Chunyan Liu83d05212014-06-05 17:20:51 +08003874 QemuOptsList *create_opts = NULL;
3875 QemuOpts *opts = NULL;
3876 const char *backing_fmt, *backing_file;
3877 int64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003878 BlockDriver *drv, *proto_drv;
Max Reitzcc84d902013-09-06 17:14:26 +02003879 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003880 int ret = 0;
3881
3882 /* Find driver and parse its options */
3883 drv = bdrv_find_format(fmt);
3884 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003885 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003886 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003887 }
3888
Max Reitzb65a5e12015-02-05 13:58:12 -05003889 proto_drv = bdrv_find_protocol(filename, true, errp);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003890 if (!proto_drv) {
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003891 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003892 }
3893
Max Reitzc6149722014-12-02 18:32:45 +01003894 if (!drv->create_opts) {
3895 error_setg(errp, "Format driver '%s' does not support image creation",
3896 drv->format_name);
3897 return;
3898 }
3899
3900 if (!proto_drv->create_opts) {
3901 error_setg(errp, "Protocol driver '%s' does not support image creation",
3902 proto_drv->format_name);
3903 return;
3904 }
3905
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003906 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3907 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003908
3909 /* Create parameter list with default values */
Chunyan Liu83d05212014-06-05 17:20:51 +08003910 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
Markus Armbruster39101f22015-02-12 16:46:36 +01003911 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003912
3913 /* Parse -o options */
3914 if (options) {
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01003915 qemu_opts_do_parse(opts, options, NULL, &local_err);
3916 if (local_err) {
3917 error_report_err(local_err);
3918 local_err = NULL;
Chunyan Liu83d05212014-06-05 17:20:51 +08003919 error_setg(errp, "Invalid options for file format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003920 goto out;
3921 }
3922 }
3923
3924 if (base_filename) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01003925 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
Markus Armbruster6be41942015-02-12 17:49:02 +01003926 if (local_err) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003927 error_setg(errp, "Backing file not supported for file format '%s'",
3928 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003929 goto out;
3930 }
3931 }
3932
3933 if (base_fmt) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01003934 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
Markus Armbruster6be41942015-02-12 17:49:02 +01003935 if (local_err) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003936 error_setg(errp, "Backing file format not supported for file "
3937 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003938 goto out;
3939 }
3940 }
3941
Chunyan Liu83d05212014-06-05 17:20:51 +08003942 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3943 if (backing_file) {
3944 if (!strcmp(filename, backing_file)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003945 error_setg(errp, "Error: Trying to create an image with the "
3946 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01003947 goto out;
3948 }
3949 }
3950
Chunyan Liu83d05212014-06-05 17:20:51 +08003951 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003952
3953 // The size for the image must always be specified, with one exception:
3954 // If we are using a backing file, we can obtain the size from there
Chunyan Liu83d05212014-06-05 17:20:51 +08003955 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3956 if (size == -1) {
3957 if (backing_file) {
Max Reitz66f6b812013-12-03 14:57:52 +01003958 BlockDriverState *bs;
Max Reitz29168012014-11-26 17:20:27 +01003959 char *full_backing = g_new0(char, PATH_MAX);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02003960 int64_t size;
Paolo Bonzini63090da2012-04-12 14:01:03 +02003961 int back_flags;
Max Reitze6641712015-08-26 19:47:48 +02003962 QDict *backing_options = NULL;
Paolo Bonzini63090da2012-04-12 14:01:03 +02003963
Max Reitz29168012014-11-26 17:20:27 +01003964 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3965 full_backing, PATH_MAX,
3966 &local_err);
3967 if (local_err) {
3968 g_free(full_backing);
3969 goto out;
3970 }
3971
Paolo Bonzini63090da2012-04-12 14:01:03 +02003972 /* backing files always opened read-only */
3973 back_flags =
3974 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003975
Max Reitze6641712015-08-26 19:47:48 +02003976 if (backing_fmt) {
3977 backing_options = qdict_new();
3978 qdict_put(backing_options, "driver",
3979 qstring_from_str(backing_fmt));
3980 }
3981
Max Reitzf67503e2014-02-18 18:33:05 +01003982 bs = NULL;
Max Reitze6641712015-08-26 19:47:48 +02003983 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
Max Reitz6ebf9aa2015-08-26 19:47:49 +02003984 back_flags, &local_err);
Max Reitz29168012014-11-26 17:20:27 +01003985 g_free(full_backing);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003986 if (ret < 0) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003987 goto out;
3988 }
Markus Armbruster52bf1e72014-06-26 13:23:25 +02003989 size = bdrv_getlength(bs);
3990 if (size < 0) {
3991 error_setg_errno(errp, -size, "Could not get size of '%s'",
3992 backing_file);
3993 bdrv_unref(bs);
3994 goto out;
3995 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003996
Markus Armbruster39101f22015-02-12 16:46:36 +01003997 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
Max Reitz66f6b812013-12-03 14:57:52 +01003998
3999 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004000 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004001 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004002 goto out;
4003 }
4004 }
4005
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01004006 if (!quiet) {
Kővágó, Zoltánfe646692015-07-07 16:42:10 +02004007 printf("Formatting '%s', fmt=%s ", filename, fmt);
Fam Zheng43c5d8f2014-12-09 15:38:04 +08004008 qemu_opts_print(opts, " ");
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01004009 puts("");
4010 }
Chunyan Liu83d05212014-06-05 17:20:51 +08004011
Chunyan Liuc282e1f2014-06-05 17:21:11 +08004012 ret = bdrv_create(drv, filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08004013
Max Reitzcc84d902013-09-06 17:14:26 +02004014 if (ret == -EFBIG) {
4015 /* This is generally a better message than whatever the driver would
4016 * deliver (especially because of the cluster_size_hint), since that
4017 * is most probably not much different from "image too large". */
4018 const char *cluster_size_hint = "";
Chunyan Liu83d05212014-06-05 17:20:51 +08004019 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
Max Reitzcc84d902013-09-06 17:14:26 +02004020 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004021 }
Max Reitzcc84d902013-09-06 17:14:26 +02004022 error_setg(errp, "The image size is too large for file format '%s'"
4023 "%s", fmt, cluster_size_hint);
4024 error_free(local_err);
4025 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004026 }
4027
4028out:
Chunyan Liu83d05212014-06-05 17:20:51 +08004029 qemu_opts_del(opts);
4030 qemu_opts_free(create_opts);
Markus Armbruster84d18f02014-01-30 15:07:28 +01004031 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +02004032 error_propagate(errp, local_err);
4033 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004034}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01004035
4036AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4037{
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004038 return bs->aio_context;
4039}
4040
4041void bdrv_detach_aio_context(BlockDriverState *bs)
4042{
Max Reitz33384422014-06-20 21:57:33 +02004043 BdrvAioNotifier *baf;
4044
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004045 if (!bs->drv) {
4046 return;
4047 }
4048
Max Reitz33384422014-06-20 21:57:33 +02004049 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
4050 baf->detach_aio_context(baf->opaque);
4051 }
4052
Alberto Garciaa0d64a62015-11-04 15:15:36 +02004053 if (bs->throttle_state) {
Benoît Canet0e5b0a22015-06-08 18:17:41 +02004054 throttle_timers_detach_aio_context(&bs->throttle_timers);
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02004055 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004056 if (bs->drv->bdrv_detach_aio_context) {
4057 bs->drv->bdrv_detach_aio_context(bs);
4058 }
4059 if (bs->file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02004060 bdrv_detach_aio_context(bs->file->bs);
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004061 }
Kevin Wolf760e0062015-06-17 14:55:21 +02004062 if (bs->backing) {
4063 bdrv_detach_aio_context(bs->backing->bs);
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004064 }
4065
4066 bs->aio_context = NULL;
4067}
4068
4069void bdrv_attach_aio_context(BlockDriverState *bs,
4070 AioContext *new_context)
4071{
Max Reitz33384422014-06-20 21:57:33 +02004072 BdrvAioNotifier *ban;
4073
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004074 if (!bs->drv) {
4075 return;
4076 }
4077
4078 bs->aio_context = new_context;
4079
Kevin Wolf760e0062015-06-17 14:55:21 +02004080 if (bs->backing) {
4081 bdrv_attach_aio_context(bs->backing->bs, new_context);
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004082 }
4083 if (bs->file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02004084 bdrv_attach_aio_context(bs->file->bs, new_context);
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004085 }
4086 if (bs->drv->bdrv_attach_aio_context) {
4087 bs->drv->bdrv_attach_aio_context(bs, new_context);
4088 }
Alberto Garciaa0d64a62015-11-04 15:15:36 +02004089 if (bs->throttle_state) {
Benoît Canet0e5b0a22015-06-08 18:17:41 +02004090 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02004091 }
Max Reitz33384422014-06-20 21:57:33 +02004092
4093 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
4094 ban->attached_aio_context(new_context, ban->opaque);
4095 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004096}
4097
4098void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
4099{
Fam Zheng53ec73e2015-05-29 18:53:14 +08004100 bdrv_drain(bs); /* ensure there are no in-flight requests */
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02004101
4102 bdrv_detach_aio_context(bs);
4103
4104 /* This function executes in the old AioContext so acquire the new one in
4105 * case it runs in a different thread.
4106 */
4107 aio_context_acquire(new_context);
4108 bdrv_attach_aio_context(bs, new_context);
4109 aio_context_release(new_context);
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01004110}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02004111
Max Reitz33384422014-06-20 21:57:33 +02004112void bdrv_add_aio_context_notifier(BlockDriverState *bs,
4113 void (*attached_aio_context)(AioContext *new_context, void *opaque),
4114 void (*detach_aio_context)(void *opaque), void *opaque)
4115{
4116 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
4117 *ban = (BdrvAioNotifier){
4118 .attached_aio_context = attached_aio_context,
4119 .detach_aio_context = detach_aio_context,
4120 .opaque = opaque
4121 };
4122
4123 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
4124}
4125
4126void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
4127 void (*attached_aio_context)(AioContext *,
4128 void *),
4129 void (*detach_aio_context)(void *),
4130 void *opaque)
4131{
4132 BdrvAioNotifier *ban, *ban_next;
4133
4134 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4135 if (ban->attached_aio_context == attached_aio_context &&
4136 ban->detach_aio_context == detach_aio_context &&
4137 ban->opaque == opaque)
4138 {
4139 QLIST_REMOVE(ban, list);
4140 g_free(ban);
4141
4142 return;
4143 }
4144 }
4145
4146 abort();
4147}
4148
Max Reitz77485432014-10-27 11:12:50 +01004149int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
Max Reitz8b139762015-07-27 17:51:32 +02004150 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
Max Reitz6f176b42013-09-03 10:09:50 +02004151{
Chunyan Liuc282e1f2014-06-05 17:21:11 +08004152 if (!bs->drv->bdrv_amend_options) {
Max Reitz6f176b42013-09-03 10:09:50 +02004153 return -ENOTSUP;
4154 }
Max Reitz8b139762015-07-27 17:51:32 +02004155 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
Max Reitz6f176b42013-09-03 10:09:50 +02004156}
Benoît Canetf6186f42013-10-02 14:33:48 +02004157
Benoît Canetb5042a32014-03-03 19:11:34 +01004158/* This function will be called by the bdrv_recurse_is_first_non_filter method
4159 * of block filter and by bdrv_is_first_non_filter.
4160 * It is used to test if the given bs is the candidate or recurse more in the
4161 * node graph.
Benoît Canet212a5a82014-01-23 21:31:36 +01004162 */
Benoît Canet212a5a82014-01-23 21:31:36 +01004163bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
4164 BlockDriverState *candidate)
Benoît Canetf6186f42013-10-02 14:33:48 +02004165{
Benoît Canetb5042a32014-03-03 19:11:34 +01004166 /* return false if basic checks fails */
4167 if (!bs || !bs->drv) {
4168 return false;
4169 }
4170
4171 /* the code reached a non block filter driver -> check if the bs is
4172 * the same as the candidate. It's the recursion termination condition.
4173 */
4174 if (!bs->drv->is_filter) {
4175 return bs == candidate;
4176 }
4177 /* Down this path the driver is a block filter driver */
4178
4179 /* If the block filter recursion method is defined use it to recurse down
4180 * the node graph.
4181 */
4182 if (bs->drv->bdrv_recurse_is_first_non_filter) {
Benoît Canet212a5a82014-01-23 21:31:36 +01004183 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4184 }
4185
Benoît Canetb5042a32014-03-03 19:11:34 +01004186 /* the driver is a block filter but don't allow to recurse -> return false
4187 */
4188 return false;
Benoît Canet212a5a82014-01-23 21:31:36 +01004189}
4190
4191/* This function checks if the candidate is the first non filter bs down it's
4192 * bs chain. Since we don't have pointers to parents it explore all bs chains
4193 * from the top. Some filters can choose not to pass down the recursion.
4194 */
4195bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4196{
4197 BlockDriverState *bs;
4198
4199 /* walk down the bs forest recursively */
4200 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4201 bool perm;
4202
Benoît Canetb5042a32014-03-03 19:11:34 +01004203 /* try to recurse in this top level bs */
Kevin Wolfe6dc8a12014-02-04 11:45:31 +01004204 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
Benoît Canet212a5a82014-01-23 21:31:36 +01004205
4206 /* candidate is the first non filter */
4207 if (perm) {
4208 return true;
4209 }
4210 }
4211
4212 return false;
Benoît Canetf6186f42013-10-02 14:33:48 +02004213}
Benoît Canet09158f02014-06-27 18:25:25 +02004214
Wen Congyange12f3782015-07-17 10:12:22 +08004215BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
4216 const char *node_name, Error **errp)
Benoît Canet09158f02014-06-27 18:25:25 +02004217{
4218 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004219 AioContext *aio_context;
4220
Benoît Canet09158f02014-06-27 18:25:25 +02004221 if (!to_replace_bs) {
4222 error_setg(errp, "Node name '%s' not found", node_name);
4223 return NULL;
4224 }
4225
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004226 aio_context = bdrv_get_aio_context(to_replace_bs);
4227 aio_context_acquire(aio_context);
4228
Benoît Canet09158f02014-06-27 18:25:25 +02004229 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004230 to_replace_bs = NULL;
4231 goto out;
Benoît Canet09158f02014-06-27 18:25:25 +02004232 }
4233
4234 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4235 * most non filter in order to prevent data corruption.
4236 * Another benefit is that this tests exclude backing files which are
4237 * blocked by the backing blockers.
4238 */
Wen Congyange12f3782015-07-17 10:12:22 +08004239 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
Benoît Canet09158f02014-06-27 18:25:25 +02004240 error_setg(errp, "Only top most non filter can be replaced");
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004241 to_replace_bs = NULL;
4242 goto out;
Benoît Canet09158f02014-06-27 18:25:25 +02004243 }
4244
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01004245out:
4246 aio_context_release(aio_context);
Benoît Canet09158f02014-06-27 18:25:25 +02004247 return to_replace_bs;
4248}
Ming Lei448ad912014-07-04 18:04:33 +08004249
Max Reitz91af7012014-07-18 20:24:56 +02004250static bool append_open_options(QDict *d, BlockDriverState *bs)
4251{
4252 const QDictEntry *entry;
Kevin Wolf9e700c12015-04-24 15:20:28 +02004253 QemuOptDesc *desc;
Kevin Wolf260fecf2015-04-27 13:46:22 +02004254 BdrvChild *child;
Max Reitz91af7012014-07-18 20:24:56 +02004255 bool found_any = false;
Kevin Wolf260fecf2015-04-27 13:46:22 +02004256 const char *p;
Max Reitz91af7012014-07-18 20:24:56 +02004257
4258 for (entry = qdict_first(bs->options); entry;
4259 entry = qdict_next(bs->options, entry))
4260 {
Kevin Wolf260fecf2015-04-27 13:46:22 +02004261 /* Exclude options for children */
4262 QLIST_FOREACH(child, &bs->children, next) {
4263 if (strstart(qdict_entry_key(entry), child->name, &p)
4264 && (!*p || *p == '.'))
4265 {
4266 break;
4267 }
4268 }
4269 if (child) {
Kevin Wolf9e700c12015-04-24 15:20:28 +02004270 continue;
Max Reitz91af7012014-07-18 20:24:56 +02004271 }
Kevin Wolf9e700c12015-04-24 15:20:28 +02004272
4273 /* And exclude all non-driver-specific options */
4274 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
4275 if (!strcmp(qdict_entry_key(entry), desc->name)) {
4276 break;
4277 }
4278 }
4279 if (desc->name) {
4280 continue;
4281 }
4282
4283 qobject_incref(qdict_entry_value(entry));
4284 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4285 found_any = true;
Max Reitz91af7012014-07-18 20:24:56 +02004286 }
4287
4288 return found_any;
4289}
4290
4291/* Updates the following BDS fields:
4292 * - exact_filename: A filename which may be used for opening a block device
4293 * which (mostly) equals the given BDS (even without any
4294 * other options; so reading and writing must return the same
4295 * results, but caching etc. may be different)
4296 * - full_open_options: Options which, when given when opening a block device
4297 * (without a filename), result in a BDS (mostly)
4298 * equalling the given one
4299 * - filename: If exact_filename is set, it is copied here. Otherwise,
4300 * full_open_options is converted to a JSON object, prefixed with
4301 * "json:" (for use through the JSON pseudo protocol) and put here.
4302 */
4303void bdrv_refresh_filename(BlockDriverState *bs)
4304{
4305 BlockDriver *drv = bs->drv;
4306 QDict *opts;
4307
4308 if (!drv) {
4309 return;
4310 }
4311
4312 /* This BDS's file name will most probably depend on its file's name, so
4313 * refresh that first */
4314 if (bs->file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02004315 bdrv_refresh_filename(bs->file->bs);
Max Reitz91af7012014-07-18 20:24:56 +02004316 }
4317
4318 if (drv->bdrv_refresh_filename) {
4319 /* Obsolete information is of no use here, so drop the old file name
4320 * information before refreshing it */
4321 bs->exact_filename[0] = '\0';
4322 if (bs->full_open_options) {
4323 QDECREF(bs->full_open_options);
4324 bs->full_open_options = NULL;
4325 }
4326
Kevin Wolf4cdd01d2015-04-27 13:50:54 +02004327 opts = qdict_new();
4328 append_open_options(opts, bs);
4329 drv->bdrv_refresh_filename(bs, opts);
4330 QDECREF(opts);
Max Reitz91af7012014-07-18 20:24:56 +02004331 } else if (bs->file) {
4332 /* Try to reconstruct valid information from the underlying file */
4333 bool has_open_options;
4334
4335 bs->exact_filename[0] = '\0';
4336 if (bs->full_open_options) {
4337 QDECREF(bs->full_open_options);
4338 bs->full_open_options = NULL;
4339 }
4340
4341 opts = qdict_new();
4342 has_open_options = append_open_options(opts, bs);
4343
4344 /* If no specific options have been given for this BDS, the filename of
4345 * the underlying file should suffice for this one as well */
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02004346 if (bs->file->bs->exact_filename[0] && !has_open_options) {
4347 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
Max Reitz91af7012014-07-18 20:24:56 +02004348 }
4349 /* Reconstructing the full options QDict is simple for most format block
4350 * drivers, as long as the full options are known for the underlying
4351 * file BDS. The full options QDict of that file BDS should somehow
4352 * contain a representation of the filename, therefore the following
4353 * suffices without querying the (exact_)filename of this BDS. */
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02004354 if (bs->file->bs->full_open_options) {
Max Reitz91af7012014-07-18 20:24:56 +02004355 qdict_put_obj(opts, "driver",
4356 QOBJECT(qstring_from_str(drv->format_name)));
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02004357 QINCREF(bs->file->bs->full_open_options);
4358 qdict_put_obj(opts, "file",
4359 QOBJECT(bs->file->bs->full_open_options));
Max Reitz91af7012014-07-18 20:24:56 +02004360
4361 bs->full_open_options = opts;
4362 } else {
4363 QDECREF(opts);
4364 }
4365 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4366 /* There is no underlying file BDS (at least referenced by BDS.file),
4367 * so the full options QDict should be equal to the options given
4368 * specifically for this block device when it was opened (plus the
4369 * driver specification).
4370 * Because those options don't change, there is no need to update
4371 * full_open_options when it's already set. */
4372
4373 opts = qdict_new();
4374 append_open_options(opts, bs);
4375 qdict_put_obj(opts, "driver",
4376 QOBJECT(qstring_from_str(drv->format_name)));
4377
4378 if (bs->exact_filename[0]) {
4379 /* This may not work for all block protocol drivers (some may
4380 * require this filename to be parsed), but we have to find some
4381 * default solution here, so just include it. If some block driver
4382 * does not support pure options without any filename at all or
4383 * needs some special format of the options QDict, it needs to
4384 * implement the driver-specific bdrv_refresh_filename() function.
4385 */
4386 qdict_put_obj(opts, "filename",
4387 QOBJECT(qstring_from_str(bs->exact_filename)));
4388 }
4389
4390 bs->full_open_options = opts;
4391 }
4392
4393 if (bs->exact_filename[0]) {
4394 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4395 } else if (bs->full_open_options) {
4396 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4397 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4398 qstring_get_str(json));
4399 QDECREF(json);
4400 }
4401}