blob: 79a5a2770f717842d9579c80f42c1bc4da4c420b [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 */
Markus Armbrustere688df62018-02-01 12:18:31 +010024
Peter Maydelld38ea872016-01-29 17:50:05 +000025#include "qemu/osdep.h"
Daniel P. Berrange0ab8ed12017-01-25 16:14:15 +000026#include "block/trace.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010027#include "block/block_int.h"
28#include "block/blockjob.h"
Kevin Wolfcd7fca92016-07-06 11:22:39 +020029#include "block/nbd.h"
Max Reitz609f45e2018-06-14 21:14:28 +020030#include "block/qdict.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010031#include "qemu/error-report.h"
Marc Mari88d88792016-08-12 09:27:03 -040032#include "module_block.h"
Markus Armbrusterdb725812019-08-12 07:23:50 +020033#include "qemu/main-loop.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010034#include "qemu/module.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010035#include "qapi/error.h"
Markus Armbruster452fcdb2018-02-01 12:18:39 +010036#include "qapi/qmp/qdict.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010037#include "qapi/qmp/qjson.h"
Max Reitze59a0cf2018-02-24 16:40:32 +010038#include "qapi/qmp/qnull.h"
Markus Armbrusterfc81fa12018-02-01 12:18:40 +010039#include "qapi/qmp/qstring.h"
Kevin Wolfe1d74bc2018-01-10 15:52:33 +010040#include "qapi/qobject-output-visitor.h"
41#include "qapi/qapi-visit-block-core.h"
Markus Armbrusterbfb197e2014-10-07 13:59:11 +020042#include "sysemu/block-backend.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010043#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010044#include "qemu/notify.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010045#include "qemu/option.h"
Daniel P. Berrange10817bf2015-09-01 14:48:02 +010046#include "qemu/coroutine.h"
Benoît Canetc13163f2014-01-23 21:31:34 +010047#include "block/qapi.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010048#include "qemu/timer.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020049#include "qemu/cutils.h"
50#include "qemu/id.h"
bellardfc01f7e2003-06-30 10:03:06 +000051
Juan Quintela71e72a12009-07-27 16:12:56 +020052#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000053#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000054#include <sys/queue.h>
blueswir1c5e97232009-03-07 20:06:23 +000055#ifndef __DragonFly__
bellard7674e7b2005-04-26 21:59:26 +000056#include <sys/disk.h>
57#endif
blueswir1c5e97232009-03-07 20:06:23 +000058#endif
bellard7674e7b2005-04-26 21:59:26 +000059
aliguori49dc7682009-03-08 16:26:59 +000060#ifdef _WIN32
61#include <windows.h>
62#endif
63
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010064#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
65
Benoît Canetdc364f42014-01-23 21:31:32 +010066static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
67 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
68
Max Reitz2c1d04e2016-01-29 16:36:11 +010069static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
70 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
71
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010072static QLIST_HEAD(, BlockDriver) bdrv_drivers =
73 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +000074
Max Reitz5b363932016-05-17 16:41:31 +020075static BlockDriverState *bdrv_open_inherit(const char *filename,
76 const char *reference,
77 QDict *options, int flags,
78 BlockDriverState *parent,
79 const BdrvChildRole *child_role,
80 Error **errp);
Kevin Wolff3930ed2015-04-08 13:43:47 +020081
Markus Armbrustereb852012009-10-27 18:41:44 +010082/* If non-zero, use only whitelisted block drivers */
83static int use_bdrv_whitelist;
84
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +000085#ifdef _WIN32
86static int is_windows_drive_prefix(const char *filename)
87{
88 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
89 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
90 filename[1] == ':');
91}
92
93int is_windows_drive(const char *filename)
94{
95 if (is_windows_drive_prefix(filename) &&
96 filename[2] == '\0')
97 return 1;
98 if (strstart(filename, "\\\\.\\", NULL) ||
99 strstart(filename, "//./", NULL))
100 return 1;
101 return 0;
102}
103#endif
104
Kevin Wolf339064d2013-11-28 10:23:32 +0100105size_t bdrv_opt_mem_align(BlockDriverState *bs)
106{
107 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300108 /* page size or 4k (hdd sector size) should be on the safe side */
Wei Yang038adc22019-10-13 10:11:45 +0800109 return MAX(4096, qemu_real_host_page_size);
Kevin Wolf339064d2013-11-28 10:23:32 +0100110 }
111
112 return bs->bl.opt_mem_alignment;
113}
114
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300115size_t bdrv_min_mem_align(BlockDriverState *bs)
116{
117 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300118 /* page size or 4k (hdd sector size) should be on the safe side */
Wei Yang038adc22019-10-13 10:11:45 +0800119 return MAX(4096, qemu_real_host_page_size);
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300120 }
121
122 return bs->bl.min_mem_alignment;
123}
124
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000125/* check if the path starts with "<protocol>:" */
Max Reitz5c984152014-12-03 14:57:22 +0100126int path_has_protocol(const char *path)
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000127{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200128 const char *p;
129
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000130#ifdef _WIN32
131 if (is_windows_drive(path) ||
132 is_windows_drive_prefix(path)) {
133 return 0;
134 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200135 p = path + strcspn(path, ":/\\");
136#else
137 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000138#endif
139
Paolo Bonzini947995c2012-05-08 16:51:48 +0200140 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000141}
142
bellard83f64092006-08-01 16:21:11 +0000143int path_is_absolute(const char *path)
144{
bellard21664422007-01-07 18:22:37 +0000145#ifdef _WIN32
146 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200147 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000148 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200149 }
150 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000151#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200152 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000153#endif
bellard83f64092006-08-01 16:21:11 +0000154}
155
Max Reitz009b03a2019-02-01 20:29:13 +0100156/* if filename is absolute, just return its duplicate. Otherwise, build a
bellard83f64092006-08-01 16:21:11 +0000157 path to it by considering it is relative to base_path. URL are
158 supported. */
Max Reitz009b03a2019-02-01 20:29:13 +0100159char *path_combine(const char *base_path, const char *filename)
bellard83f64092006-08-01 16:21:11 +0000160{
Max Reitz009b03a2019-02-01 20:29:13 +0100161 const char *protocol_stripped = NULL;
bellard83f64092006-08-01 16:21:11 +0000162 const char *p, *p1;
Max Reitz009b03a2019-02-01 20:29:13 +0100163 char *result;
bellard83f64092006-08-01 16:21:11 +0000164 int len;
165
bellard83f64092006-08-01 16:21:11 +0000166 if (path_is_absolute(filename)) {
Max Reitz009b03a2019-02-01 20:29:13 +0100167 return g_strdup(filename);
bellard83f64092006-08-01 16:21:11 +0000168 }
Max Reitz009b03a2019-02-01 20:29:13 +0100169
170 if (path_has_protocol(base_path)) {
171 protocol_stripped = strchr(base_path, ':');
172 if (protocol_stripped) {
173 protocol_stripped++;
174 }
175 }
176 p = protocol_stripped ?: base_path;
177
178 p1 = strrchr(base_path, '/');
179#ifdef _WIN32
180 {
181 const char *p2;
182 p2 = strrchr(base_path, '\\');
183 if (!p1 || p2 > p1) {
184 p1 = p2;
185 }
186 }
187#endif
188 if (p1) {
189 p1++;
190 } else {
191 p1 = base_path;
192 }
193 if (p1 > p) {
194 p = p1;
195 }
196 len = p - base_path;
197
198 result = g_malloc(len + strlen(filename) + 1);
199 memcpy(result, base_path, len);
200 strcpy(result + len, filename);
201
202 return result;
203}
204
Max Reitz03c320d2017-05-22 21:52:16 +0200205/*
206 * Helper function for bdrv_parse_filename() implementations to remove optional
207 * protocol prefixes (especially "file:") from a filename and for putting the
208 * stripped filename into the options QDict if there is such a prefix.
209 */
210void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix,
211 QDict *options)
212{
213 if (strstart(filename, prefix, &filename)) {
214 /* Stripping the explicit protocol prefix may result in a protocol
215 * prefix being (wrongly) detected (if the filename contains a colon) */
216 if (path_has_protocol(filename)) {
217 QString *fat_filename;
218
219 /* This means there is some colon before the first slash; therefore,
220 * this cannot be an absolute path */
221 assert(!path_is_absolute(filename));
222
223 /* And we can thus fix the protocol detection issue by prefixing it
224 * by "./" */
225 fat_filename = qstring_from_str("./");
226 qstring_append(fat_filename, filename);
227
228 assert(!path_has_protocol(qstring_get_str(fat_filename)));
229
230 qdict_put(options, "filename", fat_filename);
231 } else {
232 /* If no protocol prefix was detected, we can use the shortened
233 * filename as-is */
234 qdict_put_str(options, "filename", filename);
235 }
236 }
237}
238
239
Kevin Wolf9c5e6592017-05-04 18:52:40 +0200240/* Returns whether the image file is opened as read-only. Note that this can
241 * return false and writing to the image file is still not possible because the
242 * image is inactivated. */
Jeff Cody93ed5242017-04-07 16:55:28 -0400243bool bdrv_is_read_only(BlockDriverState *bs)
244{
245 return bs->read_only;
246}
247
Kevin Wolf54a32bf2017-08-03 17:02:58 +0200248int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
249 bool ignore_allow_rdw, Error **errp)
Jeff Codyfe5241b2017-04-07 16:55:25 -0400250{
Jeff Codye2b82472017-04-07 16:55:26 -0400251 /* Do not set read_only if copy_on_read is enabled */
252 if (bs->copy_on_read && read_only) {
253 error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
254 bdrv_get_device_or_node_name(bs));
255 return -EINVAL;
256 }
257
Jeff Codyd6fcdf02017-04-07 16:55:27 -0400258 /* Do not clear read_only if it is prohibited */
Kevin Wolf54a32bf2017-08-03 17:02:58 +0200259 if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&
260 !ignore_allow_rdw)
261 {
Jeff Codyd6fcdf02017-04-07 16:55:27 -0400262 error_setg(errp, "Node '%s' is read only",
263 bdrv_get_device_or_node_name(bs));
264 return -EPERM;
265 }
266
Jeff Cody45803a02017-04-07 16:55:29 -0400267 return 0;
268}
269
Kevin Wolfeaa24102018-10-12 11:27:41 +0200270/*
271 * Called by a driver that can only provide a read-only image.
272 *
273 * Returns 0 if the node is already read-only or it could switch the node to
274 * read-only because BDRV_O_AUTO_RDONLY is set.
275 *
276 * Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set
277 * or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg
278 * is not NULL, it is used as the error message for the Error object.
279 */
280int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
281 Error **errp)
Jeff Cody45803a02017-04-07 16:55:29 -0400282{
283 int ret = 0;
284
Kevin Wolfeaa24102018-10-12 11:27:41 +0200285 if (!(bs->open_flags & BDRV_O_RDWR)) {
286 return 0;
287 }
288 if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) {
289 goto fail;
290 }
291
292 ret = bdrv_can_set_read_only(bs, true, false, NULL);
Jeff Cody45803a02017-04-07 16:55:29 -0400293 if (ret < 0) {
Kevin Wolfeaa24102018-10-12 11:27:41 +0200294 goto fail;
Jeff Cody45803a02017-04-07 16:55:29 -0400295 }
296
Kevin Wolfeaa24102018-10-12 11:27:41 +0200297 bs->read_only = true;
298 bs->open_flags &= ~BDRV_O_RDWR;
Kevin Wolfeeae6a52018-10-09 16:57:12 +0200299
Jeff Codye2b82472017-04-07 16:55:26 -0400300 return 0;
Kevin Wolfeaa24102018-10-12 11:27:41 +0200301
302fail:
303 error_setg(errp, "%s", errmsg ?: "Image is read-only");
304 return -EACCES;
Jeff Codyfe5241b2017-04-07 16:55:25 -0400305}
306
Max Reitz645ae7d2019-02-01 20:29:14 +0100307/*
308 * If @backing is empty, this function returns NULL without setting
309 * @errp. In all other cases, NULL will only be returned with @errp
310 * set.
311 *
312 * Therefore, a return value of NULL without @errp set means that
313 * there is no backing file; if @errp is set, there is one but its
314 * absolute filename cannot be generated.
315 */
316char *bdrv_get_full_backing_filename_from_filename(const char *backed,
317 const char *backing,
318 Error **errp)
Max Reitz0a828552014-11-26 17:20:25 +0100319{
Max Reitz645ae7d2019-02-01 20:29:14 +0100320 if (backing[0] == '\0') {
321 return NULL;
322 } else if (path_has_protocol(backing) || path_is_absolute(backing)) {
323 return g_strdup(backing);
Max Reitz9f074292014-11-26 17:20:26 +0100324 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
325 error_setg(errp, "Cannot use relative backing file names for '%s'",
326 backed);
Max Reitz645ae7d2019-02-01 20:29:14 +0100327 return NULL;
Max Reitz0a828552014-11-26 17:20:25 +0100328 } else {
Max Reitz645ae7d2019-02-01 20:29:14 +0100329 return path_combine(backed, backing);
Max Reitz0a828552014-11-26 17:20:25 +0100330 }
331}
332
Max Reitz9f4793d2019-02-01 20:29:16 +0100333/*
334 * If @filename is empty or NULL, this function returns NULL without
335 * setting @errp. In all other cases, NULL will only be returned with
336 * @errp set.
337 */
338static char *bdrv_make_absolute_filename(BlockDriverState *relative_to,
339 const char *filename, Error **errp)
340{
Max Reitz8df68612019-02-01 20:29:23 +0100341 char *dir, *full_name;
Max Reitz9f4793d2019-02-01 20:29:16 +0100342
Max Reitz8df68612019-02-01 20:29:23 +0100343 if (!filename || filename[0] == '\0') {
344 return NULL;
345 } else if (path_has_protocol(filename) || path_is_absolute(filename)) {
346 return g_strdup(filename);
347 }
Max Reitz9f4793d2019-02-01 20:29:16 +0100348
Max Reitz8df68612019-02-01 20:29:23 +0100349 dir = bdrv_dirname(relative_to, errp);
350 if (!dir) {
351 return NULL;
352 }
Max Reitz9f4793d2019-02-01 20:29:16 +0100353
Max Reitz8df68612019-02-01 20:29:23 +0100354 full_name = g_strconcat(dir, filename, NULL);
355 g_free(dir);
356 return full_name;
Max Reitz9f4793d2019-02-01 20:29:16 +0100357}
358
Max Reitz6b6833c2019-02-01 20:29:15 +0100359char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp)
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200360{
Max Reitz9f4793d2019-02-01 20:29:16 +0100361 return bdrv_make_absolute_filename(bs, bs->backing_file, errp);
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200362}
363
Stefan Hajnoczi0eb72172015-04-28 14:27:51 +0100364void bdrv_register(BlockDriver *bdrv)
365{
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100366 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000367}
bellardb3380822004-03-14 21:38:54 +0000368
Markus Armbrustere4e99862014-10-07 13:59:03 +0200369BlockDriverState *bdrv_new(void)
370{
371 BlockDriverState *bs;
372 int i;
373
Markus Armbruster5839e532014-08-19 10:31:08 +0200374 bs = g_new0(BlockDriverState, 1);
Fam Zhenge4654d22013-11-13 18:29:43 +0800375 QLIST_INIT(&bs->dirty_bitmaps);
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800376 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
377 QLIST_INIT(&bs->op_blockers[i]);
378 }
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200379 notifier_with_return_list_init(&bs->before_write_notifiers);
Paolo Bonzini3783fa32017-06-05 14:39:02 +0200380 qemu_co_mutex_init(&bs->reqs_lock);
Paolo Bonzini21198822017-06-05 14:39:03 +0200381 qemu_mutex_init(&bs->dirty_bitmap_mutex);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800382 bs->refcnt = 1;
Stefan Hajnoczidcd04222014-05-08 16:34:37 +0200383 bs->aio_context = qemu_get_aio_context();
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200384
Evgeny Yakovlev3ff2f672016-07-18 22:39:52 +0300385 qemu_co_queue_init(&bs->flush_queue);
386
Kevin Wolf0f122642018-03-28 18:29:18 +0200387 for (i = 0; i < bdrv_drain_all_count; i++) {
388 bdrv_drained_begin(bs);
389 }
390
Max Reitz2c1d04e2016-01-29 16:36:11 +0100391 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
392
bellardb3380822004-03-14 21:38:54 +0000393 return bs;
394}
395
Marc Mari88d88792016-08-12 09:27:03 -0400396static BlockDriver *bdrv_do_find_format(const char *format_name)
bellardea2384d2004-08-01 21:59:26 +0000397{
398 BlockDriver *drv1;
Marc Mari88d88792016-08-12 09:27:03 -0400399
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100400 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
401 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000402 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100403 }
bellardea2384d2004-08-01 21:59:26 +0000404 }
Marc Mari88d88792016-08-12 09:27:03 -0400405
bellardea2384d2004-08-01 21:59:26 +0000406 return NULL;
407}
408
Marc Mari88d88792016-08-12 09:27:03 -0400409BlockDriver *bdrv_find_format(const char *format_name)
410{
411 BlockDriver *drv1;
412 int i;
413
414 drv1 = bdrv_do_find_format(format_name);
415 if (drv1) {
416 return drv1;
417 }
418
419 /* The driver isn't registered, maybe we need to load a module */
420 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
421 if (!strcmp(block_driver_modules[i].format_name, format_name)) {
422 block_module_load_one(block_driver_modules[i].library_name);
423 break;
424 }
425 }
426
427 return bdrv_do_find_format(format_name);
428}
429
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300430static int bdrv_format_is_whitelisted(const char *format_name, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100431{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800432 static const char *whitelist_rw[] = {
433 CONFIG_BDRV_RW_WHITELIST
434 };
435 static const char *whitelist_ro[] = {
436 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100437 };
438 const char **p;
439
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800440 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100441 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800442 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100443
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800444 for (p = whitelist_rw; *p; p++) {
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300445 if (!strcmp(format_name, *p)) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100446 return 1;
447 }
448 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800449 if (read_only) {
450 for (p = whitelist_ro; *p; p++) {
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300451 if (!strcmp(format_name, *p)) {
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800452 return 1;
453 }
454 }
455 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100456 return 0;
457}
458
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300459int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
460{
461 return bdrv_format_is_whitelisted(drv->format_name, read_only);
462}
463
Daniel P. Berrangee6ff69b2016-03-21 14:11:48 +0000464bool bdrv_uses_whitelist(void)
465{
466 return use_bdrv_whitelist;
467}
468
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800469typedef struct CreateCo {
470 BlockDriver *drv;
471 char *filename;
Chunyan Liu83d05212014-06-05 17:20:51 +0800472 QemuOpts *opts;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800473 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200474 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800475} CreateCo;
476
477static void coroutine_fn bdrv_create_co_entry(void *opaque)
478{
Max Reitzcc84d902013-09-06 17:14:26 +0200479 Error *local_err = NULL;
480 int ret;
481
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800482 CreateCo *cco = opaque;
483 assert(cco->drv);
484
Stefan Hajnocziefc75e22018-01-18 13:43:45 +0100485 ret = cco->drv->bdrv_co_create_opts(cco->filename, cco->opts, &local_err);
Eduardo Habkost621ff942016-06-13 18:57:56 -0300486 error_propagate(&cco->err, local_err);
Max Reitzcc84d902013-09-06 17:14:26 +0200487 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800488}
489
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200490int bdrv_create(BlockDriver *drv, const char* filename,
Chunyan Liu83d05212014-06-05 17:20:51 +0800491 QemuOpts *opts, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000492{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800493 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200494
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800495 Coroutine *co;
496 CreateCo cco = {
497 .drv = drv,
498 .filename = g_strdup(filename),
Chunyan Liu83d05212014-06-05 17:20:51 +0800499 .opts = opts,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800500 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200501 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800502 };
503
Stefan Hajnocziefc75e22018-01-18 13:43:45 +0100504 if (!drv->bdrv_co_create_opts) {
Max Reitzcc84d902013-09-06 17:14:26 +0200505 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300506 ret = -ENOTSUP;
507 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800508 }
509
510 if (qemu_in_coroutine()) {
511 /* Fast-path if already in coroutine context */
512 bdrv_create_co_entry(&cco);
513 } else {
Paolo Bonzini0b8b8752016-07-04 19:10:01 +0200514 co = qemu_coroutine_create(bdrv_create_co_entry, &cco);
515 qemu_coroutine_enter(co);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800516 while (cco.ret == NOT_DONE) {
Paolo Bonzinib47ec2c2014-07-07 15:18:01 +0200517 aio_poll(qemu_get_aio_context(), true);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800518 }
519 }
520
521 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200522 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100523 if (cco.err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200524 error_propagate(errp, cco.err);
525 } else {
526 error_setg_errno(errp, -ret, "Could not create image");
527 }
528 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800529
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300530out:
531 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800532 return ret;
bellardea2384d2004-08-01 21:59:26 +0000533}
534
Max Reitzfd171462020-01-22 17:45:29 +0100535/**
536 * Helper function for bdrv_create_file_fallback(): Resize @blk to at
537 * least the given @minimum_size.
538 *
539 * On success, return @blk's actual length.
540 * Otherwise, return -errno.
541 */
542static int64_t create_file_fallback_truncate(BlockBackend *blk,
543 int64_t minimum_size, Error **errp)
544{
545 Error *local_err = NULL;
546 int64_t size;
547 int ret;
548
549 ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
550 if (ret < 0 && ret != -ENOTSUP) {
551 error_propagate(errp, local_err);
552 return ret;
553 }
554
555 size = blk_getlength(blk);
556 if (size < 0) {
557 error_free(local_err);
558 error_setg_errno(errp, -size,
559 "Failed to inquire the new image file's length");
560 return size;
561 }
562
563 if (size < minimum_size) {
564 /* Need to grow the image, but we failed to do that */
565 error_propagate(errp, local_err);
566 return -ENOTSUP;
567 }
568
569 error_free(local_err);
570 local_err = NULL;
571
572 return size;
573}
574
575/**
576 * Helper function for bdrv_create_file_fallback(): Zero the first
577 * sector to remove any potentially pre-existing image header.
578 */
579static int create_file_fallback_zero_first_sector(BlockBackend *blk,
580 int64_t current_size,
581 Error **errp)
582{
583 int64_t bytes_to_clear;
584 int ret;
585
586 bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE);
587 if (bytes_to_clear) {
588 ret = blk_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP);
589 if (ret < 0) {
590 error_setg_errno(errp, -ret,
591 "Failed to clear the new image's first sector");
592 return ret;
593 }
594 }
595
596 return 0;
597}
598
599static int bdrv_create_file_fallback(const char *filename, BlockDriver *drv,
600 QemuOpts *opts, Error **errp)
601{
602 BlockBackend *blk;
Max Reitzeeea1fa2020-02-25 16:56:18 +0100603 QDict *options;
Max Reitzfd171462020-01-22 17:45:29 +0100604 int64_t size = 0;
605 char *buf = NULL;
606 PreallocMode prealloc;
607 Error *local_err = NULL;
608 int ret;
609
610 size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
611 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
612 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
613 PREALLOC_MODE_OFF, &local_err);
614 g_free(buf);
615 if (local_err) {
616 error_propagate(errp, local_err);
617 return -EINVAL;
618 }
619
620 if (prealloc != PREALLOC_MODE_OFF) {
621 error_setg(errp, "Unsupported preallocation mode '%s'",
622 PreallocMode_str(prealloc));
623 return -ENOTSUP;
624 }
625
Max Reitzeeea1fa2020-02-25 16:56:18 +0100626 options = qdict_new();
Max Reitzfd171462020-01-22 17:45:29 +0100627 qdict_put_str(options, "driver", drv->format_name);
628
629 blk = blk_new_open(filename, NULL, options,
630 BDRV_O_RDWR | BDRV_O_RESIZE, errp);
631 if (!blk) {
632 error_prepend(errp, "Protocol driver '%s' does not support image "
633 "creation, and opening the image failed: ",
634 drv->format_name);
635 return -EINVAL;
636 }
637
638 size = create_file_fallback_truncate(blk, size, errp);
639 if (size < 0) {
640 ret = size;
641 goto out;
642 }
643
644 ret = create_file_fallback_zero_first_sector(blk, size, errp);
645 if (ret < 0) {
646 goto out;
647 }
648
649 ret = 0;
650out:
651 blk_unref(blk);
652 return ret;
653}
654
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800655int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200656{
657 BlockDriver *drv;
658
Max Reitzb65a5e12015-02-05 13:58:12 -0500659 drv = bdrv_find_protocol(filename, true, errp);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200660 if (drv == NULL) {
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000661 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200662 }
663
Max Reitzfd171462020-01-22 17:45:29 +0100664 if (drv->bdrv_co_create_opts) {
665 return bdrv_create(drv, filename, opts, errp);
666 } else {
667 return bdrv_create_file_fallback(filename, drv, opts, errp);
668 }
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200669}
670
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100671/**
672 * Try to get @bs's logical and physical block size.
673 * On success, store them in @bsz struct and return 0.
674 * On failure return -errno.
675 * @bs must not be empty.
676 */
677int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
678{
679 BlockDriver *drv = bs->drv;
680
681 if (drv && drv->bdrv_probe_blocksizes) {
682 return drv->bdrv_probe_blocksizes(bs, bsz);
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +0300683 } else if (drv && drv->is_filter && bs->file) {
684 return bdrv_probe_blocksizes(bs->file->bs, bsz);
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100685 }
686
687 return -ENOTSUP;
688}
689
690/**
691 * Try to get @bs's geometry (cyls, heads, sectors).
692 * On success, store them in @geo struct and return 0.
693 * On failure return -errno.
694 * @bs must not be empty.
695 */
696int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
697{
698 BlockDriver *drv = bs->drv;
699
700 if (drv && drv->bdrv_probe_geometry) {
701 return drv->bdrv_probe_geometry(bs, geo);
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +0300702 } else if (drv && drv->is_filter && bs->file) {
703 return bdrv_probe_geometry(bs->file->bs, geo);
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100704 }
705
706 return -ENOTSUP;
707}
708
Jim Meyeringeba25052012-05-28 09:27:54 +0200709/*
710 * Create a uniquely-named empty temporary file.
711 * Return 0 upon success, otherwise a negative errno value.
712 */
713int get_tmp_filename(char *filename, int size)
714{
bellardd5249392004-08-03 21:14:23 +0000715#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000716 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200717 /* GetTempFileName requires that its output buffer (4th param)
718 have length MAX_PATH or greater. */
719 assert(size >= MAX_PATH);
720 return (GetTempPath(MAX_PATH, temp_dir)
721 && GetTempFileName(temp_dir, "qem", 0, filename)
722 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000723#else
bellardea2384d2004-08-01 21:59:26 +0000724 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000725 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000726 tmpdir = getenv("TMPDIR");
Amit Shah69bef792014-02-26 15:12:37 +0530727 if (!tmpdir) {
728 tmpdir = "/var/tmp";
729 }
Jim Meyeringeba25052012-05-28 09:27:54 +0200730 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
731 return -EOVERFLOW;
732 }
bellardea2384d2004-08-01 21:59:26 +0000733 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800734 if (fd < 0) {
735 return -errno;
736 }
737 if (close(fd) != 0) {
738 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200739 return -errno;
740 }
741 return 0;
bellardd5249392004-08-03 21:14:23 +0000742#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200743}
bellardea2384d2004-08-01 21:59:26 +0000744
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200745/*
746 * Detect host devices. By convention, /dev/cdrom[N] is always
747 * recognized as a host CDROM.
748 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200749static BlockDriver *find_hdev_driver(const char *filename)
750{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200751 int score_max = 0, score;
752 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200753
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100754 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200755 if (d->bdrv_probe_device) {
756 score = d->bdrv_probe_device(filename);
757 if (score > score_max) {
758 score_max = score;
759 drv = d;
760 }
761 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200762 }
763
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200764 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200765}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200766
Marc Mari88d88792016-08-12 09:27:03 -0400767static BlockDriver *bdrv_do_find_protocol(const char *protocol)
768{
769 BlockDriver *drv1;
770
771 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
772 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
773 return drv1;
774 }
775 }
776
777 return NULL;
778}
779
Kevin Wolf98289622013-07-10 15:47:39 +0200780BlockDriver *bdrv_find_protocol(const char *filename,
Max Reitzb65a5e12015-02-05 13:58:12 -0500781 bool allow_protocol_prefix,
782 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200783{
784 BlockDriver *drv1;
785 char protocol[128];
786 int len;
787 const char *p;
Marc Mari88d88792016-08-12 09:27:03 -0400788 int i;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200789
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200790 /* TODO Drivers without bdrv_file_open must be specified explicitly */
791
Christoph Hellwig39508e72010-06-23 12:25:17 +0200792 /*
793 * XXX(hch): we really should not let host device detection
794 * override an explicit protocol specification, but moving this
795 * later breaks access to device names with colons in them.
796 * Thanks to the brain-dead persistent naming schemes on udev-
797 * based Linux systems those actually are quite common.
798 */
799 drv1 = find_hdev_driver(filename);
800 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200801 return drv1;
802 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200803
Kevin Wolf98289622013-07-10 15:47:39 +0200804 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Max Reitzef810432014-12-02 18:32:42 +0100805 return &bdrv_file;
Christoph Hellwig39508e72010-06-23 12:25:17 +0200806 }
Kevin Wolf98289622013-07-10 15:47:39 +0200807
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000808 p = strchr(filename, ':');
809 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200810 len = p - filename;
811 if (len > sizeof(protocol) - 1)
812 len = sizeof(protocol) - 1;
813 memcpy(protocol, filename, len);
814 protocol[len] = '\0';
Marc Mari88d88792016-08-12 09:27:03 -0400815
816 drv1 = bdrv_do_find_protocol(protocol);
817 if (drv1) {
818 return drv1;
819 }
820
821 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
822 if (block_driver_modules[i].protocol_name &&
823 !strcmp(block_driver_modules[i].protocol_name, protocol)) {
824 block_module_load_one(block_driver_modules[i].library_name);
825 break;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200826 }
827 }
Max Reitzb65a5e12015-02-05 13:58:12 -0500828
Marc Mari88d88792016-08-12 09:27:03 -0400829 drv1 = bdrv_do_find_protocol(protocol);
830 if (!drv1) {
831 error_setg(errp, "Unknown protocol '%s'", protocol);
832 }
833 return drv1;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200834}
835
Markus Armbrusterc6684242014-11-20 16:27:10 +0100836/*
837 * Guess image format by probing its contents.
838 * This is not a good idea when your image is raw (CVE-2008-2004), but
839 * we do it anyway for backward compatibility.
840 *
841 * @buf contains the image's first @buf_size bytes.
Kevin Wolf7cddd372014-11-20 16:27:11 +0100842 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
843 * but can be smaller if the image file is smaller)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100844 * @filename is its filename.
845 *
846 * For all block drivers, call the bdrv_probe() method to get its
847 * probing score.
848 * Return the first block driver with the highest probing score.
849 */
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100850BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
851 const char *filename)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100852{
853 int score_max = 0, score;
854 BlockDriver *drv = NULL, *d;
855
856 QLIST_FOREACH(d, &bdrv_drivers, list) {
857 if (d->bdrv_probe) {
858 score = d->bdrv_probe(buf, buf_size, filename);
859 if (score > score_max) {
860 score_max = score;
861 drv = d;
862 }
863 }
864 }
865
866 return drv;
867}
868
Kevin Wolf5696c6e2017-02-17 18:39:24 +0100869static int find_image_format(BlockBackend *file, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200870 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000871{
Markus Armbrusterc6684242014-11-20 16:27:10 +0100872 BlockDriver *drv;
Kevin Wolf7cddd372014-11-20 16:27:11 +0100873 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100874 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700875
Kevin Wolf08a00552010-06-01 18:37:31 +0200876 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Kevin Wolf5696c6e2017-02-17 18:39:24 +0100877 if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
Max Reitzef810432014-12-02 18:32:42 +0100878 *pdrv = &bdrv_raw;
Stefan Weilc98ac352010-07-21 21:51:51 +0200879 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700880 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700881
Kevin Wolf5696c6e2017-02-17 18:39:24 +0100882 ret = blk_pread(file, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000883 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200884 error_setg_errno(errp, -ret, "Could not read image for determining its "
885 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200886 *pdrv = NULL;
887 return ret;
bellard83f64092006-08-01 16:21:11 +0000888 }
889
Markus Armbrusterc6684242014-11-20 16:27:10 +0100890 drv = bdrv_probe_all(buf, ret, filename);
Stefan Weilc98ac352010-07-21 21:51:51 +0200891 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200892 error_setg(errp, "Could not determine image format: No compatible "
893 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200894 ret = -ENOENT;
895 }
896 *pdrv = drv;
897 return ret;
bellardea2384d2004-08-01 21:59:26 +0000898}
899
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100900/**
901 * Set the current 'total_sectors' value
Markus Armbruster65a9bb22014-06-26 13:23:17 +0200902 * Return 0 on success, -errno on error.
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100903 */
Kevin Wolf3d9f2d22018-06-26 13:55:20 +0200904int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100905{
906 BlockDriver *drv = bs->drv;
907
Max Reitzd470ad42017-11-10 21:31:09 +0100908 if (!drv) {
909 return -ENOMEDIUM;
910 }
911
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700912 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300913 if (bdrv_is_sg(bs))
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700914 return 0;
915
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100916 /* query actual device if possible, otherwise just trust the hint */
917 if (drv->bdrv_getlength) {
918 int64_t length = drv->bdrv_getlength(bs);
919 if (length < 0) {
920 return length;
921 }
Fam Zheng7e382002013-11-06 19:48:06 +0800922 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100923 }
924
925 bs->total_sectors = hint;
926 return 0;
927}
928
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100929/**
Kevin Wolfcddff5b2015-11-16 16:43:27 +0100930 * Combines a QDict of new block driver @options with any missing options taken
931 * from @old_options, so that leaving out an option defaults to its old value.
932 */
933static void bdrv_join_options(BlockDriverState *bs, QDict *options,
934 QDict *old_options)
935{
936 if (bs->drv && bs->drv->bdrv_join_options) {
937 bs->drv->bdrv_join_options(options, old_options);
938 } else {
939 qdict_join(options, old_options, false);
940 }
941}
942
Alberto Garcia543770b2018-09-06 12:37:09 +0300943static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
944 int open_flags,
945 Error **errp)
946{
947 Error *local_err = NULL;
948 char *value = qemu_opt_get_del(opts, "detect-zeroes");
949 BlockdevDetectZeroesOptions detect_zeroes =
950 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup, value,
951 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, &local_err);
952 g_free(value);
953 if (local_err) {
954 error_propagate(errp, local_err);
955 return detect_zeroes;
956 }
957
958 if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
959 !(open_flags & BDRV_O_UNMAP))
960 {
961 error_setg(errp, "setting detect-zeroes to unmap is not allowed "
962 "without setting discard operation to unmap");
963 }
964
965 return detect_zeroes;
966}
967
Kevin Wolfcddff5b2015-11-16 16:43:27 +0100968/**
Aarushi Mehtaf80f2672020-01-20 14:18:50 +0000969 * Set open flags for aio engine
970 *
971 * Return 0 on success, -1 if the engine specified is invalid
972 */
973int bdrv_parse_aio(const char *mode, int *flags)
974{
975 if (!strcmp(mode, "threads")) {
976 /* do nothing, default */
977 } else if (!strcmp(mode, "native")) {
978 *flags |= BDRV_O_NATIVE_AIO;
979#ifdef CONFIG_LINUX_IO_URING
980 } else if (!strcmp(mode, "io_uring")) {
981 *flags |= BDRV_O_IO_URING;
982#endif
983 } else {
984 return -1;
985 }
986
987 return 0;
988}
989
990/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100991 * Set open flags for a given discard mode
992 *
993 * Return 0 on success, -1 if the discard mode was invalid.
994 */
995int bdrv_parse_discard_flags(const char *mode, int *flags)
996{
997 *flags &= ~BDRV_O_UNMAP;
998
999 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
1000 /* do nothing */
1001 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
1002 *flags |= BDRV_O_UNMAP;
1003 } else {
1004 return -1;
1005 }
1006
1007 return 0;
1008}
1009
1010/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001011 * Set open flags for a given cache mode
1012 *
1013 * Return 0 on success, -1 if the cache mode was invalid.
1014 */
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001015int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001016{
1017 *flags &= ~BDRV_O_CACHE_MASK;
1018
1019 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001020 *writethrough = false;
1021 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +01001022 } else if (!strcmp(mode, "directsync")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001023 *writethrough = true;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +01001024 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001025 } else if (!strcmp(mode, "writeback")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001026 *writethrough = false;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001027 } else if (!strcmp(mode, "unsafe")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001028 *writethrough = false;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001029 *flags |= BDRV_O_NO_FLUSH;
1030 } else if (!strcmp(mode, "writethrough")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001031 *writethrough = true;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001032 } else {
1033 return -1;
1034 }
1035
1036 return 0;
1037}
1038
Kevin Wolfb5411552017-01-17 15:56:16 +01001039static char *bdrv_child_get_parent_desc(BdrvChild *c)
1040{
1041 BlockDriverState *parent = c->opaque;
1042 return g_strdup(bdrv_get_device_or_node_name(parent));
1043}
1044
Kevin Wolf20018e12016-05-23 18:46:59 +02001045static void bdrv_child_cb_drained_begin(BdrvChild *child)
1046{
1047 BlockDriverState *bs = child->opaque;
Kevin Wolf6cd5c9d2018-05-29 17:17:45 +02001048 bdrv_do_drained_begin_quiesce(bs, NULL, false);
Kevin Wolf20018e12016-05-23 18:46:59 +02001049}
1050
Kevin Wolf89bd0302018-03-22 14:11:20 +01001051static bool bdrv_child_cb_drained_poll(BdrvChild *child)
1052{
1053 BlockDriverState *bs = child->opaque;
Kevin Wolf6cd5c9d2018-05-29 17:17:45 +02001054 return bdrv_drain_poll(bs, false, NULL, false);
Kevin Wolf89bd0302018-03-22 14:11:20 +01001055}
1056
Max Reitze037c092019-07-19 11:26:14 +02001057static void bdrv_child_cb_drained_end(BdrvChild *child,
1058 int *drained_end_counter)
Kevin Wolf20018e12016-05-23 18:46:59 +02001059{
1060 BlockDriverState *bs = child->opaque;
Max Reitze037c092019-07-19 11:26:14 +02001061 bdrv_drained_end_no_poll(bs, drained_end_counter);
Kevin Wolf20018e12016-05-23 18:46:59 +02001062}
1063
Kevin Wolfd736f112017-12-18 16:05:48 +01001064static void bdrv_child_cb_attach(BdrvChild *child)
1065{
1066 BlockDriverState *bs = child->opaque;
1067 bdrv_apply_subtree_drain(child, bs);
1068}
1069
1070static void bdrv_child_cb_detach(BdrvChild *child)
1071{
1072 BlockDriverState *bs = child->opaque;
1073 bdrv_unapply_subtree_drain(child, bs);
1074}
1075
Kevin Wolf38701b62017-05-04 18:52:39 +02001076static int bdrv_child_cb_inactivate(BdrvChild *child)
1077{
1078 BlockDriverState *bs = child->opaque;
1079 assert(bs->open_flags & BDRV_O_INACTIVE);
1080 return 0;
1081}
1082
Kevin Wolf5d231842019-05-06 19:17:56 +02001083static bool bdrv_child_cb_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
1084 GSList **ignore, Error **errp)
1085{
1086 BlockDriverState *bs = child->opaque;
1087 return bdrv_can_set_aio_context(bs, ctx, ignore, errp);
1088}
1089
Kevin Wolf53a7d042019-05-06 19:17:59 +02001090static void bdrv_child_cb_set_aio_ctx(BdrvChild *child, AioContext *ctx,
1091 GSList **ignore)
1092{
1093 BlockDriverState *bs = child->opaque;
1094 return bdrv_set_aio_context_ignore(bs, ctx, ignore);
1095}
1096
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001097/*
Kevin Wolf73176be2016-03-07 13:02:15 +01001098 * Returns the options and flags that a temporary snapshot should get, based on
1099 * the originally requested flags (the originally requested image will have
1100 * flags like a backing file)
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001101 */
Kevin Wolf73176be2016-03-07 13:02:15 +01001102static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
1103 int parent_flags, QDict *parent_options)
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001104{
Kevin Wolf73176be2016-03-07 13:02:15 +01001105 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
1106
1107 /* For temporary files, unconditional cache=unsafe is fine */
Kevin Wolf73176be2016-03-07 13:02:15 +01001108 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
1109 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
Kevin Wolf41869042016-06-16 12:59:30 +02001110
Kevin Wolf3f486862019-04-04 17:04:43 +02001111 /* Copy the read-only and discard options from the parent */
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001112 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
Kevin Wolf3f486862019-04-04 17:04:43 +02001113 qdict_copy_default(child_options, parent_options, BDRV_OPT_DISCARD);
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001114
Kevin Wolf41869042016-06-16 12:59:30 +02001115 /* aio=native doesn't work for cache.direct=off, so disable it for the
1116 * temporary snapshot */
1117 *child_flags &= ~BDRV_O_NATIVE_AIO;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001118}
1119
1120/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001121 * Returns the options and flags that bs->file should get if a protocol driver
1122 * is expected, based on the given options and flags for the parent BDS
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001123 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001124static void bdrv_inherited_options(int *child_flags, QDict *child_options,
1125 int parent_flags, QDict *parent_options)
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001126{
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001127 int flags = parent_flags;
1128
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001129 /* Enable protocol handling, disable format probing for bs->file */
1130 flags |= BDRV_O_PROTOCOL;
1131
Kevin Wolf91a097e2015-05-08 17:49:53 +02001132 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
1133 * the parent. */
1134 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
1135 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
Fam Zheng5a9347c2017-05-03 00:35:37 +08001136 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
Kevin Wolf91a097e2015-05-08 17:49:53 +02001137
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001138 /* Inherit the read-only option from the parent if it's not set */
1139 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
Kevin Wolfe35bdc12018-10-05 18:57:40 +02001140 qdict_copy_default(child_options, parent_options, BDRV_OPT_AUTO_READ_ONLY);
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001141
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001142 /* Our block drivers take care to send flushes and respect unmap policy,
Kevin Wolf91a097e2015-05-08 17:49:53 +02001143 * so we can default to enable both on lower layers regardless of the
1144 * corresponding parent options. */
Kevin Wolf818584a2016-09-12 18:03:18 +02001145 qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001146
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001147 /* Clear flags that only apply to the top layer */
Daniel P. Berrangeabb06c52016-03-21 14:11:42 +00001148 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
1149 BDRV_O_NO_IO);
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001150
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001151 *child_flags = flags;
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001152}
1153
Kevin Wolff3930ed2015-04-08 13:43:47 +02001154const BdrvChildRole child_file = {
Kevin Wolf6cd5c9d2018-05-29 17:17:45 +02001155 .parent_is_bds = true,
Kevin Wolfb5411552017-01-17 15:56:16 +01001156 .get_parent_desc = bdrv_child_get_parent_desc,
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001157 .inherit_options = bdrv_inherited_options,
Kevin Wolf20018e12016-05-23 18:46:59 +02001158 .drained_begin = bdrv_child_cb_drained_begin,
Kevin Wolf89bd0302018-03-22 14:11:20 +01001159 .drained_poll = bdrv_child_cb_drained_poll,
Kevin Wolf20018e12016-05-23 18:46:59 +02001160 .drained_end = bdrv_child_cb_drained_end,
Kevin Wolfd736f112017-12-18 16:05:48 +01001161 .attach = bdrv_child_cb_attach,
1162 .detach = bdrv_child_cb_detach,
Kevin Wolf38701b62017-05-04 18:52:39 +02001163 .inactivate = bdrv_child_cb_inactivate,
Kevin Wolf5d231842019-05-06 19:17:56 +02001164 .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx,
Kevin Wolf53a7d042019-05-06 19:17:59 +02001165 .set_aio_ctx = bdrv_child_cb_set_aio_ctx,
Kevin Wolff3930ed2015-04-08 13:43:47 +02001166};
1167
1168/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001169 * Returns the options and flags that bs->file should get if the use of formats
1170 * (and not only protocols) is permitted for it, based on the given options and
1171 * flags for the parent BDS
Kevin Wolff3930ed2015-04-08 13:43:47 +02001172 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001173static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
1174 int parent_flags, QDict *parent_options)
Kevin Wolff3930ed2015-04-08 13:43:47 +02001175{
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001176 child_file.inherit_options(child_flags, child_options,
1177 parent_flags, parent_options);
1178
Daniel P. Berrangeabb06c52016-03-21 14:11:42 +00001179 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001180}
1181
1182const BdrvChildRole child_format = {
Kevin Wolf6cd5c9d2018-05-29 17:17:45 +02001183 .parent_is_bds = true,
Kevin Wolfb5411552017-01-17 15:56:16 +01001184 .get_parent_desc = bdrv_child_get_parent_desc,
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001185 .inherit_options = bdrv_inherited_fmt_options,
Kevin Wolf20018e12016-05-23 18:46:59 +02001186 .drained_begin = bdrv_child_cb_drained_begin,
Kevin Wolf89bd0302018-03-22 14:11:20 +01001187 .drained_poll = bdrv_child_cb_drained_poll,
Kevin Wolf20018e12016-05-23 18:46:59 +02001188 .drained_end = bdrv_child_cb_drained_end,
Kevin Wolfd736f112017-12-18 16:05:48 +01001189 .attach = bdrv_child_cb_attach,
1190 .detach = bdrv_child_cb_detach,
Kevin Wolf38701b62017-05-04 18:52:39 +02001191 .inactivate = bdrv_child_cb_inactivate,
Kevin Wolf5d231842019-05-06 19:17:56 +02001192 .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx,
Kevin Wolf53a7d042019-05-06 19:17:59 +02001193 .set_aio_ctx = bdrv_child_cb_set_aio_ctx,
Kevin Wolff3930ed2015-04-08 13:43:47 +02001194};
1195
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001196static void bdrv_backing_attach(BdrvChild *c)
1197{
1198 BlockDriverState *parent = c->opaque;
1199 BlockDriverState *backing_hd = c->bs;
1200
1201 assert(!parent->backing_blocker);
1202 error_setg(&parent->backing_blocker,
1203 "node is used as backing hd of '%s'",
1204 bdrv_get_device_or_node_name(parent));
1205
Max Reitzf30c66b2019-02-01 20:29:05 +01001206 bdrv_refresh_filename(backing_hd);
1207
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001208 parent->open_flags &= ~BDRV_O_NO_BACKING;
1209 pstrcpy(parent->backing_file, sizeof(parent->backing_file),
1210 backing_hd->filename);
1211 pstrcpy(parent->backing_format, sizeof(parent->backing_format),
1212 backing_hd->drv ? backing_hd->drv->format_name : "");
1213
1214 bdrv_op_block_all(backing_hd, parent->backing_blocker);
1215 /* Otherwise we won't be able to commit or stream */
1216 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1217 parent->backing_blocker);
1218 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
1219 parent->backing_blocker);
1220 /*
1221 * We do backup in 3 ways:
1222 * 1. drive backup
1223 * The target bs is new opened, and the source is top BDS
1224 * 2. blockdev backup
1225 * Both the source and the target are top BDSes.
1226 * 3. internal backup(used for block replication)
1227 * Both the source and the target are backing file
1228 *
1229 * In case 1 and 2, neither the source nor the target is the backing file.
1230 * In case 3, we will block the top BDS, so there is only one block job
1231 * for the top BDS and its backing chain.
1232 */
1233 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
1234 parent->backing_blocker);
1235 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
1236 parent->backing_blocker);
Kevin Wolfd736f112017-12-18 16:05:48 +01001237
1238 bdrv_child_cb_attach(c);
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001239}
1240
1241static void bdrv_backing_detach(BdrvChild *c)
1242{
1243 BlockDriverState *parent = c->opaque;
1244
1245 assert(parent->backing_blocker);
1246 bdrv_op_unblock_all(c->bs, parent->backing_blocker);
1247 error_free(parent->backing_blocker);
1248 parent->backing_blocker = NULL;
Kevin Wolfd736f112017-12-18 16:05:48 +01001249
1250 bdrv_child_cb_detach(c);
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001251}
1252
Kevin Wolf317fc442014-04-25 13:27:34 +02001253/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001254 * Returns the options and flags that bs->backing should get, based on the
1255 * given options and flags for the parent BDS
Kevin Wolf317fc442014-04-25 13:27:34 +02001256 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001257static void bdrv_backing_options(int *child_flags, QDict *child_options,
1258 int parent_flags, QDict *parent_options)
Kevin Wolf317fc442014-04-25 13:27:34 +02001259{
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001260 int flags = parent_flags;
1261
Kevin Wolfb8816a42016-03-04 14:52:32 +01001262 /* The cache mode is inherited unmodified for backing files; except WCE,
1263 * which is only applied on the top level (BlockBackend) */
Kevin Wolf91a097e2015-05-08 17:49:53 +02001264 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
1265 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
Fam Zheng5a9347c2017-05-03 00:35:37 +08001266 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
Kevin Wolf91a097e2015-05-08 17:49:53 +02001267
Kevin Wolf317fc442014-04-25 13:27:34 +02001268 /* backing files always opened read-only */
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001269 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
Kevin Wolfe35bdc12018-10-05 18:57:40 +02001270 qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001271 flags &= ~BDRV_O_COPY_ON_READ;
Kevin Wolf317fc442014-04-25 13:27:34 +02001272
1273 /* snapshot=on is handled on the top layer */
Kevin Wolf8bfea152014-04-11 19:16:36 +02001274 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
Kevin Wolf317fc442014-04-25 13:27:34 +02001275
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001276 *child_flags = flags;
Kevin Wolf317fc442014-04-25 13:27:34 +02001277}
1278
Kevin Wolf6858eba2017-06-29 19:32:21 +02001279static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
1280 const char *filename, Error **errp)
1281{
1282 BlockDriverState *parent = c->opaque;
Alberto Garciae94d3db2018-11-12 16:00:34 +02001283 bool read_only = bdrv_is_read_only(parent);
Kevin Wolf6858eba2017-06-29 19:32:21 +02001284 int ret;
1285
Alberto Garciae94d3db2018-11-12 16:00:34 +02001286 if (read_only) {
1287 ret = bdrv_reopen_set_read_only(parent, false, errp);
Kevin Wolf61f09ce2017-09-19 16:22:54 +02001288 if (ret < 0) {
1289 return ret;
1290 }
1291 }
1292
Kevin Wolf6858eba2017-06-29 19:32:21 +02001293 ret = bdrv_change_backing_file(parent, filename,
1294 base->drv ? base->drv->format_name : "");
1295 if (ret < 0) {
Kevin Wolf64730692017-11-06 17:52:58 +01001296 error_setg_errno(errp, -ret, "Could not update backing file link");
Kevin Wolf6858eba2017-06-29 19:32:21 +02001297 }
1298
Alberto Garciae94d3db2018-11-12 16:00:34 +02001299 if (read_only) {
1300 bdrv_reopen_set_read_only(parent, true, NULL);
Kevin Wolf61f09ce2017-09-19 16:22:54 +02001301 }
1302
Kevin Wolf6858eba2017-06-29 19:32:21 +02001303 return ret;
1304}
1305
Kevin Wolf91ef3822016-12-20 16:23:46 +01001306const BdrvChildRole child_backing = {
Kevin Wolf6cd5c9d2018-05-29 17:17:45 +02001307 .parent_is_bds = true,
Kevin Wolfb5411552017-01-17 15:56:16 +01001308 .get_parent_desc = bdrv_child_get_parent_desc,
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001309 .attach = bdrv_backing_attach,
1310 .detach = bdrv_backing_detach,
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001311 .inherit_options = bdrv_backing_options,
Kevin Wolf20018e12016-05-23 18:46:59 +02001312 .drained_begin = bdrv_child_cb_drained_begin,
Kevin Wolf89bd0302018-03-22 14:11:20 +01001313 .drained_poll = bdrv_child_cb_drained_poll,
Kevin Wolf20018e12016-05-23 18:46:59 +02001314 .drained_end = bdrv_child_cb_drained_end,
Kevin Wolf38701b62017-05-04 18:52:39 +02001315 .inactivate = bdrv_child_cb_inactivate,
Kevin Wolf6858eba2017-06-29 19:32:21 +02001316 .update_filename = bdrv_backing_update_filename,
Kevin Wolf5d231842019-05-06 19:17:56 +02001317 .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx,
Kevin Wolf53a7d042019-05-06 19:17:59 +02001318 .set_aio_ctx = bdrv_child_cb_set_aio_ctx,
Kevin Wolff3930ed2015-04-08 13:43:47 +02001319};
1320
Kevin Wolf7b272452012-11-12 17:05:39 +01001321static int bdrv_open_flags(BlockDriverState *bs, int flags)
1322{
Kevin Wolf61de4c62016-03-18 17:46:45 +01001323 int open_flags = flags;
Kevin Wolf7b272452012-11-12 17:05:39 +01001324
1325 /*
1326 * Clear flags that are internal to the block layer before opening the
1327 * image.
1328 */
Kevin Wolf20cca272014-06-04 14:33:27 +02001329 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
Kevin Wolf7b272452012-11-12 17:05:39 +01001330
Kevin Wolf7b272452012-11-12 17:05:39 +01001331 return open_flags;
1332}
1333
Kevin Wolf91a097e2015-05-08 17:49:53 +02001334static void update_flags_from_options(int *flags, QemuOpts *opts)
1335{
Alberto Garcia2a3d4332018-11-12 16:00:48 +02001336 *flags &= ~(BDRV_O_CACHE_MASK | BDRV_O_RDWR | BDRV_O_AUTO_RDONLY);
Kevin Wolf91a097e2015-05-08 17:49:53 +02001337
Alberto Garcia57f9db92018-09-06 12:37:06 +03001338 if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
Kevin Wolf91a097e2015-05-08 17:49:53 +02001339 *flags |= BDRV_O_NO_FLUSH;
1340 }
1341
Alberto Garcia57f9db92018-09-06 12:37:06 +03001342 if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_DIRECT, false)) {
Kevin Wolf91a097e2015-05-08 17:49:53 +02001343 *flags |= BDRV_O_NOCACHE;
1344 }
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001345
Alberto Garcia57f9db92018-09-06 12:37:06 +03001346 if (!qemu_opt_get_bool_del(opts, BDRV_OPT_READ_ONLY, false)) {
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001347 *flags |= BDRV_O_RDWR;
1348 }
1349
Kevin Wolfe35bdc12018-10-05 18:57:40 +02001350 if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
1351 *flags |= BDRV_O_AUTO_RDONLY;
1352 }
Kevin Wolf91a097e2015-05-08 17:49:53 +02001353}
1354
1355static void update_options_from_flags(QDict *options, int flags)
1356{
Kevin Wolf91a097e2015-05-08 17:49:53 +02001357 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
Eric Blake46f5ac22017-04-27 16:58:17 -05001358 qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
Kevin Wolf91a097e2015-05-08 17:49:53 +02001359 }
1360 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
Eric Blake46f5ac22017-04-27 16:58:17 -05001361 qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
1362 flags & BDRV_O_NO_FLUSH);
Kevin Wolf91a097e2015-05-08 17:49:53 +02001363 }
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001364 if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
Eric Blake46f5ac22017-04-27 16:58:17 -05001365 qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001366 }
Kevin Wolfe35bdc12018-10-05 18:57:40 +02001367 if (!qdict_haskey(options, BDRV_OPT_AUTO_READ_ONLY)) {
1368 qdict_put_bool(options, BDRV_OPT_AUTO_READ_ONLY,
1369 flags & BDRV_O_AUTO_RDONLY);
1370 }
Kevin Wolf91a097e2015-05-08 17:49:53 +02001371}
1372
Kevin Wolf636ea372014-01-24 14:11:52 +01001373static void bdrv_assign_node_name(BlockDriverState *bs,
1374 const char *node_name,
1375 Error **errp)
Benoît Canet6913c0c2014-01-23 21:31:33 +01001376{
Jeff Cody15489c72015-10-12 19:36:50 -04001377 char *gen_node_name = NULL;
Benoît Canet6913c0c2014-01-23 21:31:33 +01001378
Jeff Cody15489c72015-10-12 19:36:50 -04001379 if (!node_name) {
1380 node_name = gen_node_name = id_generate(ID_BLOCK);
1381 } else if (!id_wellformed(node_name)) {
1382 /*
1383 * Check for empty string or invalid characters, but not if it is
1384 * generated (generated names use characters not available to the user)
1385 */
Kevin Wolf9aebf3b2014-09-25 09:54:02 +02001386 error_setg(errp, "Invalid node name");
Kevin Wolf636ea372014-01-24 14:11:52 +01001387 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +01001388 }
1389
Benoît Canet0c5e94e2014-02-12 17:15:07 +01001390 /* takes care of avoiding namespaces collisions */
Markus Armbruster7f06d472014-10-07 13:59:12 +02001391 if (blk_by_name(node_name)) {
Benoît Canet0c5e94e2014-02-12 17:15:07 +01001392 error_setg(errp, "node-name=%s is conflicting with a device id",
1393 node_name);
Jeff Cody15489c72015-10-12 19:36:50 -04001394 goto out;
Benoît Canet0c5e94e2014-02-12 17:15:07 +01001395 }
1396
Benoît Canet6913c0c2014-01-23 21:31:33 +01001397 /* takes care of avoiding duplicates node names */
1398 if (bdrv_find_node(node_name)) {
1399 error_setg(errp, "Duplicate node name");
Jeff Cody15489c72015-10-12 19:36:50 -04001400 goto out;
Benoît Canet6913c0c2014-01-23 21:31:33 +01001401 }
1402
Kevin Wolf824808d2018-07-04 13:28:29 +02001403 /* Make sure that the node name isn't truncated */
1404 if (strlen(node_name) >= sizeof(bs->node_name)) {
1405 error_setg(errp, "Node name too long");
1406 goto out;
1407 }
1408
Benoît Canet6913c0c2014-01-23 21:31:33 +01001409 /* copy node name into the bs and insert it into the graph list */
1410 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
1411 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
Jeff Cody15489c72015-10-12 19:36:50 -04001412out:
1413 g_free(gen_node_name);
Benoît Canet6913c0c2014-01-23 21:31:33 +01001414}
1415
Kevin Wolf01a56502017-01-18 15:51:56 +01001416static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
1417 const char *node_name, QDict *options,
1418 int open_flags, Error **errp)
1419{
1420 Error *local_err = NULL;
Kevin Wolf0f122642018-03-28 18:29:18 +02001421 int i, ret;
Kevin Wolf01a56502017-01-18 15:51:56 +01001422
1423 bdrv_assign_node_name(bs, node_name, &local_err);
1424 if (local_err) {
1425 error_propagate(errp, local_err);
1426 return -EINVAL;
1427 }
1428
1429 bs->drv = drv;
Kevin Wolf680c7f92017-01-18 17:16:41 +01001430 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
Kevin Wolf01a56502017-01-18 15:51:56 +01001431 bs->opaque = g_malloc0(drv->instance_size);
1432
1433 if (drv->bdrv_file_open) {
1434 assert(!drv->bdrv_needs_filename || bs->filename[0]);
1435 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolf680c7f92017-01-18 17:16:41 +01001436 } else if (drv->bdrv_open) {
Kevin Wolf01a56502017-01-18 15:51:56 +01001437 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf680c7f92017-01-18 17:16:41 +01001438 } else {
1439 ret = 0;
Kevin Wolf01a56502017-01-18 15:51:56 +01001440 }
1441
1442 if (ret < 0) {
1443 if (local_err) {
1444 error_propagate(errp, local_err);
1445 } else if (bs->filename[0]) {
1446 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1447 } else {
1448 error_setg_errno(errp, -ret, "Could not open image");
1449 }
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001450 goto open_failed;
Kevin Wolf01a56502017-01-18 15:51:56 +01001451 }
1452
1453 ret = refresh_total_sectors(bs, bs->total_sectors);
1454 if (ret < 0) {
1455 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001456 return ret;
Kevin Wolf01a56502017-01-18 15:51:56 +01001457 }
1458
1459 bdrv_refresh_limits(bs, &local_err);
1460 if (local_err) {
1461 error_propagate(errp, local_err);
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001462 return -EINVAL;
Kevin Wolf01a56502017-01-18 15:51:56 +01001463 }
1464
1465 assert(bdrv_opt_mem_align(bs) != 0);
1466 assert(bdrv_min_mem_align(bs) != 0);
1467 assert(is_power_of_2(bs->bl.request_alignment));
1468
Kevin Wolf0f122642018-03-28 18:29:18 +02001469 for (i = 0; i < bs->quiesce_counter; i++) {
1470 if (drv->bdrv_co_drain_begin) {
1471 drv->bdrv_co_drain_begin(bs);
1472 }
1473 }
1474
Kevin Wolf01a56502017-01-18 15:51:56 +01001475 return 0;
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001476open_failed:
1477 bs->drv = NULL;
1478 if (bs->file != NULL) {
1479 bdrv_unref_child(bs, bs->file);
1480 bs->file = NULL;
1481 }
Kevin Wolf01a56502017-01-18 15:51:56 +01001482 g_free(bs->opaque);
1483 bs->opaque = NULL;
Kevin Wolf01a56502017-01-18 15:51:56 +01001484 return ret;
1485}
1486
Kevin Wolf680c7f92017-01-18 17:16:41 +01001487BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
1488 int flags, Error **errp)
1489{
1490 BlockDriverState *bs;
1491 int ret;
1492
1493 bs = bdrv_new();
1494 bs->open_flags = flags;
1495 bs->explicit_options = qdict_new();
1496 bs->options = qdict_new();
1497 bs->opaque = NULL;
1498
1499 update_options_from_flags(bs->options, flags);
1500
1501 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
1502 if (ret < 0) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001503 qobject_unref(bs->explicit_options);
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001504 bs->explicit_options = NULL;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001505 qobject_unref(bs->options);
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001506 bs->options = NULL;
Kevin Wolf680c7f92017-01-18 17:16:41 +01001507 bdrv_unref(bs);
1508 return NULL;
1509 }
1510
1511 return bs;
1512}
1513
Kevin Wolfc5f30142016-10-06 11:33:17 +02001514QemuOptsList bdrv_runtime_opts = {
Kevin Wolf18edf282015-04-07 17:12:56 +02001515 .name = "bdrv_common",
1516 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
1517 .desc = {
1518 {
1519 .name = "node-name",
1520 .type = QEMU_OPT_STRING,
1521 .help = "Node name of the block device node",
1522 },
Kevin Wolf62392eb2015-04-24 16:38:02 +02001523 {
1524 .name = "driver",
1525 .type = QEMU_OPT_STRING,
1526 .help = "Block driver to use for the node",
1527 },
Kevin Wolf91a097e2015-05-08 17:49:53 +02001528 {
Kevin Wolf91a097e2015-05-08 17:49:53 +02001529 .name = BDRV_OPT_CACHE_DIRECT,
1530 .type = QEMU_OPT_BOOL,
1531 .help = "Bypass software writeback cache on the host",
1532 },
1533 {
1534 .name = BDRV_OPT_CACHE_NO_FLUSH,
1535 .type = QEMU_OPT_BOOL,
1536 .help = "Ignore flush requests",
1537 },
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001538 {
1539 .name = BDRV_OPT_READ_ONLY,
1540 .type = QEMU_OPT_BOOL,
1541 .help = "Node is opened in read-only mode",
1542 },
Kevin Wolf692e01a2016-09-12 21:00:41 +02001543 {
Kevin Wolfe35bdc12018-10-05 18:57:40 +02001544 .name = BDRV_OPT_AUTO_READ_ONLY,
1545 .type = QEMU_OPT_BOOL,
1546 .help = "Node can become read-only if opening read-write fails",
1547 },
1548 {
Kevin Wolf692e01a2016-09-12 21:00:41 +02001549 .name = "detect-zeroes",
1550 .type = QEMU_OPT_STRING,
1551 .help = "try to optimize zero writes (off, on, unmap)",
1552 },
Kevin Wolf818584a2016-09-12 18:03:18 +02001553 {
Alberto Garcia415bbca2018-10-03 13:23:13 +03001554 .name = BDRV_OPT_DISCARD,
Kevin Wolf818584a2016-09-12 18:03:18 +02001555 .type = QEMU_OPT_STRING,
1556 .help = "discard operation (ignore/off, unmap/on)",
1557 },
Fam Zheng5a9347c2017-05-03 00:35:37 +08001558 {
1559 .name = BDRV_OPT_FORCE_SHARE,
1560 .type = QEMU_OPT_BOOL,
1561 .help = "always accept other writers (default: off)",
1562 },
Kevin Wolf18edf282015-04-07 17:12:56 +02001563 { /* end of list */ }
1564 },
1565};
1566
Max Reitzfd171462020-01-22 17:45:29 +01001567static QemuOptsList fallback_create_opts = {
1568 .name = "fallback-create-opts",
1569 .head = QTAILQ_HEAD_INITIALIZER(fallback_create_opts.head),
1570 .desc = {
1571 {
1572 .name = BLOCK_OPT_SIZE,
1573 .type = QEMU_OPT_SIZE,
1574 .help = "Virtual disk size"
1575 },
1576 {
1577 .name = BLOCK_OPT_PREALLOC,
1578 .type = QEMU_OPT_STRING,
1579 .help = "Preallocation mode (allowed values: off)"
1580 },
1581 { /* end of list */ }
1582 }
1583};
1584
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001585/*
Kevin Wolf57915332010-04-14 15:24:50 +02001586 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001587 *
1588 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +02001589 */
Kevin Wolf5696c6e2017-02-17 18:39:24 +01001590static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001591 QDict *options, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +02001592{
1593 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +02001594 const char *filename;
Kevin Wolf62392eb2015-04-24 16:38:02 +02001595 const char *driver_name = NULL;
Benoît Canet6913c0c2014-01-23 21:31:33 +01001596 const char *node_name = NULL;
Kevin Wolf818584a2016-09-12 18:03:18 +02001597 const char *discard;
Kevin Wolf18edf282015-04-07 17:12:56 +02001598 QemuOpts *opts;
Kevin Wolf62392eb2015-04-24 16:38:02 +02001599 BlockDriver *drv;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001600 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +02001601
Paolo Bonzini64058752012-05-08 16:51:49 +02001602 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +01001603 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +02001604
Kevin Wolf62392eb2015-04-24 16:38:02 +02001605 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1606 qemu_opts_absorb_qdict(opts, options, &local_err);
1607 if (local_err) {
1608 error_propagate(errp, local_err);
1609 ret = -EINVAL;
1610 goto fail_opts;
1611 }
1612
Alberto Garcia9b7e8692016-09-15 17:53:01 +03001613 update_flags_from_options(&bs->open_flags, opts);
1614
Kevin Wolf62392eb2015-04-24 16:38:02 +02001615 driver_name = qemu_opt_get(opts, "driver");
1616 drv = bdrv_find_format(driver_name);
1617 assert(drv != NULL);
1618
Fam Zheng5a9347c2017-05-03 00:35:37 +08001619 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);
1620
1621 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {
1622 error_setg(errp,
1623 BDRV_OPT_FORCE_SHARE
1624 "=on can only be used with read-only images");
1625 ret = -EINVAL;
1626 goto fail_opts;
1627 }
1628
Kevin Wolf45673672013-04-22 17:48:40 +02001629 if (file != NULL) {
Max Reitzf30c66b2019-02-01 20:29:05 +01001630 bdrv_refresh_filename(blk_bs(file));
Kevin Wolf5696c6e2017-02-17 18:39:24 +01001631 filename = blk_bs(file)->filename;
Kevin Wolf45673672013-04-22 17:48:40 +02001632 } else {
Markus Armbruster129c7d12017-03-30 19:43:12 +02001633 /*
1634 * Caution: while qdict_get_try_str() is fine, getting
1635 * non-string types would require more care. When @options
1636 * come from -blockdev or blockdev_add, its members are typed
1637 * according to the QAPI schema, but when they come from
1638 * -drive, they're all QString.
1639 */
Kevin Wolf45673672013-04-22 17:48:40 +02001640 filename = qdict_get_try_str(options, "filename");
1641 }
1642
Max Reitz4a008242017-04-13 18:06:24 +02001643 if (drv->bdrv_needs_filename && (!filename || !filename[0])) {
Kevin Wolf765003d2014-02-03 14:49:42 +01001644 error_setg(errp, "The '%s' block driver requires a file name",
1645 drv->format_name);
Kevin Wolf18edf282015-04-07 17:12:56 +02001646 ret = -EINVAL;
1647 goto fail_opts;
1648 }
1649
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001650 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
1651 drv->format_name);
Kevin Wolf62392eb2015-04-24 16:38:02 +02001652
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001653 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
Fam Zhengb64ec4e2013-05-29 19:35:40 +08001654
1655 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8be25de2019-01-22 13:15:31 +01001656 if (!bs->read_only && bdrv_is_whitelisted(drv, true)) {
1657 ret = bdrv_apply_auto_read_only(bs, NULL, NULL);
1658 } else {
1659 ret = -ENOTSUP;
1660 }
1661 if (ret < 0) {
1662 error_setg(errp,
1663 !bs->read_only && bdrv_is_whitelisted(drv, true)
1664 ? "Driver '%s' can only be used for read-only devices"
1665 : "Driver '%s' is not whitelisted",
1666 drv->format_name);
1667 goto fail_opts;
1668 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +08001669 }
Kevin Wolf57915332010-04-14 15:24:50 +02001670
Paolo Bonzinid3faa132017-06-05 14:38:50 +02001671 /* bdrv_new() and bdrv_close() make it so */
1672 assert(atomic_read(&bs->copy_on_read) == 0);
1673
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001674 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
Kevin Wolf0ebd24e2013-09-19 15:12:18 +02001675 if (!bs->read_only) {
1676 bdrv_enable_copy_on_read(bs);
1677 } else {
1678 error_setg(errp, "Can't use copy-on-read on read-only device");
Kevin Wolf18edf282015-04-07 17:12:56 +02001679 ret = -EINVAL;
1680 goto fail_opts;
Kevin Wolf0ebd24e2013-09-19 15:12:18 +02001681 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001682 }
1683
Alberto Garcia415bbca2018-10-03 13:23:13 +03001684 discard = qemu_opt_get(opts, BDRV_OPT_DISCARD);
Kevin Wolf818584a2016-09-12 18:03:18 +02001685 if (discard != NULL) {
1686 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
1687 error_setg(errp, "Invalid discard option");
1688 ret = -EINVAL;
1689 goto fail_opts;
1690 }
1691 }
1692
Alberto Garcia543770b2018-09-06 12:37:09 +03001693 bs->detect_zeroes =
1694 bdrv_parse_detect_zeroes(opts, bs->open_flags, &local_err);
1695 if (local_err) {
1696 error_propagate(errp, local_err);
1697 ret = -EINVAL;
1698 goto fail_opts;
Kevin Wolf692e01a2016-09-12 21:00:41 +02001699 }
1700
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001701 if (filename != NULL) {
1702 pstrcpy(bs->filename, sizeof(bs->filename), filename);
1703 } else {
1704 bs->filename[0] = '\0';
1705 }
Max Reitz91af7012014-07-18 20:24:56 +02001706 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
Kevin Wolf57915332010-04-14 15:24:50 +02001707
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001708 /* Open the image, either directly or using a protocol */
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001709 open_flags = bdrv_open_flags(bs, bs->open_flags);
Kevin Wolf01a56502017-01-18 15:51:56 +01001710 node_name = qemu_opt_get(opts, "node-name");
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001711
Kevin Wolf01a56502017-01-18 15:51:56 +01001712 assert(!drv->bdrv_file_open || file == NULL);
1713 ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
Kevin Wolf57915332010-04-14 15:24:50 +02001714 if (ret < 0) {
Kevin Wolf01a56502017-01-18 15:51:56 +01001715 goto fail_opts;
Kevin Wolf57915332010-04-14 15:24:50 +02001716 }
1717
Kevin Wolf18edf282015-04-07 17:12:56 +02001718 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +02001719 return 0;
1720
Kevin Wolf18edf282015-04-07 17:12:56 +02001721fail_opts:
1722 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +02001723 return ret;
1724}
1725
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001726static QDict *parse_json_filename(const char *filename, Error **errp)
1727{
1728 QObject *options_obj;
1729 QDict *options;
1730 int ret;
1731
1732 ret = strstart(filename, "json:", &filename);
1733 assert(ret);
1734
Markus Armbruster5577fff2017-02-28 22:26:59 +01001735 options_obj = qobject_from_json(filename, errp);
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001736 if (!options_obj) {
Markus Armbruster5577fff2017-02-28 22:26:59 +01001737 error_prepend(errp, "Could not parse the JSON options: ");
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001738 return NULL;
1739 }
1740
Max Reitz7dc847e2018-02-24 16:40:29 +01001741 options = qobject_to(QDict, options_obj);
Markus Armbrusterca6b6e12017-02-17 21:38:18 +01001742 if (!options) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001743 qobject_unref(options_obj);
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001744 error_setg(errp, "Invalid JSON object given");
1745 return NULL;
1746 }
1747
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001748 qdict_flatten(options);
1749
1750 return options;
1751}
1752
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001753static void parse_json_protocol(QDict *options, const char **pfilename,
1754 Error **errp)
1755{
1756 QDict *json_options;
1757 Error *local_err = NULL;
1758
1759 /* Parse json: pseudo-protocol */
1760 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1761 return;
1762 }
1763
1764 json_options = parse_json_filename(*pfilename, &local_err);
1765 if (local_err) {
1766 error_propagate(errp, local_err);
1767 return;
1768 }
1769
1770 /* Options given in the filename have lower priority than options
1771 * specified directly */
1772 qdict_join(options, json_options, false);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001773 qobject_unref(json_options);
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001774 *pfilename = NULL;
1775}
1776
Kevin Wolf57915332010-04-14 15:24:50 +02001777/*
Kevin Wolff54120f2014-05-26 11:09:59 +02001778 * Fills in default options for opening images and converts the legacy
1779 * filename/flags pair to option QDict entries.
Max Reitz53a29512015-03-19 14:53:16 -04001780 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1781 * block driver has been specified explicitly.
Kevin Wolff54120f2014-05-26 11:09:59 +02001782 */
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001783static int bdrv_fill_options(QDict **options, const char *filename,
Max Reitz053e1572015-08-26 19:47:51 +02001784 int *flags, Error **errp)
Kevin Wolff54120f2014-05-26 11:09:59 +02001785{
1786 const char *drvname;
Max Reitz53a29512015-03-19 14:53:16 -04001787 bool protocol = *flags & BDRV_O_PROTOCOL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001788 bool parse_filename = false;
Max Reitz053e1572015-08-26 19:47:51 +02001789 BlockDriver *drv = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001790 Error *local_err = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001791
Markus Armbruster129c7d12017-03-30 19:43:12 +02001792 /*
1793 * Caution: while qdict_get_try_str() is fine, getting non-string
1794 * types would require more care. When @options come from
1795 * -blockdev or blockdev_add, its members are typed according to
1796 * the QAPI schema, but when they come from -drive, they're all
1797 * QString.
1798 */
Max Reitz53a29512015-03-19 14:53:16 -04001799 drvname = qdict_get_try_str(*options, "driver");
Max Reitz053e1572015-08-26 19:47:51 +02001800 if (drvname) {
1801 drv = bdrv_find_format(drvname);
1802 if (!drv) {
1803 error_setg(errp, "Unknown driver '%s'", drvname);
1804 return -ENOENT;
1805 }
1806 /* If the user has explicitly specified the driver, this choice should
1807 * override the BDRV_O_PROTOCOL flag */
1808 protocol = drv->bdrv_file_open;
Max Reitz53a29512015-03-19 14:53:16 -04001809 }
1810
1811 if (protocol) {
1812 *flags |= BDRV_O_PROTOCOL;
1813 } else {
1814 *flags &= ~BDRV_O_PROTOCOL;
1815 }
1816
Kevin Wolf91a097e2015-05-08 17:49:53 +02001817 /* Translate cache options from flags into options */
1818 update_options_from_flags(*options, *flags);
1819
Kevin Wolff54120f2014-05-26 11:09:59 +02001820 /* Fetch the file name from the options QDict if necessary */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001821 if (protocol && filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001822 if (!qdict_haskey(*options, "filename")) {
Eric Blake46f5ac22017-04-27 16:58:17 -05001823 qdict_put_str(*options, "filename", filename);
Kevin Wolff54120f2014-05-26 11:09:59 +02001824 parse_filename = true;
1825 } else {
1826 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1827 "the same time");
1828 return -EINVAL;
1829 }
1830 }
1831
1832 /* Find the right block driver */
Markus Armbruster129c7d12017-03-30 19:43:12 +02001833 /* See cautionary note on accessing @options above */
Kevin Wolff54120f2014-05-26 11:09:59 +02001834 filename = qdict_get_try_str(*options, "filename");
Kevin Wolff54120f2014-05-26 11:09:59 +02001835
Max Reitz053e1572015-08-26 19:47:51 +02001836 if (!drvname && protocol) {
1837 if (filename) {
1838 drv = bdrv_find_protocol(filename, parse_filename, errp);
1839 if (!drv) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001840 return -EINVAL;
1841 }
Max Reitz053e1572015-08-26 19:47:51 +02001842
1843 drvname = drv->format_name;
Eric Blake46f5ac22017-04-27 16:58:17 -05001844 qdict_put_str(*options, "driver", drvname);
Max Reitz053e1572015-08-26 19:47:51 +02001845 } else {
1846 error_setg(errp, "Must specify either driver or file");
1847 return -EINVAL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001848 }
1849 }
1850
Kevin Wolf17b005f2014-05-27 10:50:29 +02001851 assert(drv || !protocol);
Kevin Wolff54120f2014-05-26 11:09:59 +02001852
1853 /* Driver-specific filename parsing */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001854 if (drv && drv->bdrv_parse_filename && parse_filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001855 drv->bdrv_parse_filename(filename, *options, &local_err);
1856 if (local_err) {
1857 error_propagate(errp, local_err);
1858 return -EINVAL;
1859 }
1860
1861 if (!drv->bdrv_needs_filename) {
1862 qdict_del(*options, "filename");
1863 }
1864 }
1865
1866 return 0;
1867}
1868
Kevin Wolf3121fb42017-09-14 14:42:12 +02001869static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
1870 uint64_t perm, uint64_t shared,
Max Reitz9eab1542019-05-22 19:03:50 +02001871 GSList *ignore_children,
1872 bool *tighten_restrictions, Error **errp);
Fam Zhengc1cef672017-03-14 10:30:50 +08001873static void bdrv_child_abort_perm_update(BdrvChild *c);
1874static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);
1875
Kevin Wolf148eb132017-09-14 14:32:04 +02001876typedef struct BlockReopenQueueEntry {
1877 bool prepared;
Kevin Wolf69b736e2019-03-05 17:18:22 +01001878 bool perms_checked;
Kevin Wolf148eb132017-09-14 14:32:04 +02001879 BDRVReopenState state;
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03001880 QTAILQ_ENTRY(BlockReopenQueueEntry) entry;
Kevin Wolf148eb132017-09-14 14:32:04 +02001881} BlockReopenQueueEntry;
1882
1883/*
1884 * Return the flags that @bs will have after the reopens in @q have
1885 * successfully completed. If @q is NULL (or @bs is not contained in @q),
1886 * return the current flags.
1887 */
1888static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs)
1889{
1890 BlockReopenQueueEntry *entry;
1891
1892 if (q != NULL) {
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03001893 QTAILQ_FOREACH(entry, q, entry) {
Kevin Wolf148eb132017-09-14 14:32:04 +02001894 if (entry->state.bs == bs) {
1895 return entry->state.flags;
1896 }
1897 }
1898 }
1899
1900 return bs->open_flags;
1901}
1902
1903/* Returns whether the image file can be written to after the reopen queue @q
1904 * has been successfully applied, or right now if @q is NULL. */
Max Reitzcc022142018-06-06 21:37:00 +02001905static bool bdrv_is_writable_after_reopen(BlockDriverState *bs,
1906 BlockReopenQueue *q)
Kevin Wolf148eb132017-09-14 14:32:04 +02001907{
1908 int flags = bdrv_reopen_get_flags(q, bs);
1909
1910 return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR;
1911}
1912
Max Reitzcc022142018-06-06 21:37:00 +02001913/*
1914 * Return whether the BDS can be written to. This is not necessarily
1915 * the same as !bdrv_is_read_only(bs), as inactivated images may not
1916 * be written to but do not count as read-only images.
1917 */
1918bool bdrv_is_writable(BlockDriverState *bs)
1919{
1920 return bdrv_is_writable_after_reopen(bs, NULL);
1921}
1922
Fam Zhengffd1a5a2017-05-03 00:35:38 +08001923static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
Kevin Wolfe0995dc2017-09-14 12:47:11 +02001924 BdrvChild *c, const BdrvChildRole *role,
1925 BlockReopenQueue *reopen_queue,
Fam Zhengffd1a5a2017-05-03 00:35:38 +08001926 uint64_t parent_perm, uint64_t parent_shared,
1927 uint64_t *nperm, uint64_t *nshared)
1928{
Alberto Garcia0b3ca762019-04-04 14:29:53 +03001929 assert(bs->drv && bs->drv->bdrv_child_perm);
1930 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
1931 parent_perm, parent_shared,
1932 nperm, nshared);
Kevin Wolfe0995dc2017-09-14 12:47:11 +02001933 /* TODO Take force_share from reopen_queue */
Fam Zhengffd1a5a2017-05-03 00:35:38 +08001934 if (child_bs && child_bs->force_share) {
1935 *nshared = BLK_PERM_ALL;
1936 }
1937}
1938
Kevin Wolf33a610c2016-12-15 13:04:20 +01001939/*
1940 * Check whether permissions on this node can be changed in a way that
1941 * @cumulative_perms and @cumulative_shared_perms are the new cumulative
1942 * permissions of all its parents. This involves checking whether all necessary
1943 * permission changes to child nodes can be performed.
1944 *
Max Reitz9eab1542019-05-22 19:03:50 +02001945 * Will set *tighten_restrictions to true if and only if new permissions have to
1946 * be taken or currently shared permissions are to be unshared. Otherwise,
1947 * errors are not fatal as long as the caller accepts that the restrictions
1948 * remain tighter than they need to be. The caller still has to abort the
1949 * transaction.
1950 * @tighten_restrictions cannot be used together with @q: When reopening, we may
1951 * encounter fatal errors even though no restrictions are to be tightened. For
1952 * example, changing a node from RW to RO will fail if the WRITE permission is
1953 * to be kept.
1954 *
Kevin Wolf33a610c2016-12-15 13:04:20 +01001955 * A call to this function must always be followed by a call to bdrv_set_perm()
1956 * or bdrv_abort_perm_update().
1957 */
Kevin Wolf3121fb42017-09-14 14:42:12 +02001958static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q,
1959 uint64_t cumulative_perms,
Kevin Wolf46181122017-03-06 15:00:13 +01001960 uint64_t cumulative_shared_perms,
Max Reitz9eab1542019-05-22 19:03:50 +02001961 GSList *ignore_children,
1962 bool *tighten_restrictions, Error **errp)
Kevin Wolf33a610c2016-12-15 13:04:20 +01001963{
1964 BlockDriver *drv = bs->drv;
1965 BdrvChild *c;
1966 int ret;
1967
Max Reitz9eab1542019-05-22 19:03:50 +02001968 assert(!q || !tighten_restrictions);
1969
1970 if (tighten_restrictions) {
1971 uint64_t current_perms, current_shared;
1972 uint64_t added_perms, removed_shared_perms;
1973
1974 bdrv_get_cumulative_perm(bs, &current_perms, &current_shared);
1975
1976 added_perms = cumulative_perms & ~current_perms;
1977 removed_shared_perms = current_shared & ~cumulative_shared_perms;
1978
1979 *tighten_restrictions = added_perms || removed_shared_perms;
1980 }
1981
Kevin Wolf33a610c2016-12-15 13:04:20 +01001982 /* Write permissions never work with read-only images */
1983 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
Max Reitzcc022142018-06-06 21:37:00 +02001984 !bdrv_is_writable_after_reopen(bs, q))
Kevin Wolf33a610c2016-12-15 13:04:20 +01001985 {
Max Reitz481e0ee2019-05-15 22:15:00 +02001986 if (!bdrv_is_writable_after_reopen(bs, NULL)) {
1987 error_setg(errp, "Block node is read-only");
1988 } else {
1989 uint64_t current_perms, current_shared;
1990 bdrv_get_cumulative_perm(bs, &current_perms, &current_shared);
1991 if (current_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) {
1992 error_setg(errp, "Cannot make block node read-only, there is "
1993 "a writer on it");
1994 } else {
1995 error_setg(errp, "Cannot make block node read-only and create "
1996 "a writer on it");
1997 }
1998 }
1999
Kevin Wolf33a610c2016-12-15 13:04:20 +01002000 return -EPERM;
2001 }
2002
2003 /* Check this node */
2004 if (!drv) {
2005 return 0;
2006 }
2007
2008 if (drv->bdrv_check_perm) {
2009 return drv->bdrv_check_perm(bs, cumulative_perms,
2010 cumulative_shared_perms, errp);
2011 }
2012
Kevin Wolf78e421c2016-12-20 23:25:12 +01002013 /* Drivers that never have children can omit .bdrv_child_perm() */
Kevin Wolf33a610c2016-12-15 13:04:20 +01002014 if (!drv->bdrv_child_perm) {
Kevin Wolf78e421c2016-12-20 23:25:12 +01002015 assert(QLIST_EMPTY(&bs->children));
Kevin Wolf33a610c2016-12-15 13:04:20 +01002016 return 0;
2017 }
2018
2019 /* Check all children */
2020 QLIST_FOREACH(c, &bs->children, next) {
2021 uint64_t cur_perm, cur_shared;
Max Reitz9eab1542019-05-22 19:03:50 +02002022 bool child_tighten_restr;
2023
Kevin Wolf3121fb42017-09-14 14:42:12 +02002024 bdrv_child_perm(bs, c->bs, c, c->role, q,
Fam Zhengffd1a5a2017-05-03 00:35:38 +08002025 cumulative_perms, cumulative_shared_perms,
2026 &cur_perm, &cur_shared);
Max Reitz9eab1542019-05-22 19:03:50 +02002027 ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared, ignore_children,
2028 tighten_restrictions ? &child_tighten_restr
2029 : NULL,
2030 errp);
2031 if (tighten_restrictions) {
2032 *tighten_restrictions |= child_tighten_restr;
2033 }
Kevin Wolf33a610c2016-12-15 13:04:20 +01002034 if (ret < 0) {
2035 return ret;
2036 }
2037 }
2038
2039 return 0;
2040}
2041
2042/*
2043 * Notifies drivers that after a previous bdrv_check_perm() call, the
2044 * permission update is not performed and any preparations made for it (e.g.
2045 * taken file locks) need to be undone.
2046 *
2047 * This function recursively notifies all child nodes.
2048 */
2049static void bdrv_abort_perm_update(BlockDriverState *bs)
2050{
2051 BlockDriver *drv = bs->drv;
2052 BdrvChild *c;
2053
2054 if (!drv) {
2055 return;
2056 }
2057
2058 if (drv->bdrv_abort_perm_update) {
2059 drv->bdrv_abort_perm_update(bs);
2060 }
2061
2062 QLIST_FOREACH(c, &bs->children, next) {
2063 bdrv_child_abort_perm_update(c);
2064 }
2065}
2066
2067static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
2068 uint64_t cumulative_shared_perms)
2069{
2070 BlockDriver *drv = bs->drv;
2071 BdrvChild *c;
2072
2073 if (!drv) {
2074 return;
2075 }
2076
2077 /* Update this node */
2078 if (drv->bdrv_set_perm) {
2079 drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);
2080 }
2081
Kevin Wolf78e421c2016-12-20 23:25:12 +01002082 /* Drivers that never have children can omit .bdrv_child_perm() */
Kevin Wolf33a610c2016-12-15 13:04:20 +01002083 if (!drv->bdrv_child_perm) {
Kevin Wolf78e421c2016-12-20 23:25:12 +01002084 assert(QLIST_EMPTY(&bs->children));
Kevin Wolf33a610c2016-12-15 13:04:20 +01002085 return;
2086 }
2087
2088 /* Update all children */
2089 QLIST_FOREACH(c, &bs->children, next) {
2090 uint64_t cur_perm, cur_shared;
Kevin Wolfe0995dc2017-09-14 12:47:11 +02002091 bdrv_child_perm(bs, c->bs, c, c->role, NULL,
Fam Zhengffd1a5a2017-05-03 00:35:38 +08002092 cumulative_perms, cumulative_shared_perms,
2093 &cur_perm, &cur_shared);
Kevin Wolf33a610c2016-12-15 13:04:20 +01002094 bdrv_child_set_perm(c, cur_perm, cur_shared);
2095 }
2096}
2097
Kevin Wolfc7a0f2b2020-03-10 12:38:25 +01002098void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
2099 uint64_t *shared_perm)
Kevin Wolf33a610c2016-12-15 13:04:20 +01002100{
2101 BdrvChild *c;
2102 uint64_t cumulative_perms = 0;
2103 uint64_t cumulative_shared_perms = BLK_PERM_ALL;
2104
2105 QLIST_FOREACH(c, &bs->parents, next_parent) {
2106 cumulative_perms |= c->perm;
2107 cumulative_shared_perms &= c->shared_perm;
2108 }
2109
2110 *perm = cumulative_perms;
2111 *shared_perm = cumulative_shared_perms;
2112}
2113
Kevin Wolfd0833192017-01-16 18:26:20 +01002114static char *bdrv_child_user_desc(BdrvChild *c)
2115{
2116 if (c->role->get_parent_desc) {
2117 return c->role->get_parent_desc(c);
2118 }
2119
2120 return g_strdup("another user");
2121}
2122
Fam Zheng51761962017-05-03 00:35:36 +08002123char *bdrv_perm_names(uint64_t perm)
Kevin Wolfd0833192017-01-16 18:26:20 +01002124{
2125 struct perm_name {
2126 uint64_t perm;
2127 const char *name;
2128 } permissions[] = {
2129 { BLK_PERM_CONSISTENT_READ, "consistent read" },
2130 { BLK_PERM_WRITE, "write" },
2131 { BLK_PERM_WRITE_UNCHANGED, "write unchanged" },
2132 { BLK_PERM_RESIZE, "resize" },
2133 { BLK_PERM_GRAPH_MOD, "change children" },
2134 { 0, NULL }
2135 };
2136
Alberto Garciae2a74232020-01-10 18:15:18 +01002137 GString *result = g_string_sized_new(30);
Kevin Wolfd0833192017-01-16 18:26:20 +01002138 struct perm_name *p;
2139
2140 for (p = permissions; p->name; p++) {
2141 if (perm & p->perm) {
Alberto Garciae2a74232020-01-10 18:15:18 +01002142 if (result->len > 0) {
2143 g_string_append(result, ", ");
2144 }
2145 g_string_append(result, p->name);
Kevin Wolfd0833192017-01-16 18:26:20 +01002146 }
2147 }
2148
Alberto Garciae2a74232020-01-10 18:15:18 +01002149 return g_string_free(result, FALSE);
Kevin Wolfd0833192017-01-16 18:26:20 +01002150}
2151
Kevin Wolf33a610c2016-12-15 13:04:20 +01002152/*
2153 * Checks whether a new reference to @bs can be added if the new user requires
Kevin Wolf46181122017-03-06 15:00:13 +01002154 * @new_used_perm/@new_shared_perm as its permissions. If @ignore_children is
2155 * set, the BdrvChild objects in this list are ignored in the calculations;
2156 * this allows checking permission updates for an existing reference.
Kevin Wolf33a610c2016-12-15 13:04:20 +01002157 *
Max Reitz9eab1542019-05-22 19:03:50 +02002158 * See bdrv_check_perm() for the semantics of @tighten_restrictions.
2159 *
Kevin Wolf33a610c2016-12-15 13:04:20 +01002160 * Needs to be followed by a call to either bdrv_set_perm() or
2161 * bdrv_abort_perm_update(). */
Kevin Wolf3121fb42017-09-14 14:42:12 +02002162static int bdrv_check_update_perm(BlockDriverState *bs, BlockReopenQueue *q,
2163 uint64_t new_used_perm,
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002164 uint64_t new_shared_perm,
Max Reitz9eab1542019-05-22 19:03:50 +02002165 GSList *ignore_children,
2166 bool *tighten_restrictions,
2167 Error **errp)
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002168{
2169 BdrvChild *c;
Kevin Wolf33a610c2016-12-15 13:04:20 +01002170 uint64_t cumulative_perms = new_used_perm;
2171 uint64_t cumulative_shared_perms = new_shared_perm;
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002172
Max Reitz9eab1542019-05-22 19:03:50 +02002173 assert(!q || !tighten_restrictions);
2174
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002175 /* There is no reason why anyone couldn't tolerate write_unchanged */
2176 assert(new_shared_perm & BLK_PERM_WRITE_UNCHANGED);
2177
2178 QLIST_FOREACH(c, &bs->parents, next_parent) {
Kevin Wolf46181122017-03-06 15:00:13 +01002179 if (g_slist_find(ignore_children, c)) {
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002180 continue;
2181 }
2182
Kevin Wolfd0833192017-01-16 18:26:20 +01002183 if ((new_used_perm & c->shared_perm) != new_used_perm) {
2184 char *user = bdrv_child_user_desc(c);
2185 char *perm_names = bdrv_perm_names(new_used_perm & ~c->shared_perm);
Max Reitz9eab1542019-05-22 19:03:50 +02002186
2187 if (tighten_restrictions) {
2188 *tighten_restrictions = true;
2189 }
2190
Kevin Wolfd0833192017-01-16 18:26:20 +01002191 error_setg(errp, "Conflicts with use by %s as '%s', which does not "
2192 "allow '%s' on %s",
2193 user, c->name, perm_names, bdrv_get_node_name(c->bs));
2194 g_free(user);
2195 g_free(perm_names);
2196 return -EPERM;
2197 }
2198
2199 if ((c->perm & new_shared_perm) != c->perm) {
2200 char *user = bdrv_child_user_desc(c);
2201 char *perm_names = bdrv_perm_names(c->perm & ~new_shared_perm);
Max Reitz9eab1542019-05-22 19:03:50 +02002202
2203 if (tighten_restrictions) {
2204 *tighten_restrictions = true;
2205 }
2206
Kevin Wolfd0833192017-01-16 18:26:20 +01002207 error_setg(errp, "Conflicts with use by %s as '%s', which uses "
2208 "'%s' on %s",
2209 user, c->name, perm_names, bdrv_get_node_name(c->bs));
2210 g_free(user);
2211 g_free(perm_names);
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002212 return -EPERM;
2213 }
Kevin Wolf33a610c2016-12-15 13:04:20 +01002214
2215 cumulative_perms |= c->perm;
2216 cumulative_shared_perms &= c->shared_perm;
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002217 }
2218
Kevin Wolf3121fb42017-09-14 14:42:12 +02002219 return bdrv_check_perm(bs, q, cumulative_perms, cumulative_shared_perms,
Max Reitz9eab1542019-05-22 19:03:50 +02002220 ignore_children, tighten_restrictions, errp);
Kevin Wolf33a610c2016-12-15 13:04:20 +01002221}
2222
2223/* Needs to be followed by a call to either bdrv_child_set_perm() or
2224 * bdrv_child_abort_perm_update(). */
Kevin Wolf3121fb42017-09-14 14:42:12 +02002225static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
2226 uint64_t perm, uint64_t shared,
Max Reitz9eab1542019-05-22 19:03:50 +02002227 GSList *ignore_children,
2228 bool *tighten_restrictions, Error **errp)
Kevin Wolf33a610c2016-12-15 13:04:20 +01002229{
Kevin Wolf46181122017-03-06 15:00:13 +01002230 int ret;
2231
2232 ignore_children = g_slist_prepend(g_slist_copy(ignore_children), c);
Max Reitz9eab1542019-05-22 19:03:50 +02002233 ret = bdrv_check_update_perm(c->bs, q, perm, shared, ignore_children,
2234 tighten_restrictions, errp);
Kevin Wolf46181122017-03-06 15:00:13 +01002235 g_slist_free(ignore_children);
2236
Vladimir Sementsov-Ogievskiyf962e962019-02-23 22:20:40 +03002237 if (ret < 0) {
2238 return ret;
2239 }
2240
2241 if (!c->has_backup_perm) {
2242 c->has_backup_perm = true;
2243 c->backup_perm = c->perm;
2244 c->backup_shared_perm = c->shared_perm;
2245 }
2246 /*
2247 * Note: it's OK if c->has_backup_perm was already set, as we can find the
2248 * same child twice during check_perm procedure
2249 */
2250
2251 c->perm = perm;
2252 c->shared_perm = shared;
2253
2254 return 0;
Kevin Wolf33a610c2016-12-15 13:04:20 +01002255}
2256
Fam Zhengc1cef672017-03-14 10:30:50 +08002257static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared)
Kevin Wolf33a610c2016-12-15 13:04:20 +01002258{
2259 uint64_t cumulative_perms, cumulative_shared_perms;
2260
Vladimir Sementsov-Ogievskiyf962e962019-02-23 22:20:40 +03002261 c->has_backup_perm = false;
2262
Kevin Wolf33a610c2016-12-15 13:04:20 +01002263 c->perm = perm;
2264 c->shared_perm = shared;
2265
2266 bdrv_get_cumulative_perm(c->bs, &cumulative_perms,
2267 &cumulative_shared_perms);
2268 bdrv_set_perm(c->bs, cumulative_perms, cumulative_shared_perms);
2269}
2270
Fam Zhengc1cef672017-03-14 10:30:50 +08002271static void bdrv_child_abort_perm_update(BdrvChild *c)
Kevin Wolf33a610c2016-12-15 13:04:20 +01002272{
Vladimir Sementsov-Ogievskiyf962e962019-02-23 22:20:40 +03002273 if (c->has_backup_perm) {
2274 c->perm = c->backup_perm;
2275 c->shared_perm = c->backup_shared_perm;
2276 c->has_backup_perm = false;
2277 }
2278
Kevin Wolf33a610c2016-12-15 13:04:20 +01002279 bdrv_abort_perm_update(c->bs);
2280}
2281
2282int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
2283 Error **errp)
2284{
Max Reitz10467792019-05-22 19:03:51 +02002285 Error *local_err = NULL;
Kevin Wolf33a610c2016-12-15 13:04:20 +01002286 int ret;
Max Reitz10467792019-05-22 19:03:51 +02002287 bool tighten_restrictions;
Kevin Wolf33a610c2016-12-15 13:04:20 +01002288
Max Reitz10467792019-05-22 19:03:51 +02002289 ret = bdrv_child_check_perm(c, NULL, perm, shared, NULL,
2290 &tighten_restrictions, &local_err);
Kevin Wolf33a610c2016-12-15 13:04:20 +01002291 if (ret < 0) {
2292 bdrv_child_abort_perm_update(c);
Max Reitz10467792019-05-22 19:03:51 +02002293 if (tighten_restrictions) {
2294 error_propagate(errp, local_err);
2295 } else {
2296 /*
2297 * Our caller may intend to only loosen restrictions and
2298 * does not expect this function to fail. Errors are not
2299 * fatal in such a case, so we can just hide them from our
2300 * caller.
2301 */
2302 error_free(local_err);
2303 ret = 0;
2304 }
Kevin Wolf33a610c2016-12-15 13:04:20 +01002305 return ret;
2306 }
2307
2308 bdrv_child_set_perm(c, perm, shared);
2309
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002310 return 0;
2311}
2312
Max Reitzc1087f12019-05-22 19:03:46 +02002313int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
2314{
2315 uint64_t parent_perms, parent_shared;
2316 uint64_t perms, shared;
2317
2318 bdrv_get_cumulative_perm(bs, &parent_perms, &parent_shared);
2319 bdrv_child_perm(bs, c->bs, c, c->role, NULL, parent_perms, parent_shared,
2320 &perms, &shared);
2321
2322 return bdrv_child_try_set_perm(c, perms, shared, errp);
2323}
2324
Kevin Wolf6a1b9ee2016-12-15 11:27:32 +01002325void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
2326 const BdrvChildRole *role,
Kevin Wolfe0995dc2017-09-14 12:47:11 +02002327 BlockReopenQueue *reopen_queue,
Kevin Wolf6a1b9ee2016-12-15 11:27:32 +01002328 uint64_t perm, uint64_t shared,
2329 uint64_t *nperm, uint64_t *nshared)
2330{
Kevin Wolfe444fa82019-08-02 15:59:41 +02002331 *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
2332 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
Kevin Wolf6a1b9ee2016-12-15 11:27:32 +01002333}
2334
Kevin Wolf6b1a0442016-12-19 15:21:48 +01002335void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
2336 const BdrvChildRole *role,
Kevin Wolfe0995dc2017-09-14 12:47:11 +02002337 BlockReopenQueue *reopen_queue,
Kevin Wolf6b1a0442016-12-19 15:21:48 +01002338 uint64_t perm, uint64_t shared,
2339 uint64_t *nperm, uint64_t *nshared)
2340{
2341 bool backing = (role == &child_backing);
2342 assert(role == &child_backing || role == &child_file);
2343
2344 if (!backing) {
Kevin Wolf5fbfabd2017-11-30 17:38:43 +01002345 int flags = bdrv_reopen_get_flags(reopen_queue, bs);
2346
Kevin Wolf6b1a0442016-12-19 15:21:48 +01002347 /* Apart from the modifications below, the same permissions are
2348 * forwarded and left alone as for filters */
Kevin Wolfe0995dc2017-09-14 12:47:11 +02002349 bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
2350 &perm, &shared);
Kevin Wolf6b1a0442016-12-19 15:21:48 +01002351
2352 /* Format drivers may touch metadata even if the guest doesn't write */
Max Reitzcc022142018-06-06 21:37:00 +02002353 if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
Kevin Wolf6b1a0442016-12-19 15:21:48 +01002354 perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2355 }
2356
2357 /* bs->file always needs to be consistent because of the metadata. We
2358 * can never allow other users to resize or write to it. */
Kevin Wolf5fbfabd2017-11-30 17:38:43 +01002359 if (!(flags & BDRV_O_NO_IO)) {
2360 perm |= BLK_PERM_CONSISTENT_READ;
2361 }
Kevin Wolf6b1a0442016-12-19 15:21:48 +01002362 shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
2363 } else {
2364 /* We want consistent read from backing files if the parent needs it.
2365 * No other operations are performed on backing files. */
2366 perm &= BLK_PERM_CONSISTENT_READ;
2367
2368 /* If the parent can deal with changing data, we're okay with a
2369 * writable and resizable backing file. */
2370 /* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */
2371 if (shared & BLK_PERM_WRITE) {
2372 shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2373 } else {
2374 shared = 0;
2375 }
2376
2377 shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
2378 BLK_PERM_WRITE_UNCHANGED;
2379 }
2380
Kevin Wolf9c5e6592017-05-04 18:52:40 +02002381 if (bs->open_flags & BDRV_O_INACTIVE) {
2382 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2383 }
2384
Kevin Wolf6b1a0442016-12-19 15:21:48 +01002385 *nperm = perm;
2386 *nshared = shared;
2387}
2388
Max Reitz7b1d9c42019-11-08 13:34:51 +01002389uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)
2390{
2391 static const uint64_t permissions[] = {
2392 [BLOCK_PERMISSION_CONSISTENT_READ] = BLK_PERM_CONSISTENT_READ,
2393 [BLOCK_PERMISSION_WRITE] = BLK_PERM_WRITE,
2394 [BLOCK_PERMISSION_WRITE_UNCHANGED] = BLK_PERM_WRITE_UNCHANGED,
2395 [BLOCK_PERMISSION_RESIZE] = BLK_PERM_RESIZE,
2396 [BLOCK_PERMISSION_GRAPH_MOD] = BLK_PERM_GRAPH_MOD,
2397 };
2398
2399 QEMU_BUILD_BUG_ON(ARRAY_SIZE(permissions) != BLOCK_PERMISSION__MAX);
2400 QEMU_BUILD_BUG_ON(1UL << ARRAY_SIZE(permissions) != BLK_PERM_ALL + 1);
2401
2402 assert(qapi_perm < BLOCK_PERMISSION__MAX);
2403
2404 return permissions[qapi_perm];
2405}
2406
Kevin Wolf8ee03992017-03-06 13:45:28 +01002407static void bdrv_replace_child_noperm(BdrvChild *child,
2408 BlockDriverState *new_bs)
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002409{
2410 BlockDriverState *old_bs = child->bs;
Max Reitzdebc2922019-07-22 15:33:44 +02002411 int new_bs_quiesce_counter;
2412 int drain_saldo;
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002413
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02002414 assert(!child->frozen);
2415
Fam Zhengbb2614e2017-04-07 14:54:10 +08002416 if (old_bs && new_bs) {
2417 assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
2418 }
Max Reitzdebc2922019-07-22 15:33:44 +02002419
2420 new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0);
2421 drain_saldo = new_bs_quiesce_counter - child->parent_quiesce_counter;
2422
2423 /*
2424 * If the new child node is drained but the old one was not, flush
2425 * all outstanding requests to the old child node.
2426 */
2427 while (drain_saldo > 0 && child->role->drained_begin) {
2428 bdrv_parent_drained_begin_single(child, true);
2429 drain_saldo--;
2430 }
2431
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002432 if (old_bs) {
Kevin Wolfd736f112017-12-18 16:05:48 +01002433 /* Detach first so that the recursive drain sections coming from @child
2434 * are already gone and we only end the drain sections that came from
2435 * elsewhere. */
2436 if (child->role->detach) {
2437 child->role->detach(child);
2438 }
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002439 QLIST_REMOVE(child, next_parent);
2440 }
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002441
2442 child->bs = new_bs;
Kevin Wolf36fe1332016-05-17 14:51:55 +02002443
2444 if (new_bs) {
2445 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
Max Reitzdebc2922019-07-22 15:33:44 +02002446
2447 /*
2448 * Detaching the old node may have led to the new node's
2449 * quiesce_counter having been decreased. Not a problem, we
2450 * just need to recognize this here and then invoke
2451 * drained_end appropriately more often.
2452 */
2453 assert(new_bs->quiesce_counter <= new_bs_quiesce_counter);
2454 drain_saldo += new_bs->quiesce_counter - new_bs_quiesce_counter;
Kevin Wolf33a610c2016-12-15 13:04:20 +01002455
Kevin Wolfd736f112017-12-18 16:05:48 +01002456 /* Attach only after starting new drained sections, so that recursive
2457 * drain sections coming from @child don't get an extra .drained_begin
2458 * callback. */
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01002459 if (child->role->attach) {
2460 child->role->attach(child);
2461 }
Kevin Wolf36fe1332016-05-17 14:51:55 +02002462 }
Max Reitzdebc2922019-07-22 15:33:44 +02002463
2464 /*
2465 * If the old child node was drained but the new one is not, allow
2466 * requests to come in only after the new node has been attached.
2467 */
2468 while (drain_saldo < 0 && child->role->drained_end) {
2469 bdrv_parent_drained_end_single(child);
2470 drain_saldo++;
2471 }
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002472}
2473
Kevin Wolf466787f2017-03-08 14:44:07 +01002474/*
2475 * Updates @child to change its reference to point to @new_bs, including
2476 * checking and applying the necessary permisson updates both to the old node
2477 * and to @new_bs.
2478 *
2479 * NULL is passed as @new_bs for removing the reference before freeing @child.
2480 *
2481 * If @new_bs is not NULL, bdrv_check_perm() must be called beforehand, as this
2482 * function uses bdrv_set_perm() to update the permissions according to the new
2483 * reference that @new_bs gets.
2484 */
2485static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)
Kevin Wolf8ee03992017-03-06 13:45:28 +01002486{
2487 BlockDriverState *old_bs = child->bs;
2488 uint64_t perm, shared_perm;
2489
Kevin Wolf8aecf1d2017-08-03 17:02:57 +02002490 bdrv_replace_child_noperm(child, new_bs);
2491
Max Reitz87ace5f2019-05-22 19:03:49 +02002492 /*
2493 * Start with the new node's permissions. If @new_bs is a (direct
2494 * or indirect) child of @old_bs, we must complete the permission
2495 * update on @new_bs before we loosen the restrictions on @old_bs.
2496 * Otherwise, bdrv_check_perm() on @old_bs would re-initiate
2497 * updating the permissions of @new_bs, and thus not purely loosen
2498 * restrictions.
2499 */
2500 if (new_bs) {
2501 bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm);
2502 bdrv_set_perm(new_bs, perm, shared_perm);
2503 }
2504
Kevin Wolf8ee03992017-03-06 13:45:28 +01002505 if (old_bs) {
2506 /* Update permissions for old node. This is guaranteed to succeed
2507 * because we're just taking a parent away, so we're loosening
2508 * restrictions. */
Max Reitz10467792019-05-22 19:03:51 +02002509 bool tighten_restrictions;
2510 int ret;
2511
Kevin Wolf8ee03992017-03-06 13:45:28 +01002512 bdrv_get_cumulative_perm(old_bs, &perm, &shared_perm);
Max Reitz10467792019-05-22 19:03:51 +02002513 ret = bdrv_check_perm(old_bs, NULL, perm, shared_perm, NULL,
2514 &tighten_restrictions, NULL);
2515 assert(tighten_restrictions == false);
2516 if (ret < 0) {
2517 /* We only tried to loosen restrictions, so errors are not fatal */
2518 bdrv_abort_perm_update(old_bs);
2519 } else {
2520 bdrv_set_perm(old_bs, perm, shared_perm);
2521 }
Kevin Wolfad943dc2019-04-24 18:04:42 +02002522
2523 /* When the parent requiring a non-default AioContext is removed, the
2524 * node moves back to the main AioContext */
2525 bdrv_try_set_aio_context(old_bs, qemu_get_aio_context(), NULL);
Kevin Wolf8ee03992017-03-06 13:45:28 +01002526 }
Kevin Wolff54120f2014-05-26 11:09:59 +02002527}
2528
Alberto Garciab441dc72019-05-13 16:46:18 +03002529/*
2530 * This function steals the reference to child_bs from the caller.
2531 * That reference is later dropped by bdrv_root_unref_child().
2532 *
2533 * On failure NULL is returned, errp is set and the reference to
2534 * child_bs is also dropped.
Kevin Wolf132ada82019-04-24 17:41:46 +02002535 *
2536 * The caller must hold the AioContext lock @child_bs, but not that of @ctx
2537 * (unless @child_bs is already in @ctx).
Alberto Garciab441dc72019-05-13 16:46:18 +03002538 */
Kevin Wolff21d96d2016-03-08 13:47:46 +01002539BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
2540 const char *child_name,
Kevin Wolf36fe1332016-05-17 14:51:55 +02002541 const BdrvChildRole *child_role,
Kevin Wolf132ada82019-04-24 17:41:46 +02002542 AioContext *ctx,
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002543 uint64_t perm, uint64_t shared_perm,
2544 void *opaque, Error **errp)
Kevin Wolfdf581792015-06-15 11:53:47 +02002545{
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002546 BdrvChild *child;
Kevin Wolf132ada82019-04-24 17:41:46 +02002547 Error *local_err = NULL;
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002548 int ret;
2549
Max Reitz9eab1542019-05-22 19:03:50 +02002550 ret = bdrv_check_update_perm(child_bs, NULL, perm, shared_perm, NULL, NULL,
2551 errp);
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002552 if (ret < 0) {
Kevin Wolf33a610c2016-12-15 13:04:20 +01002553 bdrv_abort_perm_update(child_bs);
Alberto Garciab441dc72019-05-13 16:46:18 +03002554 bdrv_unref(child_bs);
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002555 return NULL;
2556 }
2557
2558 child = g_new(BdrvChild, 1);
Kevin Wolfdf581792015-06-15 11:53:47 +02002559 *child = (BdrvChild) {
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002560 .bs = NULL,
2561 .name = g_strdup(child_name),
2562 .role = child_role,
2563 .perm = perm,
2564 .shared_perm = shared_perm,
2565 .opaque = opaque,
Kevin Wolfdf581792015-06-15 11:53:47 +02002566 };
2567
Kevin Wolf132ada82019-04-24 17:41:46 +02002568 /* If the AioContexts don't match, first try to move the subtree of
2569 * child_bs into the AioContext of the new parent. If this doesn't work,
2570 * try moving the parent into the AioContext of child_bs instead. */
2571 if (bdrv_get_aio_context(child_bs) != ctx) {
2572 ret = bdrv_try_set_aio_context(child_bs, ctx, &local_err);
2573 if (ret < 0 && child_role->can_set_aio_ctx) {
Philippe Mathieu-Daudé0beab812020-02-18 10:43:52 +01002574 GSList *ignore = g_slist_prepend(NULL, child);
Kevin Wolf132ada82019-04-24 17:41:46 +02002575 ctx = bdrv_get_aio_context(child_bs);
2576 if (child_role->can_set_aio_ctx(child, ctx, &ignore, NULL)) {
2577 error_free(local_err);
2578 ret = 0;
2579 g_slist_free(ignore);
Philippe Mathieu-Daudé0beab812020-02-18 10:43:52 +01002580 ignore = g_slist_prepend(NULL, child);
Kevin Wolf132ada82019-04-24 17:41:46 +02002581 child_role->set_aio_ctx(child, ctx, &ignore);
2582 }
2583 g_slist_free(ignore);
2584 }
2585 if (ret < 0) {
2586 error_propagate(errp, local_err);
2587 g_free(child);
2588 bdrv_abort_perm_update(child_bs);
2589 return NULL;
2590 }
2591 }
2592
Kevin Wolf33a610c2016-12-15 13:04:20 +01002593 /* This performs the matching bdrv_set_perm() for the above check. */
Kevin Wolf466787f2017-03-08 14:44:07 +01002594 bdrv_replace_child(child, child_bs);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02002595
2596 return child;
Kevin Wolfdf581792015-06-15 11:53:47 +02002597}
2598
Alberto Garciab441dc72019-05-13 16:46:18 +03002599/*
2600 * This function transfers the reference to child_bs from the caller
2601 * to parent_bs. That reference is later dropped by parent_bs on
2602 * bdrv_close() or if someone calls bdrv_unref_child().
2603 *
2604 * On failure NULL is returned, errp is set and the reference to
2605 * child_bs is also dropped.
Kevin Wolf132ada82019-04-24 17:41:46 +02002606 *
2607 * If @parent_bs and @child_bs are in different AioContexts, the caller must
2608 * hold the AioContext lock for @child_bs, but not for @parent_bs.
Alberto Garciab441dc72019-05-13 16:46:18 +03002609 */
Wen Congyang98292c62016-05-10 15:36:38 +08002610BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
2611 BlockDriverState *child_bs,
2612 const char *child_name,
Kevin Wolf8b2ff522016-12-20 22:21:17 +01002613 const BdrvChildRole *child_role,
2614 Error **errp)
Kevin Wolff21d96d2016-03-08 13:47:46 +01002615{
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002616 BdrvChild *child;
Kevin Wolff68c5982016-12-20 15:51:12 +01002617 uint64_t perm, shared_perm;
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002618
Kevin Wolff68c5982016-12-20 15:51:12 +01002619 bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
2620
2621 assert(parent_bs->drv);
Kevin Wolfe0995dc2017-09-14 12:47:11 +02002622 bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
Fam Zhengffd1a5a2017-05-03 00:35:38 +08002623 perm, shared_perm, &perm, &shared_perm);
Kevin Wolff68c5982016-12-20 15:51:12 +01002624
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002625 child = bdrv_root_attach_child(child_bs, child_name, child_role,
Kevin Wolf132ada82019-04-24 17:41:46 +02002626 bdrv_get_aio_context(parent_bs),
Kevin Wolff68c5982016-12-20 15:51:12 +01002627 perm, shared_perm, parent_bs, errp);
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002628 if (child == NULL) {
2629 return NULL;
2630 }
2631
Kevin Wolff21d96d2016-03-08 13:47:46 +01002632 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
2633 return child;
2634}
2635
Kevin Wolf3f09bfb2015-09-15 11:58:23 +02002636static void bdrv_detach_child(BdrvChild *child)
Kevin Wolf33a60402015-06-15 13:51:04 +02002637{
Stefan Hajnoczi195ed8c2020-02-14 17:17:10 +00002638 QLIST_SAFE_REMOVE(child, next);
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002639
Kevin Wolf466787f2017-03-08 14:44:07 +01002640 bdrv_replace_child(child, NULL);
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002641
Kevin Wolf260fecf2015-04-27 13:46:22 +02002642 g_free(child->name);
Kevin Wolf33a60402015-06-15 13:51:04 +02002643 g_free(child);
2644}
2645
Kevin Wolff21d96d2016-03-08 13:47:46 +01002646void bdrv_root_unref_child(BdrvChild *child)
Kevin Wolf33a60402015-06-15 13:51:04 +02002647{
Kevin Wolf779020c2015-10-13 14:09:44 +02002648 BlockDriverState *child_bs;
2649
Kevin Wolff21d96d2016-03-08 13:47:46 +01002650 child_bs = child->bs;
2651 bdrv_detach_child(child);
2652 bdrv_unref(child_bs);
2653}
2654
Max Reitz3cf746b2019-07-03 19:28:07 +02002655/**
2656 * Clear all inherits_from pointers from children and grandchildren of
2657 * @root that point to @root, where necessary.
2658 */
2659static void bdrv_unset_inherits_from(BlockDriverState *root, BdrvChild *child)
Kevin Wolff21d96d2016-03-08 13:47:46 +01002660{
Max Reitz3cf746b2019-07-03 19:28:07 +02002661 BdrvChild *c;
Kevin Wolf33a60402015-06-15 13:51:04 +02002662
Max Reitz3cf746b2019-07-03 19:28:07 +02002663 if (child->bs->inherits_from == root) {
2664 /*
2665 * Remove inherits_from only when the last reference between root and
2666 * child->bs goes away.
2667 */
2668 QLIST_FOREACH(c, &root->children, next) {
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01002669 if (c != child && c->bs == child->bs) {
2670 break;
2671 }
2672 }
2673 if (c == NULL) {
2674 child->bs->inherits_from = NULL;
2675 }
Kevin Wolf33a60402015-06-15 13:51:04 +02002676 }
2677
Max Reitz3cf746b2019-07-03 19:28:07 +02002678 QLIST_FOREACH(c, &child->bs->children, next) {
2679 bdrv_unset_inherits_from(root, c);
2680 }
2681}
2682
2683void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
2684{
2685 if (child == NULL) {
2686 return;
2687 }
2688
2689 bdrv_unset_inherits_from(parent, child);
Kevin Wolff21d96d2016-03-08 13:47:46 +01002690 bdrv_root_unref_child(child);
Kevin Wolf33a60402015-06-15 13:51:04 +02002691}
2692
Kevin Wolf5c8cab42016-02-24 15:13:35 +01002693
2694static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
2695{
2696 BdrvChild *c;
2697 QLIST_FOREACH(c, &bs->parents, next_parent) {
2698 if (c->role->change_media) {
2699 c->role->change_media(c, load);
2700 }
2701 }
2702}
2703
Alberto Garcia0065c452018-10-31 18:16:37 +02002704/* Return true if you can reach parent going through child->inherits_from
2705 * recursively. If parent or child are NULL, return false */
2706static bool bdrv_inherits_from_recursive(BlockDriverState *child,
2707 BlockDriverState *parent)
2708{
2709 while (child && child != parent) {
2710 child = child->inherits_from;
2711 }
2712
2713 return child != NULL;
2714}
2715
Kevin Wolf5db15a52015-09-14 15:33:33 +02002716/*
2717 * Sets the backing file link of a BDS. A new reference is created; callers
2718 * which don't need their own reference any more must call bdrv_unref().
2719 */
Kevin Wolf12fa4af2017-02-17 20:42:32 +01002720void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
2721 Error **errp)
Fam Zheng8d24cce2014-05-23 21:29:45 +08002722{
Alberto Garcia0065c452018-10-31 18:16:37 +02002723 bool update_inherits_from = bdrv_chain_contains(bs, backing_hd) &&
2724 bdrv_inherits_from_recursive(backing_hd, bs);
2725
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02002726 if (bdrv_is_backing_chain_frozen(bs, backing_bs(bs), errp)) {
2727 return;
2728 }
2729
Kevin Wolf5db15a52015-09-14 15:33:33 +02002730 if (backing_hd) {
2731 bdrv_ref(backing_hd);
2732 }
Fam Zheng8d24cce2014-05-23 21:29:45 +08002733
Kevin Wolf760e0062015-06-17 14:55:21 +02002734 if (bs->backing) {
Kevin Wolf5db15a52015-09-14 15:33:33 +02002735 bdrv_unref_child(bs, bs->backing);
Fam Zheng826b6ca2014-05-23 21:29:47 +08002736 }
2737
Fam Zheng8d24cce2014-05-23 21:29:45 +08002738 if (!backing_hd) {
Kevin Wolf760e0062015-06-17 14:55:21 +02002739 bs->backing = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08002740 goto out;
2741 }
Kevin Wolf12fa4af2017-02-17 20:42:32 +01002742
Kevin Wolf8b2ff522016-12-20 22:21:17 +01002743 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
Kevin Wolf12fa4af2017-02-17 20:42:32 +01002744 errp);
Alberto Garcia0065c452018-10-31 18:16:37 +02002745 /* If backing_hd was already part of bs's backing chain, and
2746 * inherits_from pointed recursively to bs then let's update it to
2747 * point directly to bs (else it will become NULL). */
Alberto Garciab441dc72019-05-13 16:46:18 +03002748 if (bs->backing && update_inherits_from) {
Alberto Garcia0065c452018-10-31 18:16:37 +02002749 backing_hd->inherits_from = bs;
2750 }
Fam Zheng826b6ca2014-05-23 21:29:47 +08002751
Fam Zheng8d24cce2014-05-23 21:29:45 +08002752out:
Kevin Wolf3baca892014-07-16 17:48:16 +02002753 bdrv_refresh_limits(bs, NULL);
Fam Zheng8d24cce2014-05-23 21:29:45 +08002754}
2755
Kevin Wolf31ca6d02013-03-28 15:29:24 +01002756/*
2757 * Opens the backing file for a BlockDriverState if not yet open
2758 *
Kevin Wolfd9b7b052015-01-16 18:23:41 +01002759 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
2760 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
2761 * itself, all options starting with "${bdref_key}." are considered part of the
2762 * BlockdevRef.
2763 *
2764 * TODO Can this be unified with bdrv_open_image()?
Kevin Wolf31ca6d02013-03-28 15:29:24 +01002765 */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01002766int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
2767 const char *bdref_key, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02002768{
Max Reitz6b6833c2019-02-01 20:29:15 +01002769 char *backing_filename = NULL;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01002770 char *bdref_key_dot;
2771 const char *reference = NULL;
Kevin Wolf317fc442014-04-25 13:27:34 +02002772 int ret = 0;
Max Reitz998c2012019-02-01 20:29:08 +01002773 bool implicit_backing = false;
Fam Zheng8d24cce2014-05-23 21:29:45 +08002774 BlockDriverState *backing_hd;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01002775 QDict *options;
2776 QDict *tmp_parent_options = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +02002777 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02002778
Kevin Wolf760e0062015-06-17 14:55:21 +02002779 if (bs->backing != NULL) {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02002780 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02002781 }
2782
Kevin Wolf31ca6d02013-03-28 15:29:24 +01002783 /* NULL means an empty set of options */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01002784 if (parent_options == NULL) {
2785 tmp_parent_options = qdict_new();
2786 parent_options = tmp_parent_options;
Kevin Wolf31ca6d02013-03-28 15:29:24 +01002787 }
2788
Paolo Bonzini9156df12012-10-18 16:49:17 +02002789 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01002790
2791 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
2792 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
2793 g_free(bdref_key_dot);
2794
Markus Armbruster129c7d12017-03-30 19:43:12 +02002795 /*
2796 * Caution: while qdict_get_try_str() is fine, getting non-string
2797 * types would require more care. When @parent_options come from
2798 * -blockdev or blockdev_add, its members are typed according to
2799 * the QAPI schema, but when they come from -drive, they're all
2800 * QString.
2801 */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01002802 reference = qdict_get_try_str(parent_options, bdref_key);
2803 if (reference || qdict_haskey(options, "file.filename")) {
Max Reitz6b6833c2019-02-01 20:29:15 +01002804 /* keep backing_filename NULL */
Kevin Wolf1cb6f502013-04-12 20:27:07 +02002805 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02002806 qobject_unref(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02002807 goto free_exit;
Fam Zhengdbecebd2013-09-22 20:05:06 +08002808 } else {
Max Reitz998c2012019-02-01 20:29:08 +01002809 if (qdict_size(options) == 0) {
2810 /* If the user specifies options that do not modify the
2811 * backing file's behavior, we might still consider it the
2812 * implicit backing file. But it's easier this way, and
2813 * just specifying some of the backing BDS's options is
2814 * only possible with -drive anyway (otherwise the QAPI
2815 * schema forces the user to specify everything). */
2816 implicit_backing = !strcmp(bs->auto_backing_file, bs->backing_file);
2817 }
2818
Max Reitz6b6833c2019-02-01 20:29:15 +01002819 backing_filename = bdrv_get_full_backing_filename(bs, &local_err);
Max Reitz9f074292014-11-26 17:20:26 +01002820 if (local_err) {
2821 ret = -EINVAL;
2822 error_propagate(errp, local_err);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02002823 qobject_unref(options);
Max Reitz9f074292014-11-26 17:20:26 +01002824 goto free_exit;
2825 }
Paolo Bonzini9156df12012-10-18 16:49:17 +02002826 }
2827
Kevin Wolf8ee79e72014-06-04 15:09:35 +02002828 if (!bs->drv || !bs->drv->supports_backing) {
2829 ret = -EINVAL;
2830 error_setg(errp, "Driver doesn't support backing files");
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02002831 qobject_unref(options);
Kevin Wolf8ee79e72014-06-04 15:09:35 +02002832 goto free_exit;
2833 }
2834
Peter Krempa6bff5972017-10-12 16:14:10 +02002835 if (!reference &&
2836 bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
Eric Blake46f5ac22017-04-27 16:58:17 -05002837 qdict_put_str(options, "driver", bs->backing_format);
Paolo Bonzini9156df12012-10-18 16:49:17 +02002838 }
2839
Max Reitz6b6833c2019-02-01 20:29:15 +01002840 backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs,
2841 &child_backing, errp);
Max Reitz5b363932016-05-17 16:41:31 +02002842 if (!backing_hd) {
Paolo Bonzini9156df12012-10-18 16:49:17 +02002843 bs->open_flags |= BDRV_O_NO_BACKING;
Markus Armbrustere43bfd92015-12-18 16:35:15 +01002844 error_prepend(errp, "Could not open backing file: ");
Max Reitz5b363932016-05-17 16:41:31 +02002845 ret = -EINVAL;
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02002846 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02002847 }
Kevin Wolfdf581792015-06-15 11:53:47 +02002848
Max Reitz998c2012019-02-01 20:29:08 +01002849 if (implicit_backing) {
2850 bdrv_refresh_filename(backing_hd);
2851 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
2852 backing_hd->filename);
2853 }
2854
Kevin Wolf5db15a52015-09-14 15:33:33 +02002855 /* Hook up the backing file link; drop our reference, bs owns the
2856 * backing_hd reference now */
Kevin Wolf12fa4af2017-02-17 20:42:32 +01002857 bdrv_set_backing_hd(bs, backing_hd, &local_err);
Kevin Wolf5db15a52015-09-14 15:33:33 +02002858 bdrv_unref(backing_hd);
Kevin Wolf12fa4af2017-02-17 20:42:32 +01002859 if (local_err) {
Fam Zheng8cd1a3e2017-03-17 09:56:30 +08002860 error_propagate(errp, local_err);
Kevin Wolf12fa4af2017-02-17 20:42:32 +01002861 ret = -EINVAL;
2862 goto free_exit;
2863 }
Peter Feinerd80ac652014-01-08 19:43:25 +00002864
Kevin Wolfd9b7b052015-01-16 18:23:41 +01002865 qdict_del(parent_options, bdref_key);
2866
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02002867free_exit:
2868 g_free(backing_filename);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02002869 qobject_unref(tmp_parent_options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02002870 return ret;
Paolo Bonzini9156df12012-10-18 16:49:17 +02002871}
2872
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01002873static BlockDriverState *
2874bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
2875 BlockDriverState *parent, const BdrvChildRole *child_role,
2876 bool allow_none, Error **errp)
Max Reitzda557aa2013-12-20 19:28:11 +01002877{
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01002878 BlockDriverState *bs = NULL;
Max Reitzda557aa2013-12-20 19:28:11 +01002879 QDict *image_options;
Max Reitzda557aa2013-12-20 19:28:11 +01002880 char *bdref_key_dot;
2881 const char *reference;
2882
Kevin Wolfdf581792015-06-15 11:53:47 +02002883 assert(child_role != NULL);
Max Reitzf67503e2014-02-18 18:33:05 +01002884
Max Reitzda557aa2013-12-20 19:28:11 +01002885 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
2886 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
2887 g_free(bdref_key_dot);
2888
Markus Armbruster129c7d12017-03-30 19:43:12 +02002889 /*
2890 * Caution: while qdict_get_try_str() is fine, getting non-string
2891 * types would require more care. When @options come from
2892 * -blockdev or blockdev_add, its members are typed according to
2893 * the QAPI schema, but when they come from -drive, they're all
2894 * QString.
2895 */
Max Reitzda557aa2013-12-20 19:28:11 +01002896 reference = qdict_get_try_str(options, bdref_key);
2897 if (!filename && !reference && !qdict_size(image_options)) {
Kevin Wolfb4b059f2015-06-15 13:24:19 +02002898 if (!allow_none) {
Max Reitzda557aa2013-12-20 19:28:11 +01002899 error_setg(errp, "A block device must be specified for \"%s\"",
2900 bdref_key);
Max Reitzda557aa2013-12-20 19:28:11 +01002901 }
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02002902 qobject_unref(image_options);
Max Reitzda557aa2013-12-20 19:28:11 +01002903 goto done;
2904 }
2905
Max Reitz5b363932016-05-17 16:41:31 +02002906 bs = bdrv_open_inherit(filename, reference, image_options, 0,
2907 parent, child_role, errp);
2908 if (!bs) {
Kevin Wolfdf581792015-06-15 11:53:47 +02002909 goto done;
2910 }
2911
Max Reitzda557aa2013-12-20 19:28:11 +01002912done:
2913 qdict_del(options, bdref_key);
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01002914 return bs;
2915}
2916
2917/*
2918 * Opens a disk image whose options are given as BlockdevRef in another block
2919 * device's options.
2920 *
2921 * If allow_none is true, no image will be opened if filename is false and no
2922 * BlockdevRef is given. NULL will be returned, but errp remains unset.
2923 *
2924 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
2925 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
2926 * itself, all options starting with "${bdref_key}." are considered part of the
2927 * BlockdevRef.
2928 *
2929 * The BlockdevRef will be removed from the options QDict.
2930 */
2931BdrvChild *bdrv_open_child(const char *filename,
2932 QDict *options, const char *bdref_key,
2933 BlockDriverState *parent,
2934 const BdrvChildRole *child_role,
2935 bool allow_none, Error **errp)
2936{
2937 BlockDriverState *bs;
2938
2939 bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,
2940 allow_none, errp);
2941 if (bs == NULL) {
2942 return NULL;
2943 }
2944
Alberto Garciab441dc72019-05-13 16:46:18 +03002945 return bdrv_attach_child(parent, bs, bdref_key, child_role, errp);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02002946}
2947
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01002948/* TODO Future callers may need to specify parent/child_role in order for
2949 * option inheritance to work. Existing callers use it for the root node. */
2950BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
2951{
2952 BlockDriverState *bs = NULL;
2953 Error *local_err = NULL;
2954 QObject *obj = NULL;
2955 QDict *qdict = NULL;
2956 const char *reference = NULL;
2957 Visitor *v = NULL;
2958
2959 if (ref->type == QTYPE_QSTRING) {
2960 reference = ref->u.reference;
2961 } else {
2962 BlockdevOptions *options = &ref->u.definition;
2963 assert(ref->type == QTYPE_QDICT);
2964
2965 v = qobject_output_visitor_new(&obj);
2966 visit_type_BlockdevOptions(v, NULL, &options, &local_err);
2967 if (local_err) {
2968 error_propagate(errp, local_err);
2969 goto fail;
2970 }
2971 visit_complete(v, &obj);
2972
Max Reitz7dc847e2018-02-24 16:40:29 +01002973 qdict = qobject_to(QDict, obj);
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01002974 qdict_flatten(qdict);
2975
2976 /* bdrv_open_inherit() defaults to the values in bdrv_flags (for
2977 * compatibility with other callers) rather than what we want as the
2978 * real defaults. Apply the defaults here instead. */
2979 qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
2980 qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
2981 qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off");
Kevin Wolfe35bdc12018-10-05 18:57:40 +02002982 qdict_set_default_str(qdict, BDRV_OPT_AUTO_READ_ONLY, "off");
2983
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01002984 }
2985
2986 bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, errp);
2987 obj = NULL;
2988
2989fail:
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02002990 qobject_unref(obj);
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01002991 visit_free(v);
2992 return bs;
2993}
2994
Max Reitz66836182016-05-17 16:41:27 +02002995static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
2996 int flags,
2997 QDict *snapshot_options,
2998 Error **errp)
Kevin Wolfb9988752014-04-03 12:09:34 +02002999{
3000 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003001 char *tmp_filename = g_malloc0(PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02003002 int64_t total_size;
Chunyan Liu83d05212014-06-05 17:20:51 +08003003 QemuOpts *opts = NULL;
Eric Blakeff6ed712017-04-27 16:58:18 -05003004 BlockDriverState *bs_snapshot = NULL;
Kevin Wolfb2c28322017-02-20 12:46:42 +01003005 Error *local_err = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02003006 int ret;
3007
3008 /* if snapshot, we create a temporary backing file and open it
3009 instead of opening 'filename' directly */
3010
3011 /* Get the required size from the image */
Kevin Wolff1877432014-04-04 17:07:19 +02003012 total_size = bdrv_getlength(bs);
3013 if (total_size < 0) {
3014 error_setg_errno(errp, -total_size, "Could not get image size");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003015 goto out;
Kevin Wolff1877432014-04-04 17:07:19 +02003016 }
Kevin Wolfb9988752014-04-03 12:09:34 +02003017
3018 /* Create the temporary image */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003019 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02003020 if (ret < 0) {
3021 error_setg_errno(errp, -ret, "Could not get temporary filename");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003022 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02003023 }
3024
Max Reitzef810432014-12-02 18:32:42 +01003025 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003026 &error_abort);
Markus Armbruster39101f22015-02-12 16:46:36 +01003027 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
Markus Armbrustere43bfd92015-12-18 16:35:15 +01003028 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
Chunyan Liu83d05212014-06-05 17:20:51 +08003029 qemu_opts_del(opts);
Kevin Wolfb9988752014-04-03 12:09:34 +02003030 if (ret < 0) {
Markus Armbrustere43bfd92015-12-18 16:35:15 +01003031 error_prepend(errp, "Could not create temporary overlay '%s': ",
3032 tmp_filename);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003033 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02003034 }
3035
Kevin Wolf73176be2016-03-07 13:02:15 +01003036 /* Prepare options QDict for the temporary file */
Eric Blake46f5ac22017-04-27 16:58:17 -05003037 qdict_put_str(snapshot_options, "file.driver", "file");
3038 qdict_put_str(snapshot_options, "file.filename", tmp_filename);
3039 qdict_put_str(snapshot_options, "driver", "qcow2");
Kevin Wolfb9988752014-04-03 12:09:34 +02003040
Max Reitz5b363932016-05-17 16:41:31 +02003041 bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
Kevin Wolf73176be2016-03-07 13:02:15 +01003042 snapshot_options = NULL;
Max Reitz5b363932016-05-17 16:41:31 +02003043 if (!bs_snapshot) {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003044 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02003045 }
3046
Eric Blakeff6ed712017-04-27 16:58:18 -05003047 /* bdrv_append() consumes a strong reference to bs_snapshot
3048 * (i.e. it will call bdrv_unref() on it) even on error, so in
3049 * order to be able to return one, we have to increase
3050 * bs_snapshot's refcount here */
Max Reitz66836182016-05-17 16:41:27 +02003051 bdrv_ref(bs_snapshot);
Kevin Wolfb2c28322017-02-20 12:46:42 +01003052 bdrv_append(bs_snapshot, bs, &local_err);
3053 if (local_err) {
3054 error_propagate(errp, local_err);
Eric Blakeff6ed712017-04-27 16:58:18 -05003055 bs_snapshot = NULL;
Kevin Wolfb2c28322017-02-20 12:46:42 +01003056 goto out;
3057 }
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003058
3059out:
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003060 qobject_unref(snapshot_options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003061 g_free(tmp_filename);
Eric Blakeff6ed712017-04-27 16:58:18 -05003062 return bs_snapshot;
Kevin Wolfb9988752014-04-03 12:09:34 +02003063}
3064
Max Reitzda557aa2013-12-20 19:28:11 +01003065/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003066 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01003067 *
3068 * options is a QDict of options to pass to the block drivers, or NULL for an
3069 * empty set of options. The reference to the QDict belongs to the block layer
3070 * after the call (even on failure), so if the caller intends to reuse the
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003071 * dictionary, it needs to use qobject_ref() before calling bdrv_open.
Max Reitzf67503e2014-02-18 18:33:05 +01003072 *
3073 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
3074 * If it is not NULL, the referenced BDS will be reused.
Max Reitzddf56362014-02-18 18:33:06 +01003075 *
3076 * The reference parameter may be used to specify an existing block device which
3077 * should be opened. If specified, neither options nor a filename may be given,
3078 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003079 */
Max Reitz5b363932016-05-17 16:41:31 +02003080static BlockDriverState *bdrv_open_inherit(const char *filename,
3081 const char *reference,
3082 QDict *options, int flags,
3083 BlockDriverState *parent,
3084 const BdrvChildRole *child_role,
3085 Error **errp)
bellardea2384d2004-08-01 21:59:26 +00003086{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003087 int ret;
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003088 BlockBackend *file = NULL;
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003089 BlockDriverState *bs;
Max Reitzce343772015-08-26 19:47:50 +02003090 BlockDriver *drv = NULL;
Alberto Garcia2f624b82018-06-29 14:37:00 +03003091 BdrvChild *child;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02003092 const char *drvname;
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02003093 const char *backing;
Max Reitz34b5d2c2013-09-05 14:45:29 +02003094 Error *local_err = NULL;
Kevin Wolf73176be2016-03-07 13:02:15 +01003095 QDict *snapshot_options = NULL;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02003096 int snapshot_flags = 0;
bellard712e7872005-04-28 21:09:32 +00003097
Kevin Wolff3930ed2015-04-08 13:43:47 +02003098 assert(!child_role || !flags);
3099 assert(!child_role == !parent);
Max Reitzf67503e2014-02-18 18:33:05 +01003100
Max Reitzddf56362014-02-18 18:33:06 +01003101 if (reference) {
3102 bool options_non_empty = options ? qdict_size(options) : false;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003103 qobject_unref(options);
Max Reitzddf56362014-02-18 18:33:06 +01003104
Max Reitzddf56362014-02-18 18:33:06 +01003105 if (filename || options_non_empty) {
3106 error_setg(errp, "Cannot reference an existing block device with "
3107 "additional options or a new filename");
Max Reitz5b363932016-05-17 16:41:31 +02003108 return NULL;
Max Reitzddf56362014-02-18 18:33:06 +01003109 }
3110
3111 bs = bdrv_lookup_bs(reference, reference, errp);
3112 if (!bs) {
Max Reitz5b363932016-05-17 16:41:31 +02003113 return NULL;
Max Reitzddf56362014-02-18 18:33:06 +01003114 }
Kevin Wolf76b22322016-04-04 17:11:13 +02003115
Max Reitzddf56362014-02-18 18:33:06 +01003116 bdrv_ref(bs);
Max Reitz5b363932016-05-17 16:41:31 +02003117 return bs;
Max Reitzddf56362014-02-18 18:33:06 +01003118 }
3119
Max Reitz5b363932016-05-17 16:41:31 +02003120 bs = bdrv_new();
Max Reitzf67503e2014-02-18 18:33:05 +01003121
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01003122 /* NULL means an empty set of options */
3123 if (options == NULL) {
3124 options = qdict_new();
3125 }
3126
Kevin Wolf145f5982015-05-08 16:15:03 +02003127 /* json: syntax counts as explicit options, as if in the QDict */
Kevin Wolfde3b53f2015-10-29 15:24:41 +01003128 parse_json_protocol(options, &filename, &local_err);
3129 if (local_err) {
Kevin Wolfde3b53f2015-10-29 15:24:41 +01003130 goto fail;
3131 }
3132
Kevin Wolf145f5982015-05-08 16:15:03 +02003133 bs->explicit_options = qdict_clone_shallow(options);
3134
Kevin Wolff3930ed2015-04-08 13:43:47 +02003135 if (child_role) {
Kevin Wolfbddcec32015-04-09 18:47:50 +02003136 bs->inherits_from = parent;
Kevin Wolf8e2160e2015-04-29 17:29:39 +02003137 child_role->inherit_options(&flags, options,
3138 parent->open_flags, parent->options);
Kevin Wolff3930ed2015-04-08 13:43:47 +02003139 }
3140
Kevin Wolfde3b53f2015-10-29 15:24:41 +01003141 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
Kevin Wolf462f5bc2014-05-26 11:39:55 +02003142 if (local_err) {
3143 goto fail;
3144 }
3145
Markus Armbruster129c7d12017-03-30 19:43:12 +02003146 /*
3147 * Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags.
3148 * Caution: getting a boolean member of @options requires care.
3149 * When @options come from -blockdev or blockdev_add, members are
3150 * typed according to the QAPI schema, but when they come from
3151 * -drive, they're all QString.
3152 */
Alberto Garciaf87a0e22016-09-15 17:53:02 +03003153 if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
3154 !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
3155 flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
3156 } else {
3157 flags &= ~BDRV_O_RDWR;
Alberto Garcia14499ea2016-09-15 17:53:00 +03003158 }
3159
3160 if (flags & BDRV_O_SNAPSHOT) {
3161 snapshot_options = qdict_new();
3162 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
3163 flags, options);
Alberto Garciaf87a0e22016-09-15 17:53:02 +03003164 /* Let bdrv_backing_options() override "read-only" */
3165 qdict_del(options, BDRV_OPT_READ_ONLY);
Alberto Garcia14499ea2016-09-15 17:53:00 +03003166 bdrv_backing_options(&flags, options, flags, options);
3167 }
3168
Kevin Wolf62392eb2015-04-24 16:38:02 +02003169 bs->open_flags = flags;
3170 bs->options = options;
3171 options = qdict_clone_shallow(options);
3172
Kevin Wolf76c591b2014-06-04 14:19:44 +02003173 /* Find the right image format driver */
Markus Armbruster129c7d12017-03-30 19:43:12 +02003174 /* See cautionary note on accessing @options above */
Kevin Wolf76c591b2014-06-04 14:19:44 +02003175 drvname = qdict_get_try_str(options, "driver");
3176 if (drvname) {
3177 drv = bdrv_find_format(drvname);
Kevin Wolf76c591b2014-06-04 14:19:44 +02003178 if (!drv) {
3179 error_setg(errp, "Unknown driver: '%s'", drvname);
Kevin Wolf76c591b2014-06-04 14:19:44 +02003180 goto fail;
3181 }
3182 }
3183
3184 assert(drvname || !(flags & BDRV_O_PROTOCOL));
Kevin Wolf76c591b2014-06-04 14:19:44 +02003185
Markus Armbruster129c7d12017-03-30 19:43:12 +02003186 /* See cautionary note on accessing @options above */
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02003187 backing = qdict_get_try_str(options, "backing");
Max Reitze59a0cf2018-02-24 16:40:32 +01003188 if (qobject_to(QNull, qdict_get(options, "backing")) != NULL ||
3189 (backing && *backing == '\0'))
3190 {
Max Reitz4f7be282018-02-24 16:40:33 +01003191 if (backing) {
3192 warn_report("Use of \"backing\": \"\" is deprecated; "
3193 "use \"backing\": null instead");
3194 }
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02003195 flags |= BDRV_O_NO_BACKING;
Kevin Wolfae0f57f2019-11-08 09:36:35 +01003196 qdict_del(bs->explicit_options, "backing");
3197 qdict_del(bs->options, "backing");
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02003198 qdict_del(options, "backing");
3199 }
3200
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003201 /* Open image file without format layer. This BlockBackend is only used for
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01003202 * probing, the block drivers will do their own bdrv_open_child() for the
3203 * same BDS, which is why we put the node name back into options. */
Kevin Wolff4788ad2014-06-03 16:44:19 +02003204 if ((flags & BDRV_O_PROTOCOL) == 0) {
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003205 BlockDriverState *file_bs;
3206
3207 file_bs = bdrv_open_child_bs(filename, options, "file", bs,
3208 &child_file, true, &local_err);
Kevin Wolf1fdd6932015-06-15 14:11:51 +02003209 if (local_err) {
Max Reitz5469a2a2014-02-18 18:33:10 +01003210 goto fail;
3211 }
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003212 if (file_bs != NULL) {
Kevin Wolfdacaa162017-11-20 14:59:13 +01003213 /* Not requesting BLK_PERM_CONSISTENT_READ because we're only
3214 * looking at the header to guess the image format. This works even
3215 * in cases where a guest would not see a consistent state. */
Kevin Wolfd861ab32019-04-25 14:25:10 +02003216 file = blk_new(bdrv_get_aio_context(file_bs), 0, BLK_PERM_ALL);
Kevin Wolfd7086422017-01-13 19:02:32 +01003217 blk_insert_bs(file, file_bs, &local_err);
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003218 bdrv_unref(file_bs);
Kevin Wolfd7086422017-01-13 19:02:32 +01003219 if (local_err) {
3220 goto fail;
3221 }
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003222
Eric Blake46f5ac22017-04-27 16:58:17 -05003223 qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01003224 }
Max Reitz5469a2a2014-02-18 18:33:10 +01003225 }
3226
Kevin Wolf76c591b2014-06-04 14:19:44 +02003227 /* Image format probing */
Kevin Wolf38f3ef52014-11-20 16:27:12 +01003228 bs->probed = !drv;
Kevin Wolf76c591b2014-06-04 14:19:44 +02003229 if (!drv && file) {
Kevin Wolfcf2ab8f2016-06-20 18:24:02 +02003230 ret = find_image_format(file, filename, &drv, &local_err);
Kevin Wolf17b005f2014-05-27 10:50:29 +02003231 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02003232 goto fail;
Max Reitz2a05cbe2013-12-20 19:28:10 +01003233 }
Kevin Wolf62392eb2015-04-24 16:38:02 +02003234 /*
3235 * This option update would logically belong in bdrv_fill_options(),
3236 * but we first need to open bs->file for the probing to work, while
3237 * opening bs->file already requires the (mostly) final set of options
3238 * so that cache mode etc. can be inherited.
3239 *
3240 * Adding the driver later is somewhat ugly, but it's not an option
3241 * that would ever be inherited, so it's correct. We just need to make
3242 * sure to update both bs->options (which has the full effective
3243 * options for bs) and options (which has file.* already removed).
3244 */
Eric Blake46f5ac22017-04-27 16:58:17 -05003245 qdict_put_str(bs->options, "driver", drv->format_name);
3246 qdict_put_str(options, "driver", drv->format_name);
Kevin Wolf76c591b2014-06-04 14:19:44 +02003247 } else if (!drv) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02003248 error_setg(errp, "Must specify either driver or file");
Kevin Wolf8bfea152014-04-11 19:16:36 +02003249 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01003250 }
3251
Max Reitz53a29512015-03-19 14:53:16 -04003252 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
3253 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
3254 /* file must be NULL if a protocol BDS is about to be created
3255 * (the inverse results in an error message from bdrv_open_common()) */
3256 assert(!(flags & BDRV_O_PROTOCOL) || !file);
3257
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003258 /* Open the image */
Kevin Wolf82dc8b42016-01-11 19:07:50 +01003259 ret = bdrv_open_common(bs, file, options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003260 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02003261 goto fail;
Christoph Hellwig69873072010-01-20 18:13:25 +01003262 }
3263
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01003264 if (file) {
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003265 blk_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01003266 file = NULL;
3267 }
3268
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003269 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02003270 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003271 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003272 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01003273 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003274 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003275 }
3276
Alberto Garcia50196d72018-09-06 12:37:03 +03003277 /* Remove all children options and references
3278 * from bs->options and bs->explicit_options */
Alberto Garcia2f624b82018-06-29 14:37:00 +03003279 QLIST_FOREACH(child, &bs->children, next) {
3280 char *child_key_dot;
3281 child_key_dot = g_strdup_printf("%s.", child->name);
3282 qdict_extract_subqdict(bs->explicit_options, NULL, child_key_dot);
3283 qdict_extract_subqdict(bs->options, NULL, child_key_dot);
Alberto Garcia50196d72018-09-06 12:37:03 +03003284 qdict_del(bs->explicit_options, child->name);
3285 qdict_del(bs->options, child->name);
Alberto Garcia2f624b82018-06-29 14:37:00 +03003286 g_free(child_key_dot);
3287 }
3288
Kevin Wolfb6ad4912013-03-15 10:35:04 +01003289 /* Check if any unknown options were used */
Paolo Bonzini7ad27572017-01-04 15:59:14 +01003290 if (qdict_size(options) != 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01003291 const QDictEntry *entry = qdict_first(options);
Max Reitz5acd9d82014-02-18 18:33:11 +01003292 if (flags & BDRV_O_PROTOCOL) {
3293 error_setg(errp, "Block protocol '%s' doesn't support the option "
3294 "'%s'", drv->format_name, entry->key);
3295 } else {
Max Reitzd0e46a52016-03-16 19:54:34 +01003296 error_setg(errp,
3297 "Block format '%s' does not support the option '%s'",
3298 drv->format_name, entry->key);
Max Reitz5acd9d82014-02-18 18:33:11 +01003299 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01003300
Kevin Wolfb6ad4912013-03-15 10:35:04 +01003301 goto close_and_fail;
3302 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01003303
Daniel P. Berrangec01c2142017-06-23 17:24:16 +01003304 bdrv_parent_cb_change_media(bs, true);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003305
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003306 qobject_unref(options);
Alberto Garcia8961be32018-09-06 17:25:41 +03003307 options = NULL;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02003308
3309 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
3310 * temporary snapshot afterwards. */
3311 if (snapshot_flags) {
Max Reitz66836182016-05-17 16:41:27 +02003312 BlockDriverState *snapshot_bs;
3313 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
3314 snapshot_options, &local_err);
Kevin Wolf73176be2016-03-07 13:02:15 +01003315 snapshot_options = NULL;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02003316 if (local_err) {
3317 goto close_and_fail;
3318 }
Max Reitz5b363932016-05-17 16:41:31 +02003319 /* We are not going to return bs but the overlay on top of it
3320 * (snapshot_bs); thus, we have to drop the strong reference to bs
3321 * (which we obtained by calling bdrv_new()). bs will not be deleted,
3322 * though, because the overlay still has a reference to it. */
3323 bdrv_unref(bs);
3324 bs = snapshot_bs;
Max Reitz66836182016-05-17 16:41:27 +02003325 }
3326
Max Reitz5b363932016-05-17 16:41:31 +02003327 return bs;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003328
Kevin Wolf8bfea152014-04-11 19:16:36 +02003329fail:
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003330 blk_unref(file);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003331 qobject_unref(snapshot_options);
3332 qobject_unref(bs->explicit_options);
3333 qobject_unref(bs->options);
3334 qobject_unref(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01003335 bs->options = NULL;
Manos Pitsidianakis998cbd62017-07-14 17:35:47 +03003336 bs->explicit_options = NULL;
Max Reitz5b363932016-05-17 16:41:31 +02003337 bdrv_unref(bs);
Eduardo Habkost621ff942016-06-13 18:57:56 -03003338 error_propagate(errp, local_err);
Max Reitz5b363932016-05-17 16:41:31 +02003339 return NULL;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01003340
Kevin Wolfb6ad4912013-03-15 10:35:04 +01003341close_and_fail:
Max Reitz5b363932016-05-17 16:41:31 +02003342 bdrv_unref(bs);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003343 qobject_unref(snapshot_options);
3344 qobject_unref(options);
Eduardo Habkost621ff942016-06-13 18:57:56 -03003345 error_propagate(errp, local_err);
Max Reitz5b363932016-05-17 16:41:31 +02003346 return NULL;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003347}
3348
Max Reitz5b363932016-05-17 16:41:31 +02003349BlockDriverState *bdrv_open(const char *filename, const char *reference,
3350 QDict *options, int flags, Error **errp)
Kevin Wolff3930ed2015-04-08 13:43:47 +02003351{
Max Reitz5b363932016-05-17 16:41:31 +02003352 return bdrv_open_inherit(filename, reference, options, flags, NULL,
Max Reitzce343772015-08-26 19:47:50 +02003353 NULL, errp);
Kevin Wolff3930ed2015-04-08 13:43:47 +02003354}
3355
Alberto Garciafaf116b2019-03-12 18:48:49 +02003356/* Return true if the NULL-terminated @list contains @str */
3357static bool is_str_in_list(const char *str, const char *const *list)
3358{
3359 if (str && list) {
3360 int i;
3361 for (i = 0; list[i] != NULL; i++) {
3362 if (!strcmp(str, list[i])) {
3363 return true;
3364 }
3365 }
3366 }
3367 return false;
3368}
3369
3370/*
3371 * Check that every option set in @bs->options is also set in
3372 * @new_opts.
3373 *
3374 * Options listed in the common_options list and in
3375 * @bs->drv->mutable_opts are skipped.
3376 *
3377 * Return 0 on success, otherwise return -EINVAL and set @errp.
3378 */
3379static int bdrv_reset_options_allowed(BlockDriverState *bs,
3380 const QDict *new_opts, Error **errp)
3381{
3382 const QDictEntry *e;
3383 /* These options are common to all block drivers and are handled
3384 * in bdrv_reopen_prepare() so they can be left out of @new_opts */
3385 const char *const common_options[] = {
3386 "node-name", "discard", "cache.direct", "cache.no-flush",
3387 "read-only", "auto-read-only", "detect-zeroes", NULL
3388 };
3389
3390 for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {
3391 if (!qdict_haskey(new_opts, e->key) &&
3392 !is_str_in_list(e->key, common_options) &&
3393 !is_str_in_list(e->key, bs->drv->mutable_opts)) {
3394 error_setg(errp, "Option '%s' cannot be reset "
3395 "to its default value", e->key);
3396 return -EINVAL;
3397 }
3398 }
3399
3400 return 0;
3401}
3402
Jeff Codye971aa12012-09-20 15:13:19 -04003403/*
Alberto Garciacb828c32019-03-12 18:48:47 +02003404 * Returns true if @child can be reached recursively from @bs
3405 */
3406static bool bdrv_recurse_has_child(BlockDriverState *bs,
3407 BlockDriverState *child)
3408{
3409 BdrvChild *c;
3410
3411 if (bs == child) {
3412 return true;
3413 }
3414
3415 QLIST_FOREACH(c, &bs->children, next) {
3416 if (bdrv_recurse_has_child(c->bs, child)) {
3417 return true;
3418 }
3419 }
3420
3421 return false;
3422}
3423
3424/*
Jeff Codye971aa12012-09-20 15:13:19 -04003425 * Adds a BlockDriverState to a simple queue for an atomic, transactional
3426 * reopen of multiple devices.
3427 *
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003428 * bs_queue can either be an existing BlockReopenQueue that has had QTAILQ_INIT
Jeff Codye971aa12012-09-20 15:13:19 -04003429 * already performed, or alternatively may be NULL a new BlockReopenQueue will
3430 * be created and initialized. This newly created BlockReopenQueue should be
3431 * passed back in for subsequent calls that are intended to be of the same
3432 * atomic 'set'.
3433 *
3434 * bs is the BlockDriverState to add to the reopen queue.
3435 *
Kevin Wolf4d2cb092015-04-10 17:50:50 +02003436 * options contains the changed options for the associated bs
3437 * (the BlockReopenQueue takes ownership)
3438 *
Jeff Codye971aa12012-09-20 15:13:19 -04003439 * flags contains the open flags for the associated bs
3440 *
3441 * returns a pointer to bs_queue, which is either the newly allocated
3442 * bs_queue, or the existing bs_queue being used.
3443 *
Kevin Wolf1a63a902017-12-06 20:24:44 +01003444 * bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple().
Jeff Codye971aa12012-09-20 15:13:19 -04003445 */
Kevin Wolf28518102015-05-08 17:07:31 +02003446static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
3447 BlockDriverState *bs,
3448 QDict *options,
Kevin Wolf28518102015-05-08 17:07:31 +02003449 const BdrvChildRole *role,
3450 QDict *parent_options,
Alberto Garcia077e8e22019-03-12 18:48:44 +02003451 int parent_flags,
3452 bool keep_old_opts)
Jeff Codye971aa12012-09-20 15:13:19 -04003453{
3454 assert(bs != NULL);
3455
3456 BlockReopenQueueEntry *bs_entry;
Kevin Wolf67251a32015-04-09 18:54:04 +02003457 BdrvChild *child;
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02003458 QDict *old_options, *explicit_options, *options_copy;
3459 int flags;
3460 QemuOpts *opts;
Kevin Wolf67251a32015-04-09 18:54:04 +02003461
Kevin Wolf1a63a902017-12-06 20:24:44 +01003462 /* Make sure that the caller remembered to use a drained section. This is
3463 * important to avoid graph changes between the recursive queuing here and
3464 * bdrv_reopen_multiple(). */
3465 assert(bs->quiesce_counter > 0);
3466
Jeff Codye971aa12012-09-20 15:13:19 -04003467 if (bs_queue == NULL) {
3468 bs_queue = g_new0(BlockReopenQueue, 1);
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003469 QTAILQ_INIT(bs_queue);
Jeff Codye971aa12012-09-20 15:13:19 -04003470 }
3471
Kevin Wolf4d2cb092015-04-10 17:50:50 +02003472 if (!options) {
3473 options = qdict_new();
3474 }
3475
Alberto Garcia5b7ba052016-09-15 17:53:03 +03003476 /* Check if this BlockDriverState is already in the queue */
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003477 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
Alberto Garcia5b7ba052016-09-15 17:53:03 +03003478 if (bs == bs_entry->state.bs) {
3479 break;
3480 }
3481 }
3482
Kevin Wolf28518102015-05-08 17:07:31 +02003483 /*
3484 * Precedence of options:
3485 * 1. Explicitly passed in options (highest)
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02003486 * 2. Retained from explicitly set options of bs
3487 * 3. Inherited from parent node
3488 * 4. Retained from effective options of bs
Kevin Wolf28518102015-05-08 17:07:31 +02003489 */
3490
Kevin Wolf145f5982015-05-08 16:15:03 +02003491 /* Old explicitly set values (don't overwrite by inherited value) */
Alberto Garcia077e8e22019-03-12 18:48:44 +02003492 if (bs_entry || keep_old_opts) {
3493 old_options = qdict_clone_shallow(bs_entry ?
3494 bs_entry->state.explicit_options :
3495 bs->explicit_options);
3496 bdrv_join_options(bs, options, old_options);
3497 qobject_unref(old_options);
Alberto Garcia5b7ba052016-09-15 17:53:03 +03003498 }
Kevin Wolf145f5982015-05-08 16:15:03 +02003499
3500 explicit_options = qdict_clone_shallow(options);
3501
Kevin Wolf28518102015-05-08 17:07:31 +02003502 /* Inherit from parent node */
3503 if (parent_options) {
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02003504 flags = 0;
Kevin Wolf8e2160e2015-04-29 17:29:39 +02003505 role->inherit_options(&flags, options, parent_flags, parent_options);
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02003506 } else {
3507 flags = bdrv_get_flags(bs);
Kevin Wolf28518102015-05-08 17:07:31 +02003508 }
3509
Alberto Garcia077e8e22019-03-12 18:48:44 +02003510 if (keep_old_opts) {
3511 /* Old values are used for options that aren't set yet */
3512 old_options = qdict_clone_shallow(bs->options);
3513 bdrv_join_options(bs, options, old_options);
3514 qobject_unref(old_options);
3515 }
Kevin Wolf4d2cb092015-04-10 17:50:50 +02003516
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02003517 /* We have the final set of options so let's update the flags */
3518 options_copy = qdict_clone_shallow(options);
3519 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
3520 qemu_opts_absorb_qdict(opts, options_copy, NULL);
3521 update_flags_from_options(&flags, opts);
3522 qemu_opts_del(opts);
3523 qobject_unref(options_copy);
3524
Kevin Wolffd452022017-08-03 17:02:59 +02003525 /* bdrv_open_inherit() sets and clears some additional flags internally */
Kevin Wolff1f25a22014-04-25 19:04:55 +02003526 flags &= ~BDRV_O_PROTOCOL;
Kevin Wolffd452022017-08-03 17:02:59 +02003527 if (flags & BDRV_O_RDWR) {
3528 flags |= BDRV_O_ALLOW_RDWR;
3529 }
Kevin Wolff1f25a22014-04-25 19:04:55 +02003530
Kevin Wolf1857c972017-09-14 14:53:46 +02003531 if (!bs_entry) {
3532 bs_entry = g_new0(BlockReopenQueueEntry, 1);
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003533 QTAILQ_INSERT_TAIL(bs_queue, bs_entry, entry);
Kevin Wolf1857c972017-09-14 14:53:46 +02003534 } else {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003535 qobject_unref(bs_entry->state.options);
3536 qobject_unref(bs_entry->state.explicit_options);
Kevin Wolf1857c972017-09-14 14:53:46 +02003537 }
3538
3539 bs_entry->state.bs = bs;
3540 bs_entry->state.options = options;
3541 bs_entry->state.explicit_options = explicit_options;
3542 bs_entry->state.flags = flags;
3543
Kevin Wolf30450252017-07-03 17:07:35 +02003544 /* This needs to be overwritten in bdrv_reopen_prepare() */
3545 bs_entry->state.perm = UINT64_MAX;
3546 bs_entry->state.shared_perm = 0;
3547
Alberto Garcia85466322019-03-12 18:48:45 +02003548 /*
3549 * If keep_old_opts is false then it means that unspecified
3550 * options must be reset to their original value. We don't allow
3551 * resetting 'backing' but we need to know if the option is
3552 * missing in order to decide if we have to return an error.
3553 */
3554 if (!keep_old_opts) {
3555 bs_entry->state.backing_missing =
3556 !qdict_haskey(options, "backing") &&
3557 !qdict_haskey(options, "backing.driver");
3558 }
3559
Kevin Wolf67251a32015-04-09 18:54:04 +02003560 QLIST_FOREACH(child, &bs->children, next) {
Alberto Garcia85466322019-03-12 18:48:45 +02003561 QDict *new_child_options = NULL;
3562 bool child_keep_old = keep_old_opts;
Kevin Wolf67251a32015-04-09 18:54:04 +02003563
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02003564 /* reopen can only change the options of block devices that were
3565 * implicitly created and inherited options. For other (referenced)
3566 * block devices, a syntax like "backing.foo" results in an error. */
Kevin Wolf67251a32015-04-09 18:54:04 +02003567 if (child->bs->inherits_from != bs) {
3568 continue;
3569 }
3570
Alberto Garcia85466322019-03-12 18:48:45 +02003571 /* Check if the options contain a child reference */
3572 if (qdict_haskey(options, child->name)) {
3573 const char *childref = qdict_get_try_str(options, child->name);
3574 /*
3575 * The current child must not be reopened if the child
3576 * reference is null or points to a different node.
3577 */
3578 if (g_strcmp0(childref, child->bs->node_name)) {
3579 continue;
3580 }
3581 /*
3582 * If the child reference points to the current child then
3583 * reopen it with its existing set of options (note that
3584 * it can still inherit new options from the parent).
3585 */
3586 child_keep_old = true;
3587 } else {
3588 /* Extract child options ("child-name.*") */
3589 char *child_key_dot = g_strdup_printf("%s.", child->name);
3590 qdict_extract_subqdict(explicit_options, NULL, child_key_dot);
3591 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
3592 g_free(child_key_dot);
3593 }
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02003594
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02003595 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options,
Alberto Garcia85466322019-03-12 18:48:45 +02003596 child->role, options, flags, child_keep_old);
Jeff Codye971aa12012-09-20 15:13:19 -04003597 }
3598
Jeff Codye971aa12012-09-20 15:13:19 -04003599 return bs_queue;
3600}
3601
Kevin Wolf28518102015-05-08 17:07:31 +02003602BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
3603 BlockDriverState *bs,
Alberto Garcia077e8e22019-03-12 18:48:44 +02003604 QDict *options, bool keep_old_opts)
Kevin Wolf28518102015-05-08 17:07:31 +02003605{
Alberto Garcia077e8e22019-03-12 18:48:44 +02003606 return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, NULL, 0,
3607 keep_old_opts);
Kevin Wolf28518102015-05-08 17:07:31 +02003608}
3609
Jeff Codye971aa12012-09-20 15:13:19 -04003610/*
3611 * Reopen multiple BlockDriverStates atomically & transactionally.
3612 *
3613 * The queue passed in (bs_queue) must have been built up previous
3614 * via bdrv_reopen_queue().
3615 *
3616 * Reopens all BDS specified in the queue, with the appropriate
3617 * flags. All devices are prepared for reopen, and failure of any
Stefan Weil50d6a8a2018-07-12 21:51:20 +02003618 * device will cause all device changes to be abandoned, and intermediate
Jeff Codye971aa12012-09-20 15:13:19 -04003619 * data cleaned up.
3620 *
3621 * If all devices prepare successfully, then the changes are committed
3622 * to all devices.
3623 *
Kevin Wolf1a63a902017-12-06 20:24:44 +01003624 * All affected nodes must be drained between bdrv_reopen_queue() and
3625 * bdrv_reopen_multiple().
Jeff Codye971aa12012-09-20 15:13:19 -04003626 */
Alberto Garcia5019aec2019-03-12 18:48:50 +02003627int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
Jeff Codye971aa12012-09-20 15:13:19 -04003628{
3629 int ret = -1;
3630 BlockReopenQueueEntry *bs_entry, *next;
Jeff Codye971aa12012-09-20 15:13:19 -04003631
3632 assert(bs_queue != NULL);
3633
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003634 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
Kevin Wolf1a63a902017-12-06 20:24:44 +01003635 assert(bs_entry->state.bs->quiesce_counter > 0);
Kevin Wolfa4615ab2019-03-05 16:51:13 +01003636 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, errp)) {
Jeff Codye971aa12012-09-20 15:13:19 -04003637 goto cleanup;
3638 }
3639 bs_entry->prepared = true;
3640 }
3641
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003642 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
Kevin Wolf69b736e2019-03-05 17:18:22 +01003643 BDRVReopenState *state = &bs_entry->state;
3644 ret = bdrv_check_perm(state->bs, bs_queue, state->perm,
Max Reitz9eab1542019-05-22 19:03:50 +02003645 state->shared_perm, NULL, NULL, errp);
Kevin Wolf69b736e2019-03-05 17:18:22 +01003646 if (ret < 0) {
3647 goto cleanup_perm;
3648 }
Alberto Garciacb828c32019-03-12 18:48:47 +02003649 /* Check if new_backing_bs would accept the new permissions */
3650 if (state->replace_backing_bs && state->new_backing_bs) {
3651 uint64_t nperm, nshared;
3652 bdrv_child_perm(state->bs, state->new_backing_bs,
3653 NULL, &child_backing, bs_queue,
3654 state->perm, state->shared_perm,
3655 &nperm, &nshared);
3656 ret = bdrv_check_update_perm(state->new_backing_bs, NULL,
Max Reitz9eab1542019-05-22 19:03:50 +02003657 nperm, nshared, NULL, NULL, errp);
Alberto Garciacb828c32019-03-12 18:48:47 +02003658 if (ret < 0) {
3659 goto cleanup_perm;
3660 }
3661 }
Kevin Wolf69b736e2019-03-05 17:18:22 +01003662 bs_entry->perms_checked = true;
3663 }
3664
Vladimir Sementsov-Ogievskiyfcd6a4f2019-09-27 15:23:48 +03003665 /*
3666 * If we reach this point, we have success and just need to apply the
3667 * changes.
3668 *
3669 * Reverse order is used to comfort qcow2 driver: on commit it need to write
3670 * IN_USE flag to the image, to mark bitmaps in the image as invalid. But
3671 * children are usually goes after parents in reopen-queue, so go from last
3672 * to first element.
Jeff Codye971aa12012-09-20 15:13:19 -04003673 */
Vladimir Sementsov-Ogievskiyfcd6a4f2019-09-27 15:23:48 +03003674 QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
Jeff Codye971aa12012-09-20 15:13:19 -04003675 bdrv_reopen_commit(&bs_entry->state);
3676 }
3677
3678 ret = 0;
Kevin Wolf69b736e2019-03-05 17:18:22 +01003679cleanup_perm:
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003680 QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
Kevin Wolf69b736e2019-03-05 17:18:22 +01003681 BDRVReopenState *state = &bs_entry->state;
Jeff Codye971aa12012-09-20 15:13:19 -04003682
Kevin Wolf69b736e2019-03-05 17:18:22 +01003683 if (!bs_entry->perms_checked) {
3684 continue;
3685 }
3686
3687 if (ret == 0) {
3688 bdrv_set_perm(state->bs, state->perm, state->shared_perm);
3689 } else {
3690 bdrv_abort_perm_update(state->bs);
Alberto Garciacb828c32019-03-12 18:48:47 +02003691 if (state->replace_backing_bs && state->new_backing_bs) {
3692 bdrv_abort_perm_update(state->new_backing_bs);
3693 }
Kevin Wolf69b736e2019-03-05 17:18:22 +01003694 }
3695 }
Peter Krempa17e1e2b2020-02-28 13:44:46 +01003696
3697 if (ret == 0) {
3698 QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
3699 BlockDriverState *bs = bs_entry->state.bs;
3700
3701 if (bs->drv->bdrv_reopen_commit_post)
3702 bs->drv->bdrv_reopen_commit_post(&bs_entry->state);
3703 }
3704 }
Jeff Codye971aa12012-09-20 15:13:19 -04003705cleanup:
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003706 QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
Alberto Garcia1bab38e2018-06-29 14:37:01 +03003707 if (ret) {
3708 if (bs_entry->prepared) {
3709 bdrv_reopen_abort(&bs_entry->state);
3710 }
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003711 qobject_unref(bs_entry->state.explicit_options);
Alberto Garcia4c8350f2018-06-29 14:37:02 +03003712 qobject_unref(bs_entry->state.options);
Jeff Codye971aa12012-09-20 15:13:19 -04003713 }
Alberto Garciacb828c32019-03-12 18:48:47 +02003714 if (bs_entry->state.new_backing_bs) {
3715 bdrv_unref(bs_entry->state.new_backing_bs);
3716 }
Jeff Codye971aa12012-09-20 15:13:19 -04003717 g_free(bs_entry);
3718 }
3719 g_free(bs_queue);
Alberto Garcia40840e42016-10-28 10:08:03 +03003720
Jeff Codye971aa12012-09-20 15:13:19 -04003721 return ret;
3722}
3723
Alberto Garcia6e1000a2018-11-12 16:00:33 +02003724int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
3725 Error **errp)
3726{
3727 int ret;
3728 BlockReopenQueue *queue;
3729 QDict *opts = qdict_new();
3730
3731 qdict_put_bool(opts, BDRV_OPT_READ_ONLY, read_only);
3732
3733 bdrv_subtree_drained_begin(bs);
Alberto Garcia077e8e22019-03-12 18:48:44 +02003734 queue = bdrv_reopen_queue(NULL, bs, opts, true);
Alberto Garcia5019aec2019-03-12 18:48:50 +02003735 ret = bdrv_reopen_multiple(queue, errp);
Alberto Garcia6e1000a2018-11-12 16:00:33 +02003736 bdrv_subtree_drained_end(bs);
3737
3738 return ret;
3739}
3740
Kevin Wolf30450252017-07-03 17:07:35 +02003741static BlockReopenQueueEntry *find_parent_in_reopen_queue(BlockReopenQueue *q,
3742 BdrvChild *c)
3743{
3744 BlockReopenQueueEntry *entry;
3745
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03003746 QTAILQ_FOREACH(entry, q, entry) {
Kevin Wolf30450252017-07-03 17:07:35 +02003747 BlockDriverState *bs = entry->state.bs;
3748 BdrvChild *child;
3749
3750 QLIST_FOREACH(child, &bs->children, next) {
3751 if (child == c) {
3752 return entry;
3753 }
3754 }
3755 }
3756
3757 return NULL;
3758}
3759
3760static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
3761 uint64_t *perm, uint64_t *shared)
3762{
3763 BdrvChild *c;
3764 BlockReopenQueueEntry *parent;
3765 uint64_t cumulative_perms = 0;
3766 uint64_t cumulative_shared_perms = BLK_PERM_ALL;
3767
3768 QLIST_FOREACH(c, &bs->parents, next_parent) {
3769 parent = find_parent_in_reopen_queue(q, c);
3770 if (!parent) {
3771 cumulative_perms |= c->perm;
3772 cumulative_shared_perms &= c->shared_perm;
3773 } else {
3774 uint64_t nperm, nshared;
3775
3776 bdrv_child_perm(parent->state.bs, bs, c, c->role, q,
3777 parent->state.perm, parent->state.shared_perm,
3778 &nperm, &nshared);
3779
3780 cumulative_perms |= nperm;
3781 cumulative_shared_perms &= nshared;
3782 }
3783 }
3784 *perm = cumulative_perms;
3785 *shared = cumulative_shared_perms;
3786}
Jeff Codye971aa12012-09-20 15:13:19 -04003787
Kevin Wolf1de6b452020-03-06 15:14:13 +01003788static bool bdrv_reopen_can_attach(BlockDriverState *parent,
3789 BdrvChild *child,
3790 BlockDriverState *new_child,
3791 Error **errp)
3792{
3793 AioContext *parent_ctx = bdrv_get_aio_context(parent);
3794 AioContext *child_ctx = bdrv_get_aio_context(new_child);
3795 GSList *ignore;
3796 bool ret;
3797
3798 ignore = g_slist_prepend(NULL, child);
3799 ret = bdrv_can_set_aio_context(new_child, parent_ctx, &ignore, NULL);
3800 g_slist_free(ignore);
3801 if (ret) {
3802 return ret;
3803 }
3804
3805 ignore = g_slist_prepend(NULL, child);
3806 ret = bdrv_can_set_aio_context(parent, child_ctx, &ignore, errp);
3807 g_slist_free(ignore);
3808 return ret;
3809}
3810
Jeff Codye971aa12012-09-20 15:13:19 -04003811/*
Alberto Garciacb828c32019-03-12 18:48:47 +02003812 * Take a BDRVReopenState and check if the value of 'backing' in the
3813 * reopen_state->options QDict is valid or not.
3814 *
3815 * If 'backing' is missing from the QDict then return 0.
3816 *
3817 * If 'backing' contains the node name of the backing file of
3818 * reopen_state->bs then return 0.
3819 *
3820 * If 'backing' contains a different node name (or is null) then check
3821 * whether the current backing file can be replaced with the new one.
3822 * If that's the case then reopen_state->replace_backing_bs is set to
3823 * true and reopen_state->new_backing_bs contains a pointer to the new
3824 * backing BlockDriverState (or NULL).
3825 *
3826 * Return 0 on success, otherwise return < 0 and set @errp.
3827 */
3828static int bdrv_reopen_parse_backing(BDRVReopenState *reopen_state,
3829 Error **errp)
3830{
3831 BlockDriverState *bs = reopen_state->bs;
3832 BlockDriverState *overlay_bs, *new_backing_bs;
3833 QObject *value;
3834 const char *str;
3835
3836 value = qdict_get(reopen_state->options, "backing");
3837 if (value == NULL) {
3838 return 0;
3839 }
3840
3841 switch (qobject_type(value)) {
3842 case QTYPE_QNULL:
3843 new_backing_bs = NULL;
3844 break;
3845 case QTYPE_QSTRING:
3846 str = qobject_get_try_str(value);
3847 new_backing_bs = bdrv_lookup_bs(NULL, str, errp);
3848 if (new_backing_bs == NULL) {
3849 return -EINVAL;
3850 } else if (bdrv_recurse_has_child(new_backing_bs, bs)) {
3851 error_setg(errp, "Making '%s' a backing file of '%s' "
3852 "would create a cycle", str, bs->node_name);
3853 return -EINVAL;
3854 }
3855 break;
3856 default:
3857 /* 'backing' does not allow any other data type */
3858 g_assert_not_reached();
3859 }
3860
3861 /*
Kevin Wolf1de6b452020-03-06 15:14:13 +01003862 * Check AioContext compatibility so that the bdrv_set_backing_hd() call in
3863 * bdrv_reopen_commit() won't fail.
Alberto Garciacb828c32019-03-12 18:48:47 +02003864 */
3865 if (new_backing_bs) {
Kevin Wolf1de6b452020-03-06 15:14:13 +01003866 if (!bdrv_reopen_can_attach(bs, bs->backing, new_backing_bs, errp)) {
Alberto Garciacb828c32019-03-12 18:48:47 +02003867 return -EINVAL;
3868 }
3869 }
3870
3871 /*
3872 * Find the "actual" backing file by skipping all links that point
3873 * to an implicit node, if any (e.g. a commit filter node).
3874 */
3875 overlay_bs = bs;
3876 while (backing_bs(overlay_bs) && backing_bs(overlay_bs)->implicit) {
3877 overlay_bs = backing_bs(overlay_bs);
3878 }
3879
3880 /* If we want to replace the backing file we need some extra checks */
3881 if (new_backing_bs != backing_bs(overlay_bs)) {
3882 /* Check for implicit nodes between bs and its backing file */
3883 if (bs != overlay_bs) {
3884 error_setg(errp, "Cannot change backing link if '%s' has "
3885 "an implicit backing file", bs->node_name);
3886 return -EPERM;
3887 }
3888 /* Check if the backing link that we want to replace is frozen */
3889 if (bdrv_is_backing_chain_frozen(overlay_bs, backing_bs(overlay_bs),
3890 errp)) {
3891 return -EPERM;
3892 }
3893 reopen_state->replace_backing_bs = true;
3894 if (new_backing_bs) {
3895 bdrv_ref(new_backing_bs);
3896 reopen_state->new_backing_bs = new_backing_bs;
3897 }
3898 }
3899
3900 return 0;
3901}
3902
3903/*
Jeff Codye971aa12012-09-20 15:13:19 -04003904 * Prepares a BlockDriverState for reopen. All changes are staged in the
3905 * 'opaque' field of the BDRVReopenState, which is used and allocated by
3906 * the block driver layer .bdrv_reopen_prepare()
3907 *
3908 * bs is the BlockDriverState to reopen
3909 * flags are the new open flags
3910 * queue is the reopen queue
3911 *
3912 * Returns 0 on success, non-zero on error. On error errp will be set
3913 * as well.
3914 *
3915 * On failure, bdrv_reopen_abort() will be called to clean up any data.
3916 * It is the responsibility of the caller to then call the abort() or
3917 * commit() for any other BDS that have been left in a prepare() state
3918 *
3919 */
3920int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
3921 Error **errp)
3922{
3923 int ret = -1;
Alberto Garciae6d79c42018-11-12 16:00:47 +02003924 int old_flags;
Jeff Codye971aa12012-09-20 15:13:19 -04003925 Error *local_err = NULL;
3926 BlockDriver *drv;
Kevin Wolfccf9dc02015-05-08 17:24:56 +02003927 QemuOpts *opts;
Alberto Garcia4c8350f2018-06-29 14:37:02 +03003928 QDict *orig_reopen_opts;
Alberto Garcia593b3072018-09-06 12:37:08 +03003929 char *discard = NULL;
Jeff Cody3d8ce172017-04-07 16:55:30 -04003930 bool read_only;
Max Reitz9ad08c42018-11-16 17:45:24 +01003931 bool drv_prepared = false;
Jeff Codye971aa12012-09-20 15:13:19 -04003932
3933 assert(reopen_state != NULL);
3934 assert(reopen_state->bs->drv != NULL);
3935 drv = reopen_state->bs->drv;
3936
Alberto Garcia4c8350f2018-06-29 14:37:02 +03003937 /* This function and each driver's bdrv_reopen_prepare() remove
3938 * entries from reopen_state->options as they are processed, so
3939 * we need to make a copy of the original QDict. */
3940 orig_reopen_opts = qdict_clone_shallow(reopen_state->options);
3941
Kevin Wolfccf9dc02015-05-08 17:24:56 +02003942 /* Process generic block layer options */
3943 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
3944 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
3945 if (local_err) {
3946 error_propagate(errp, local_err);
3947 ret = -EINVAL;
3948 goto error;
3949 }
3950
Alberto Garciae6d79c42018-11-12 16:00:47 +02003951 /* This was already called in bdrv_reopen_queue_child() so the flags
3952 * are up-to-date. This time we simply want to remove the options from
3953 * QemuOpts in order to indicate that they have been processed. */
3954 old_flags = reopen_state->flags;
Kevin Wolf91a097e2015-05-08 17:49:53 +02003955 update_flags_from_options(&reopen_state->flags, opts);
Alberto Garciae6d79c42018-11-12 16:00:47 +02003956 assert(old_flags == reopen_state->flags);
Kevin Wolf91a097e2015-05-08 17:49:53 +02003957
Alberto Garcia415bbca2018-10-03 13:23:13 +03003958 discard = qemu_opt_get_del(opts, BDRV_OPT_DISCARD);
Alberto Garcia593b3072018-09-06 12:37:08 +03003959 if (discard != NULL) {
3960 if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) {
3961 error_setg(errp, "Invalid discard option");
3962 ret = -EINVAL;
3963 goto error;
3964 }
3965 }
3966
Alberto Garcia543770b2018-09-06 12:37:09 +03003967 reopen_state->detect_zeroes =
3968 bdrv_parse_detect_zeroes(opts, reopen_state->flags, &local_err);
3969 if (local_err) {
3970 error_propagate(errp, local_err);
3971 ret = -EINVAL;
3972 goto error;
3973 }
3974
Alberto Garcia57f9db92018-09-06 12:37:06 +03003975 /* All other options (including node-name and driver) must be unchanged.
3976 * Put them back into the QDict, so that they are checked at the end
3977 * of this function. */
3978 qemu_opts_to_qdict(opts, reopen_state->options);
Kevin Wolfccf9dc02015-05-08 17:24:56 +02003979
Jeff Cody3d8ce172017-04-07 16:55:30 -04003980 /* If we are to stay read-only, do not allow permission change
3981 * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
3982 * not set, or if the BDS still has copy_on_read enabled */
3983 read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf54a32bf2017-08-03 17:02:58 +02003984 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);
Jeff Cody3d8ce172017-04-07 16:55:30 -04003985 if (local_err) {
3986 error_propagate(errp, local_err);
Jeff Codye971aa12012-09-20 15:13:19 -04003987 goto error;
3988 }
3989
Kevin Wolf30450252017-07-03 17:07:35 +02003990 /* Calculate required permissions after reopening */
3991 bdrv_reopen_perm(queue, reopen_state->bs,
3992 &reopen_state->perm, &reopen_state->shared_perm);
Jeff Codye971aa12012-09-20 15:13:19 -04003993
3994 ret = bdrv_flush(reopen_state->bs);
3995 if (ret) {
Eric Blake455b0fd2015-11-10 23:51:20 -07003996 error_setg_errno(errp, -ret, "Error flushing drive");
Jeff Codye971aa12012-09-20 15:13:19 -04003997 goto error;
3998 }
3999
4000 if (drv->bdrv_reopen_prepare) {
Alberto Garciafaf116b2019-03-12 18:48:49 +02004001 /*
4002 * If a driver-specific option is missing, it means that we
4003 * should reset it to its default value.
4004 * But not all options allow that, so we need to check it first.
4005 */
4006 ret = bdrv_reset_options_allowed(reopen_state->bs,
4007 reopen_state->options, errp);
4008 if (ret) {
4009 goto error;
4010 }
4011
Jeff Codye971aa12012-09-20 15:13:19 -04004012 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
4013 if (ret) {
4014 if (local_err != NULL) {
4015 error_propagate(errp, local_err);
4016 } else {
Max Reitzf30c66b2019-02-01 20:29:05 +01004017 bdrv_refresh_filename(reopen_state->bs);
Luiz Capitulinod8b68952013-06-10 11:29:27 -04004018 error_setg(errp, "failed while preparing to reopen image '%s'",
4019 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04004020 }
4021 goto error;
4022 }
4023 } else {
4024 /* It is currently mandatory to have a bdrv_reopen_prepare()
4025 * handler for each supported drv. */
Alberto Garcia81e5f782015-04-08 12:29:19 +03004026 error_setg(errp, "Block format '%s' used by node '%s' "
4027 "does not support reopening files", drv->format_name,
4028 bdrv_get_device_or_node_name(reopen_state->bs));
Jeff Codye971aa12012-09-20 15:13:19 -04004029 ret = -1;
4030 goto error;
4031 }
4032
Max Reitz9ad08c42018-11-16 17:45:24 +01004033 drv_prepared = true;
4034
Alberto Garciabacd9b82019-03-12 18:48:46 +02004035 /*
4036 * We must provide the 'backing' option if the BDS has a backing
4037 * file or if the image file has a backing file name as part of
4038 * its metadata. Otherwise the 'backing' option can be omitted.
4039 */
4040 if (drv->supports_backing && reopen_state->backing_missing &&
4041 (backing_bs(reopen_state->bs) || reopen_state->bs->backing_file[0])) {
Alberto Garcia85466322019-03-12 18:48:45 +02004042 error_setg(errp, "backing is missing for '%s'",
4043 reopen_state->bs->node_name);
4044 ret = -EINVAL;
4045 goto error;
4046 }
4047
Alberto Garciacb828c32019-03-12 18:48:47 +02004048 /*
4049 * Allow changing the 'backing' option. The new value can be
4050 * either a reference to an existing node (using its node name)
4051 * or NULL to simply detach the current backing file.
4052 */
4053 ret = bdrv_reopen_parse_backing(reopen_state, errp);
4054 if (ret < 0) {
4055 goto error;
4056 }
4057 qdict_del(reopen_state->options, "backing");
4058
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004059 /* Options that are not handled are only okay if they are unchanged
4060 * compared to the old state. It is expected that some options are only
4061 * used for the initial open, but not reopen (e.g. filename) */
4062 if (qdict_size(reopen_state->options)) {
4063 const QDictEntry *entry = qdict_first(reopen_state->options);
4064
4065 do {
Max Reitz54fd1b02017-11-14 19:01:26 +01004066 QObject *new = entry->value;
4067 QObject *old = qdict_get(reopen_state->bs->options, entry->key);
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004068
Alberto Garciadb905282018-09-06 12:37:05 +03004069 /* Allow child references (child_name=node_name) as long as they
4070 * point to the current child (i.e. everything stays the same). */
4071 if (qobject_type(new) == QTYPE_QSTRING) {
4072 BdrvChild *child;
4073 QLIST_FOREACH(child, &reopen_state->bs->children, next) {
4074 if (!strcmp(child->name, entry->key)) {
4075 break;
4076 }
4077 }
4078
4079 if (child) {
4080 const char *str = qobject_get_try_str(new);
4081 if (!strcmp(child->bs->node_name, str)) {
4082 continue; /* Found child with this name, skip option */
4083 }
4084 }
4085 }
4086
Max Reitz54fd1b02017-11-14 19:01:26 +01004087 /*
4088 * TODO: When using -drive to specify blockdev options, all values
4089 * will be strings; however, when using -blockdev, blockdev-add or
4090 * filenames using the json:{} pseudo-protocol, they will be
4091 * correctly typed.
4092 * In contrast, reopening options are (currently) always strings
4093 * (because you can only specify them through qemu-io; all other
4094 * callers do not specify any options).
4095 * Therefore, when using anything other than -drive to create a BDS,
4096 * this cannot detect non-string options as unchanged, because
4097 * qobject_is_equal() always returns false for objects of different
4098 * type. In the future, this should be remedied by correctly typing
4099 * all options. For now, this is not too big of an issue because
4100 * the user can simply omit options which cannot be changed anyway,
4101 * so they will stay unchanged.
4102 */
4103 if (!qobject_is_equal(new, old)) {
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004104 error_setg(errp, "Cannot change the option '%s'", entry->key);
4105 ret = -EINVAL;
4106 goto error;
4107 }
4108 } while ((entry = qdict_next(reopen_state->options, entry)));
4109 }
4110
Jeff Codye971aa12012-09-20 15:13:19 -04004111 ret = 0;
4112
Alberto Garcia4c8350f2018-06-29 14:37:02 +03004113 /* Restore the original reopen_state->options QDict */
4114 qobject_unref(reopen_state->options);
4115 reopen_state->options = qobject_ref(orig_reopen_opts);
4116
Jeff Codye971aa12012-09-20 15:13:19 -04004117error:
Max Reitz9ad08c42018-11-16 17:45:24 +01004118 if (ret < 0 && drv_prepared) {
4119 /* drv->bdrv_reopen_prepare() has succeeded, so we need to
4120 * call drv->bdrv_reopen_abort() before signaling an error
4121 * (bdrv_reopen_multiple() will not call bdrv_reopen_abort()
4122 * when the respective bdrv_reopen_prepare() has failed) */
4123 if (drv->bdrv_reopen_abort) {
4124 drv->bdrv_reopen_abort(reopen_state);
4125 }
4126 }
Kevin Wolfccf9dc02015-05-08 17:24:56 +02004127 qemu_opts_del(opts);
Alberto Garcia4c8350f2018-06-29 14:37:02 +03004128 qobject_unref(orig_reopen_opts);
Alberto Garcia593b3072018-09-06 12:37:08 +03004129 g_free(discard);
Jeff Codye971aa12012-09-20 15:13:19 -04004130 return ret;
4131}
4132
4133/*
4134 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
4135 * makes them final by swapping the staging BlockDriverState contents into
4136 * the active BlockDriverState contents.
4137 */
4138void bdrv_reopen_commit(BDRVReopenState *reopen_state)
4139{
4140 BlockDriver *drv;
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03004141 BlockDriverState *bs;
Alberto Garcia50196d72018-09-06 12:37:03 +03004142 BdrvChild *child;
Jeff Codye971aa12012-09-20 15:13:19 -04004143
4144 assert(reopen_state != NULL);
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03004145 bs = reopen_state->bs;
4146 drv = bs->drv;
Jeff Codye971aa12012-09-20 15:13:19 -04004147 assert(drv != NULL);
4148
4149 /* If there are any driver level actions to take */
4150 if (drv->bdrv_reopen_commit) {
4151 drv->bdrv_reopen_commit(reopen_state);
4152 }
4153
4154 /* set BDS specific flags now */
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004155 qobject_unref(bs->explicit_options);
Alberto Garcia4c8350f2018-06-29 14:37:02 +03004156 qobject_unref(bs->options);
Kevin Wolf145f5982015-05-08 16:15:03 +02004157
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03004158 bs->explicit_options = reopen_state->explicit_options;
Alberto Garcia4c8350f2018-06-29 14:37:02 +03004159 bs->options = reopen_state->options;
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03004160 bs->open_flags = reopen_state->flags;
4161 bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
Alberto Garcia543770b2018-09-06 12:37:09 +03004162 bs->detect_zeroes = reopen_state->detect_zeroes;
Kevin Wolf355ef4a2013-12-11 20:14:09 +01004163
Alberto Garciacb828c32019-03-12 18:48:47 +02004164 if (reopen_state->replace_backing_bs) {
4165 qdict_del(bs->explicit_options, "backing");
4166 qdict_del(bs->options, "backing");
4167 }
4168
Alberto Garcia50196d72018-09-06 12:37:03 +03004169 /* Remove child references from bs->options and bs->explicit_options.
4170 * Child options were already removed in bdrv_reopen_queue_child() */
4171 QLIST_FOREACH(child, &bs->children, next) {
4172 qdict_del(bs->explicit_options, child->name);
4173 qdict_del(bs->options, child->name);
4174 }
4175
Alberto Garciacb828c32019-03-12 18:48:47 +02004176 /*
4177 * Change the backing file if a new one was specified. We do this
4178 * after updating bs->options, so bdrv_refresh_filename() (called
4179 * from bdrv_set_backing_hd()) has the new values.
4180 */
4181 if (reopen_state->replace_backing_bs) {
4182 BlockDriverState *old_backing_bs = backing_bs(bs);
4183 assert(!old_backing_bs || !old_backing_bs->implicit);
4184 /* Abort the permission update on the backing bs we're detaching */
4185 if (old_backing_bs) {
4186 bdrv_abort_perm_update(old_backing_bs);
4187 }
4188 bdrv_set_backing_hd(bs, reopen_state->new_backing_bs, &error_abort);
4189 }
4190
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03004191 bdrv_refresh_limits(bs, NULL);
Jeff Codye971aa12012-09-20 15:13:19 -04004192}
4193
4194/*
4195 * Abort the reopen, and delete and free the staged changes in
4196 * reopen_state
4197 */
4198void bdrv_reopen_abort(BDRVReopenState *reopen_state)
4199{
4200 BlockDriver *drv;
4201
4202 assert(reopen_state != NULL);
4203 drv = reopen_state->bs->drv;
4204 assert(drv != NULL);
4205
4206 if (drv->bdrv_reopen_abort) {
4207 drv->bdrv_reopen_abort(reopen_state);
4208 }
4209}
4210
4211
Max Reitz64dff522016-01-29 16:36:10 +01004212static void bdrv_close(BlockDriverState *bs)
bellardfc01f7e2003-06-30 10:03:06 +00004213{
Max Reitz33384422014-06-20 21:57:33 +02004214 BdrvAioNotifier *ban, *ban_next;
Alberto Garcia50a3efb2017-11-06 16:53:45 +02004215 BdrvChild *child, *next;
Max Reitz33384422014-06-20 21:57:33 +02004216
Max Reitz30f55fb2016-05-17 16:41:32 +02004217 assert(!bs->refcnt);
Alberto Garcia99b7e772015-09-25 16:41:44 +03004218
Paolo Bonzinifc272912015-12-23 11:48:24 +01004219 bdrv_drained_begin(bs); /* complete I/O */
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02004220 bdrv_flush(bs);
Fam Zheng53ec73e2015-05-29 18:53:14 +08004221 bdrv_drain(bs); /* in case flush left pending I/O */
Paolo Bonzinifc272912015-12-23 11:48:24 +01004222
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02004223 if (bs->drv) {
Vladimir Sementsov-Ogievskiy3c005292018-08-14 15:43:19 +03004224 if (bs->drv->bdrv_close) {
4225 bs->drv->bdrv_close(bs);
4226 }
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02004227 bs->drv = NULL;
bellardb3380822004-03-14 21:38:54 +00004228 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08004229
Alberto Garcia50a3efb2017-11-06 16:53:45 +02004230 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
Alberto Garciadd4118c2019-05-13 16:46:17 +03004231 bdrv_unref_child(bs, child);
Alberto Garcia50a3efb2017-11-06 16:53:45 +02004232 }
4233
Alberto Garciadd4118c2019-05-13 16:46:17 +03004234 bs->backing = NULL;
4235 bs->file = NULL;
Alberto Garcia50a3efb2017-11-06 16:53:45 +02004236 g_free(bs->opaque);
4237 bs->opaque = NULL;
4238 atomic_set(&bs->copy_on_read, 0);
4239 bs->backing_file[0] = '\0';
4240 bs->backing_format[0] = '\0';
4241 bs->total_sectors = 0;
4242 bs->encrypted = false;
4243 bs->sg = false;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004244 qobject_unref(bs->options);
4245 qobject_unref(bs->explicit_options);
Alberto Garcia50a3efb2017-11-06 16:53:45 +02004246 bs->options = NULL;
4247 bs->explicit_options = NULL;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004248 qobject_unref(bs->full_open_options);
Alberto Garcia50a3efb2017-11-06 16:53:45 +02004249 bs->full_open_options = NULL;
4250
Vladimir Sementsov-Ogievskiycca43ae2017-06-28 15:05:16 +03004251 bdrv_release_named_dirty_bitmaps(bs);
4252 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
4253
Max Reitz33384422014-06-20 21:57:33 +02004254 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4255 g_free(ban);
4256 }
4257 QLIST_INIT(&bs->aio_notifiers);
Paolo Bonzinifc272912015-12-23 11:48:24 +01004258 bdrv_drained_end(bs);
bellardb3380822004-03-14 21:38:54 +00004259}
4260
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09004261void bdrv_close_all(void)
4262{
Kevin Wolfb3b52992018-05-16 13:46:37 +02004263 assert(job_next(NULL) == NULL);
Kevin Wolfcd7fca92016-07-06 11:22:39 +02004264 nbd_export_close_all();
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09004265
Max Reitzca9bd242016-01-29 16:36:14 +01004266 /* Drop references from requests still in flight, such as canceled block
4267 * jobs whose AIO context has not been polled yet */
4268 bdrv_drain_all();
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02004269
Max Reitzca9bd242016-01-29 16:36:14 +01004270 blk_remove_all_bs();
4271 blockdev_close_all_bdrv_states();
4272
Kevin Wolfa1a2af02016-04-08 18:26:37 +02004273 assert(QTAILQ_EMPTY(&all_bdrv_states));
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09004274}
4275
Kevin Wolfd0ac0382017-03-01 17:30:41 +01004276static bool should_update_child(BdrvChild *c, BlockDriverState *to)
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004277{
Vladimir Sementsov-Ogievskiy2f30b7c2019-02-23 22:20:39 +03004278 GQueue *queue;
4279 GHashTable *found;
4280 bool ret;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004281
Kevin Wolfd0ac0382017-03-01 17:30:41 +01004282 if (c->role->stay_at_node) {
4283 return false;
4284 }
4285
Max Reitzec9f10f2018-06-13 20:18:15 +02004286 /* If the child @c belongs to the BDS @to, replacing the current
4287 * c->bs by @to would mean to create a loop.
4288 *
4289 * Such a case occurs when appending a BDS to a backing chain.
4290 * For instance, imagine the following chain:
4291 *
4292 * guest device -> node A -> further backing chain...
4293 *
4294 * Now we create a new BDS B which we want to put on top of this
4295 * chain, so we first attach A as its backing node:
4296 *
4297 * node B
4298 * |
4299 * v
4300 * guest device -> node A -> further backing chain...
4301 *
4302 * Finally we want to replace A by B. When doing that, we want to
4303 * replace all pointers to A by pointers to B -- except for the
4304 * pointer from B because (1) that would create a loop, and (2)
4305 * that pointer should simply stay intact:
4306 *
4307 * guest device -> node B
4308 * |
4309 * v
4310 * node A -> further backing chain...
4311 *
4312 * In general, when replacing a node A (c->bs) by a node B (@to),
4313 * if A is a child of B, that means we cannot replace A by B there
4314 * because that would create a loop. Silently detaching A from B
4315 * is also not really an option. So overall just leaving A in
Vladimir Sementsov-Ogievskiy2f30b7c2019-02-23 22:20:39 +03004316 * place there is the most sensible choice.
4317 *
4318 * We would also create a loop in any cases where @c is only
4319 * indirectly referenced by @to. Prevent this by returning false
4320 * if @c is found (by breadth-first search) anywhere in the whole
4321 * subtree of @to.
4322 */
4323
4324 ret = true;
4325 found = g_hash_table_new(NULL, NULL);
4326 g_hash_table_add(found, to);
4327 queue = g_queue_new();
4328 g_queue_push_tail(queue, to);
4329
4330 while (!g_queue_is_empty(queue)) {
4331 BlockDriverState *v = g_queue_pop_head(queue);
4332 BdrvChild *c2;
4333
4334 QLIST_FOREACH(c2, &v->children, next) {
4335 if (c2 == c) {
4336 ret = false;
4337 break;
4338 }
4339
4340 if (g_hash_table_contains(found, c2->bs)) {
4341 continue;
4342 }
4343
4344 g_queue_push_tail(queue, c2->bs);
4345 g_hash_table_add(found, c2->bs);
Kevin Wolfd0ac0382017-03-01 17:30:41 +01004346 }
4347 }
4348
Vladimir Sementsov-Ogievskiy2f30b7c2019-02-23 22:20:39 +03004349 g_queue_free(queue);
4350 g_hash_table_destroy(found);
4351
4352 return ret;
Kevin Wolfd0ac0382017-03-01 17:30:41 +01004353}
4354
Kevin Wolf5fe31c22017-03-06 16:20:51 +01004355void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
4356 Error **errp)
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004357{
Kevin Wolfd0ac0382017-03-01 17:30:41 +01004358 BdrvChild *c, *next;
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004359 GSList *list = NULL, *p;
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004360 uint64_t perm = 0, shared = BLK_PERM_ALL;
4361 int ret;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004362
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004363 /* Make sure that @from doesn't go away until we have successfully attached
4364 * all of its parents to @to. */
4365 bdrv_ref(from);
4366
Kevin Wolff871abd2019-05-21 19:00:25 +02004367 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
4368 bdrv_drained_begin(from);
4369
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004370 /* Put all parents into @list and calculate their cumulative permissions */
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004371 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
Max Reitzec9f10f2018-06-13 20:18:15 +02004372 assert(c->bs == from);
Kevin Wolfd0ac0382017-03-01 17:30:41 +01004373 if (!should_update_child(c, to)) {
Kevin Wolf26de9432017-01-17 13:39:34 +01004374 continue;
4375 }
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004376 if (c->frozen) {
4377 error_setg(errp, "Cannot change '%s' link to '%s'",
4378 c->name, from->node_name);
4379 goto out;
4380 }
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004381 list = g_slist_prepend(list, c);
4382 perm |= c->perm;
4383 shared &= c->shared_perm;
4384 }
4385
4386 /* Check whether the required permissions can be granted on @to, ignoring
4387 * all BdrvChild in @list so that they can't block themselves. */
Max Reitz9eab1542019-05-22 19:03:50 +02004388 ret = bdrv_check_update_perm(to, NULL, perm, shared, list, NULL, errp);
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004389 if (ret < 0) {
4390 bdrv_abort_perm_update(to);
4391 goto out;
4392 }
4393
4394 /* Now actually perform the change. We performed the permission check for
4395 * all elements of @list at once, so set the permissions all at once at the
4396 * very end. */
4397 for (p = list; p != NULL; p = p->next) {
4398 c = p->data;
Max Reitz9bd910e2016-06-10 20:57:46 +02004399
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004400 bdrv_ref(to);
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004401 bdrv_replace_child_noperm(c, to);
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004402 bdrv_unref(from);
4403 }
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004404
Vladimir Sementsov-Ogievskiyb503de62019-08-24 13:07:40 +03004405 bdrv_get_cumulative_perm(to, &perm, &shared);
4406 bdrv_set_perm(to, perm, shared);
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004407
4408out:
4409 g_slist_free(list);
Kevin Wolff871abd2019-05-21 19:00:25 +02004410 bdrv_drained_end(from);
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004411 bdrv_unref(from);
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004412}
4413
Jeff Cody8802d1f2012-02-28 15:54:06 -05004414/*
4415 * Add new bs contents at the top of an image chain while the chain is
4416 * live, while keeping required fields on the top layer.
4417 *
4418 * This will modify the BlockDriverState fields, and swap contents
4419 * between bs_new and bs_top. Both bs_new and bs_top are modified.
4420 *
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02004421 * bs_new must not be attached to a BlockBackend.
Jeff Codyf6801b82012-03-27 16:30:19 -04004422 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05004423 * This function does not create any image files.
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004424 *
4425 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
4426 * that's what the callers commonly need. bs_new will be referenced by the old
4427 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
4428 * reference of its own, it must call bdrv_ref().
Jeff Cody8802d1f2012-02-28 15:54:06 -05004429 */
Kevin Wolfb2c28322017-02-20 12:46:42 +01004430void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
4431 Error **errp)
Jeff Cody8802d1f2012-02-28 15:54:06 -05004432{
Kevin Wolfb2c28322017-02-20 12:46:42 +01004433 Error *local_err = NULL;
4434
Kevin Wolfb2c28322017-02-20 12:46:42 +01004435 bdrv_set_backing_hd(bs_new, bs_top, &local_err);
4436 if (local_err) {
4437 error_propagate(errp, local_err);
4438 goto out;
4439 }
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004440
Kevin Wolf5fe31c22017-03-06 16:20:51 +01004441 bdrv_replace_node(bs_top, bs_new, &local_err);
Kevin Wolf234ac1a2017-03-02 18:43:00 +01004442 if (local_err) {
4443 error_propagate(errp, local_err);
4444 bdrv_set_backing_hd(bs_new, NULL, &error_abort);
4445 goto out;
4446 }
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004447
4448 /* bs_new is now referenced by its new parents, we don't need the
4449 * additional reference any more. */
Kevin Wolfb2c28322017-02-20 12:46:42 +01004450out:
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004451 bdrv_unref(bs_new);
Jeff Cody8802d1f2012-02-28 15:54:06 -05004452}
4453
Fam Zheng4f6fd342013-08-23 09:14:47 +08004454static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00004455{
Fam Zheng3718d8a2014-05-23 21:29:43 +08004456 assert(bdrv_op_blocker_is_empty(bs));
Fam Zheng4f6fd342013-08-23 09:14:47 +08004457 assert(!bs->refcnt);
Markus Armbruster18846de2010-06-29 16:58:30 +02004458
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01004459 /* remove from list, if necessary */
Kevin Wolf63eaaae2016-03-18 10:46:57 +01004460 if (bs->node_name[0] != '\0') {
4461 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
4462 }
Max Reitz2c1d04e2016-01-29 16:36:11 +01004463 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
4464
Anton Kuchin30c321f2019-05-07 11:12:56 +03004465 bdrv_close(bs);
4466
Anthony Liguori7267c092011-08-20 22:09:37 -05004467 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00004468}
4469
aliguorie97fc192009-04-21 23:11:50 +00004470/*
4471 * Run consistency checks on an image
4472 *
Kevin Wolfe076f332010-06-29 11:43:13 +02004473 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02004474 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02004475 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00004476 */
Paolo Bonzini2fd61632018-03-01 17:36:19 +01004477static int coroutine_fn bdrv_co_check(BlockDriverState *bs,
4478 BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00004479{
Max Reitz908bcd52014-08-07 22:47:55 +02004480 if (bs->drv == NULL) {
4481 return -ENOMEDIUM;
4482 }
Paolo Bonzini2fd61632018-03-01 17:36:19 +01004483 if (bs->drv->bdrv_co_check == NULL) {
aliguorie97fc192009-04-21 23:11:50 +00004484 return -ENOTSUP;
4485 }
4486
Kevin Wolfe076f332010-06-29 11:43:13 +02004487 memset(res, 0, sizeof(*res));
Paolo Bonzini2fd61632018-03-01 17:36:19 +01004488 return bs->drv->bdrv_co_check(bs, res, fix);
4489}
4490
4491typedef struct CheckCo {
4492 BlockDriverState *bs;
4493 BdrvCheckResult *res;
4494 BdrvCheckMode fix;
4495 int ret;
4496} CheckCo;
4497
Nikita Alekseev66a5bdf2019-04-01 12:30:51 +03004498static void coroutine_fn bdrv_check_co_entry(void *opaque)
Paolo Bonzini2fd61632018-03-01 17:36:19 +01004499{
4500 CheckCo *cco = opaque;
4501 cco->ret = bdrv_co_check(cco->bs, cco->res, cco->fix);
Kevin Wolf4720cbe2019-01-07 13:02:48 +01004502 aio_wait_kick();
Paolo Bonzini2fd61632018-03-01 17:36:19 +01004503}
4504
4505int bdrv_check(BlockDriverState *bs,
4506 BdrvCheckResult *res, BdrvCheckMode fix)
4507{
4508 Coroutine *co;
4509 CheckCo cco = {
4510 .bs = bs,
4511 .res = res,
4512 .ret = -EINPROGRESS,
4513 .fix = fix,
4514 };
4515
4516 if (qemu_in_coroutine()) {
4517 /* Fast-path if already in coroutine context */
4518 bdrv_check_co_entry(&cco);
4519 } else {
4520 co = qemu_coroutine_create(bdrv_check_co_entry, &cco);
Kevin Wolf4720cbe2019-01-07 13:02:48 +01004521 bdrv_coroutine_enter(bs, co);
Paolo Bonzini2fd61632018-03-01 17:36:19 +01004522 BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS);
4523 }
4524
4525 return cco.ret;
aliguorie97fc192009-04-21 23:11:50 +00004526}
4527
Kevin Wolf756e6732010-01-12 12:55:17 +01004528/*
4529 * Return values:
4530 * 0 - success
4531 * -EINVAL - backing format specified, but no file
4532 * -ENOSPC - can't update the backing file because no space is left in the
4533 * image file header
4534 * -ENOTSUP - format driver doesn't support changing the backing file
4535 */
4536int bdrv_change_backing_file(BlockDriverState *bs,
4537 const char *backing_file, const char *backing_fmt)
4538{
4539 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02004540 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01004541
Max Reitzd470ad42017-11-10 21:31:09 +01004542 if (!drv) {
4543 return -ENOMEDIUM;
4544 }
4545
Paolo Bonzini5f377792012-04-12 14:01:01 +02004546 /* Backing file format doesn't make sense without a backing file */
4547 if (backing_fmt && !backing_file) {
4548 return -EINVAL;
4549 }
4550
Kevin Wolf756e6732010-01-12 12:55:17 +01004551 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02004552 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01004553 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02004554 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01004555 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02004556
4557 if (ret == 0) {
4558 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
4559 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
Max Reitz998c2012019-02-01 20:29:08 +01004560 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
4561 backing_file ?: "");
Paolo Bonzini469ef352012-04-12 14:01:02 +02004562 }
4563 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01004564}
4565
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004566/*
4567 * Finds the image layer in the chain that has 'bs' as its backing file.
4568 *
4569 * active is the current topmost image.
4570 *
4571 * Returns NULL if bs is not found in active's image chain,
4572 * or if active == bs.
Jeff Cody4caf0fc2014-06-25 15:35:26 -04004573 *
4574 * Returns the bottommost base image if bs == NULL.
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004575 */
4576BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
4577 BlockDriverState *bs)
4578{
Kevin Wolf760e0062015-06-17 14:55:21 +02004579 while (active && bs != backing_bs(active)) {
4580 active = backing_bs(active);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004581 }
4582
Jeff Cody4caf0fc2014-06-25 15:35:26 -04004583 return active;
4584}
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004585
Jeff Cody4caf0fc2014-06-25 15:35:26 -04004586/* Given a BDS, searches for the base layer. */
4587BlockDriverState *bdrv_find_base(BlockDriverState *bs)
4588{
4589 return bdrv_find_overlay(bs, NULL);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004590}
4591
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004592/*
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004593 * Return true if at least one of the backing links between @bs and
4594 * @base is frozen. @errp is set if that's the case.
Alberto Garcia0f0998f2019-03-28 18:25:09 +02004595 * @base must be reachable from @bs, or NULL.
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004596 */
4597bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
4598 Error **errp)
4599{
4600 BlockDriverState *i;
4601
Alberto Garcia0f0998f2019-03-28 18:25:09 +02004602 for (i = bs; i != base; i = backing_bs(i)) {
4603 if (i->backing && i->backing->frozen) {
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004604 error_setg(errp, "Cannot change '%s' link from '%s' to '%s'",
4605 i->backing->name, i->node_name,
4606 backing_bs(i)->node_name);
4607 return true;
4608 }
4609 }
4610
4611 return false;
4612}
4613
4614/*
4615 * Freeze all backing links between @bs and @base.
4616 * If any of the links is already frozen the operation is aborted and
4617 * none of the links are modified.
Alberto Garcia0f0998f2019-03-28 18:25:09 +02004618 * @base must be reachable from @bs, or NULL.
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004619 * Returns 0 on success. On failure returns < 0 and sets @errp.
4620 */
4621int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
4622 Error **errp)
4623{
4624 BlockDriverState *i;
4625
4626 if (bdrv_is_backing_chain_frozen(bs, base, errp)) {
4627 return -EPERM;
4628 }
4629
Alberto Garcia0f0998f2019-03-28 18:25:09 +02004630 for (i = bs; i != base; i = backing_bs(i)) {
Max Reitze5182c12019-07-03 19:28:02 +02004631 if (i->backing && backing_bs(i)->never_freeze) {
4632 error_setg(errp, "Cannot freeze '%s' link to '%s'",
4633 i->backing->name, backing_bs(i)->node_name);
4634 return -EPERM;
4635 }
4636 }
4637
4638 for (i = bs; i != base; i = backing_bs(i)) {
Alberto Garcia0f0998f2019-03-28 18:25:09 +02004639 if (i->backing) {
4640 i->backing->frozen = true;
4641 }
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004642 }
4643
4644 return 0;
4645}
4646
4647/*
4648 * Unfreeze all backing links between @bs and @base. The caller must
4649 * ensure that all links are frozen before using this function.
Alberto Garcia0f0998f2019-03-28 18:25:09 +02004650 * @base must be reachable from @bs, or NULL.
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004651 */
4652void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base)
4653{
4654 BlockDriverState *i;
4655
Alberto Garcia0f0998f2019-03-28 18:25:09 +02004656 for (i = bs; i != base; i = backing_bs(i)) {
4657 if (i->backing) {
4658 assert(i->backing->frozen);
4659 i->backing->frozen = false;
4660 }
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004661 }
4662}
4663
4664/*
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004665 * Drops images above 'base' up to and including 'top', and sets the image
4666 * above 'top' to have base as its backing file.
4667 *
4668 * Requires that the overlay to 'top' is opened r/w, so that the backing file
4669 * information in 'bs' can be properly updated.
4670 *
4671 * E.g., this will convert the following chain:
4672 * bottom <- base <- intermediate <- top <- active
4673 *
4674 * to
4675 *
4676 * bottom <- base <- active
4677 *
4678 * It is allowed for bottom==base, in which case it converts:
4679 *
4680 * base <- intermediate <- top <- active
4681 *
4682 * to
4683 *
4684 * base <- active
4685 *
Jeff Cody54e26902014-06-25 15:40:10 -04004686 * If backing_file_str is non-NULL, it will be used when modifying top's
4687 * overlay image metadata.
4688 *
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004689 * Error conditions:
4690 * if active == top, that is considered an error
4691 *
4692 */
Kevin Wolfbde70712017-06-27 20:36:18 +02004693int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
4694 const char *backing_file_str)
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004695{
Alberto Garcia6bd858b2018-10-31 18:16:38 +02004696 BlockDriverState *explicit_top = top;
4697 bool update_inherits_from;
Kevin Wolf61f09ce2017-09-19 16:22:54 +02004698 BdrvChild *c, *next;
Kevin Wolf12fa4af2017-02-17 20:42:32 +01004699 Error *local_err = NULL;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004700 int ret = -EIO;
4701
Kevin Wolf6858eba2017-06-29 19:32:21 +02004702 bdrv_ref(top);
Max Reitz637d54a2019-07-22 15:33:43 +02004703 bdrv_subtree_drained_begin(top);
Kevin Wolf6858eba2017-06-29 19:32:21 +02004704
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004705 if (!top->drv || !base->drv) {
4706 goto exit;
4707 }
4708
Kevin Wolf5db15a52015-09-14 15:33:33 +02004709 /* Make sure that base is in the backing chain of top */
4710 if (!bdrv_chain_contains(top, base)) {
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004711 goto exit;
4712 }
4713
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02004714 /* This function changes all links that point to top and makes
4715 * them point to base. Check that none of them is frozen. */
4716 QLIST_FOREACH(c, &top->parents, next_parent) {
4717 if (c->frozen) {
4718 goto exit;
4719 }
4720 }
4721
Alberto Garcia6bd858b2018-10-31 18:16:38 +02004722 /* If 'base' recursively inherits from 'top' then we should set
4723 * base->inherits_from to top->inherits_from after 'top' and all
4724 * other intermediate nodes have been dropped.
4725 * If 'top' is an implicit node (e.g. "commit_top") we should skip
4726 * it because no one inherits from it. We use explicit_top for that. */
4727 while (explicit_top && explicit_top->implicit) {
4728 explicit_top = backing_bs(explicit_top);
4729 }
4730 update_inherits_from = bdrv_inherits_from_recursive(base, explicit_top);
4731
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004732 /* success - we can delete the intermediate states, and link top->base */
Kevin Wolfbde70712017-06-27 20:36:18 +02004733 /* TODO Check graph modification op blockers (BLK_PERM_GRAPH_MOD) once
4734 * we've figured out how they should work. */
Max Reitzf30c66b2019-02-01 20:29:05 +01004735 if (!backing_file_str) {
4736 bdrv_refresh_filename(base);
4737 backing_file_str = base->filename;
4738 }
Kevin Wolf61f09ce2017-09-19 16:22:54 +02004739
4740 QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) {
4741 /* Check whether we are allowed to switch c from top to base */
4742 GSList *ignore_children = g_slist_prepend(NULL, c);
Kevin Wolf2345bde2019-03-15 12:15:16 +01004743 ret = bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm,
Max Reitz9eab1542019-05-22 19:03:50 +02004744 ignore_children, NULL, &local_err);
Fam Zheng2c860e72018-03-15 11:51:57 +08004745 g_slist_free(ignore_children);
Kevin Wolf2345bde2019-03-15 12:15:16 +01004746 if (ret < 0) {
Kevin Wolf61f09ce2017-09-19 16:22:54 +02004747 error_report_err(local_err);
Kevin Wolf6858eba2017-06-29 19:32:21 +02004748 goto exit;
4749 }
Kevin Wolf12fa4af2017-02-17 20:42:32 +01004750
Kevin Wolf61f09ce2017-09-19 16:22:54 +02004751 /* If so, update the backing file path in the image file */
4752 if (c->role->update_filename) {
4753 ret = c->role->update_filename(c, base, backing_file_str,
4754 &local_err);
4755 if (ret < 0) {
4756 bdrv_abort_perm_update(base);
4757 error_report_err(local_err);
4758 goto exit;
4759 }
4760 }
4761
4762 /* Do the actual switch in the in-memory graph.
4763 * Completes bdrv_check_update_perm() transaction internally. */
4764 bdrv_ref(base);
4765 bdrv_replace_child(c, base);
4766 bdrv_unref(top);
Kevin Wolf12fa4af2017-02-17 20:42:32 +01004767 }
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004768
Alberto Garcia6bd858b2018-10-31 18:16:38 +02004769 if (update_inherits_from) {
4770 base->inherits_from = explicit_top->inherits_from;
4771 }
4772
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004773 ret = 0;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004774exit:
Max Reitz637d54a2019-07-22 15:33:43 +02004775 bdrv_subtree_drained_end(top);
Kevin Wolf6858eba2017-06-29 19:32:21 +02004776 bdrv_unref(top);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04004777 return ret;
4778}
4779
bellard83f64092006-08-01 16:21:11 +00004780/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08004781 * Length of a allocated file in bytes. Sparse files are counted by actual
4782 * allocated space. Return < 0 if error or unknown.
4783 */
4784int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
4785{
4786 BlockDriver *drv = bs->drv;
4787 if (!drv) {
4788 return -ENOMEDIUM;
4789 }
4790 if (drv->bdrv_get_allocated_file_size) {
4791 return drv->bdrv_get_allocated_file_size(bs);
4792 }
4793 if (bs->file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02004794 return bdrv_get_allocated_file_size(bs->file->bs);
Fam Zheng4a1d5e12011-07-12 19:56:39 +08004795 }
4796 return -ENOTSUP;
4797}
4798
Stefan Hajnoczi90880ff2017-07-05 13:57:30 +01004799/*
4800 * bdrv_measure:
4801 * @drv: Format driver
4802 * @opts: Creation options for new image
4803 * @in_bs: Existing image containing data for new image (may be NULL)
4804 * @errp: Error object
4805 * Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo())
4806 * or NULL on error
4807 *
4808 * Calculate file size required to create a new image.
4809 *
4810 * If @in_bs is given then space for allocated clusters and zero clusters
4811 * from that image are included in the calculation. If @opts contains a
4812 * backing file that is shared by @in_bs then backing clusters may be omitted
4813 * from the calculation.
4814 *
4815 * If @in_bs is NULL then the calculation includes no allocated clusters
4816 * unless a preallocation option is given in @opts.
4817 *
4818 * Note that @in_bs may use a different BlockDriver from @drv.
4819 *
4820 * If an error occurs the @errp pointer is set.
4821 */
4822BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
4823 BlockDriverState *in_bs, Error **errp)
4824{
4825 if (!drv->bdrv_measure) {
4826 error_setg(errp, "Block driver '%s' does not support size measurement",
4827 drv->format_name);
4828 return NULL;
4829 }
4830
4831 return drv->bdrv_measure(opts, in_bs, errp);
4832}
4833
Fam Zheng4a1d5e12011-07-12 19:56:39 +08004834/**
Markus Armbruster65a9bb22014-06-26 13:23:17 +02004835 * Return number of sectors on success, -errno on error.
bellard83f64092006-08-01 16:21:11 +00004836 */
Markus Armbruster65a9bb22014-06-26 13:23:17 +02004837int64_t bdrv_nb_sectors(BlockDriverState *bs)
bellard83f64092006-08-01 16:21:11 +00004838{
4839 BlockDriver *drv = bs->drv;
Markus Armbruster65a9bb22014-06-26 13:23:17 +02004840
bellard83f64092006-08-01 16:21:11 +00004841 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00004842 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01004843
Kevin Wolfb94a2612013-10-29 12:18:58 +01004844 if (drv->has_variable_length) {
4845 int ret = refresh_total_sectors(bs, bs->total_sectors);
4846 if (ret < 0) {
4847 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01004848 }
bellard83f64092006-08-01 16:21:11 +00004849 }
Markus Armbruster65a9bb22014-06-26 13:23:17 +02004850 return bs->total_sectors;
4851}
4852
4853/**
4854 * Return length in bytes on success, -errno on error.
4855 * The length is always a multiple of BDRV_SECTOR_SIZE.
4856 */
4857int64_t bdrv_getlength(BlockDriverState *bs)
4858{
4859 int64_t ret = bdrv_nb_sectors(bs);
4860
Fam Zheng4a9c9ea2015-05-15 16:36:05 +08004861 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
Markus Armbruster65a9bb22014-06-26 13:23:17 +02004862 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00004863}
4864
bellard19cb3732006-08-19 11:45:59 +00004865/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00004866void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00004867{
Markus Armbruster65a9bb22014-06-26 13:23:17 +02004868 int64_t nb_sectors = bdrv_nb_sectors(bs);
4869
4870 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
bellardfc01f7e2003-06-30 10:03:06 +00004871}
bellardcf989512004-02-16 21:56:36 +00004872
Eric Blake54115412016-06-23 16:37:26 -06004873bool bdrv_is_sg(BlockDriverState *bs)
ths985a03b2007-12-24 16:10:43 +00004874{
4875 return bs->sg;
4876}
4877
Eric Blake54115412016-06-23 16:37:26 -06004878bool bdrv_is_encrypted(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00004879{
Kevin Wolf760e0062015-06-17 14:55:21 +02004880 if (bs->backing && bs->backing->bs->encrypted) {
Eric Blake54115412016-06-23 16:37:26 -06004881 return true;
Kevin Wolf760e0062015-06-17 14:55:21 +02004882 }
bellardea2384d2004-08-01 21:59:26 +00004883 return bs->encrypted;
4884}
4885
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02004886const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00004887{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02004888 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00004889}
4890
Stefan Hajnocziada42402014-08-27 12:08:55 +01004891static int qsort_strcmp(const void *a, const void *b)
4892{
Max Reitzceff5bd2016-10-12 22:49:05 +02004893 return strcmp(*(char *const *)a, *(char *const *)b);
Stefan Hajnocziada42402014-08-27 12:08:55 +01004894}
4895
ths5fafdf22007-09-16 21:08:06 +00004896void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +03004897 void *opaque, bool read_only)
bellardea2384d2004-08-01 21:59:26 +00004898{
4899 BlockDriver *drv;
Jeff Codye855e4f2014-04-28 18:29:54 -04004900 int count = 0;
Stefan Hajnocziada42402014-08-27 12:08:55 +01004901 int i;
Jeff Codye855e4f2014-04-28 18:29:54 -04004902 const char **formats = NULL;
bellardea2384d2004-08-01 21:59:26 +00004903
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01004904 QLIST_FOREACH(drv, &bdrv_drivers, list) {
Jeff Codye855e4f2014-04-28 18:29:54 -04004905 if (drv->format_name) {
4906 bool found = false;
4907 int i = count;
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +03004908
4909 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, read_only)) {
4910 continue;
4911 }
4912
Jeff Codye855e4f2014-04-28 18:29:54 -04004913 while (formats && i && !found) {
4914 found = !strcmp(formats[--i], drv->format_name);
4915 }
4916
4917 if (!found) {
Markus Armbruster5839e532014-08-19 10:31:08 +02004918 formats = g_renew(const char *, formats, count + 1);
Jeff Codye855e4f2014-04-28 18:29:54 -04004919 formats[count++] = drv->format_name;
Jeff Codye855e4f2014-04-28 18:29:54 -04004920 }
4921 }
bellardea2384d2004-08-01 21:59:26 +00004922 }
Stefan Hajnocziada42402014-08-27 12:08:55 +01004923
Max Reitzeb0df692016-10-12 22:49:06 +02004924 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
4925 const char *format_name = block_driver_modules[i].format_name;
4926
4927 if (format_name) {
4928 bool found = false;
4929 int j = count;
4930
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +03004931 if (use_bdrv_whitelist &&
4932 !bdrv_format_is_whitelisted(format_name, read_only)) {
4933 continue;
4934 }
4935
Max Reitzeb0df692016-10-12 22:49:06 +02004936 while (formats && j && !found) {
4937 found = !strcmp(formats[--j], format_name);
4938 }
4939
4940 if (!found) {
4941 formats = g_renew(const char *, formats, count + 1);
4942 formats[count++] = format_name;
4943 }
4944 }
4945 }
4946
Stefan Hajnocziada42402014-08-27 12:08:55 +01004947 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
4948
4949 for (i = 0; i < count; i++) {
4950 it(opaque, formats[i]);
4951 }
4952
Jeff Codye855e4f2014-04-28 18:29:54 -04004953 g_free(formats);
bellardea2384d2004-08-01 21:59:26 +00004954}
4955
Benoît Canetdc364f42014-01-23 21:31:32 +01004956/* This function is to find a node in the bs graph */
4957BlockDriverState *bdrv_find_node(const char *node_name)
4958{
4959 BlockDriverState *bs;
4960
4961 assert(node_name);
4962
4963 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
4964 if (!strcmp(node_name, bs->node_name)) {
4965 return bs;
4966 }
4967 }
4968 return NULL;
4969}
4970
Benoît Canetc13163f2014-01-23 21:31:34 +01004971/* Put this QMP function here so it can access the static graph_bdrv_states. */
Peter Krempafacda542020-01-20 09:50:49 +01004972BlockDeviceInfoList *bdrv_named_nodes_list(bool flat,
4973 Error **errp)
Benoît Canetc13163f2014-01-23 21:31:34 +01004974{
4975 BlockDeviceInfoList *list, *entry;
4976 BlockDriverState *bs;
4977
4978 list = NULL;
4979 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
Peter Krempafacda542020-01-20 09:50:49 +01004980 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, flat, errp);
Alberto Garciad5a8ee62015-04-17 14:52:43 +03004981 if (!info) {
4982 qapi_free_BlockDeviceInfoList(list);
4983 return NULL;
4984 }
Benoît Canetc13163f2014-01-23 21:31:34 +01004985 entry = g_malloc0(sizeof(*entry));
Alberto Garciad5a8ee62015-04-17 14:52:43 +03004986 entry->value = info;
Benoît Canetc13163f2014-01-23 21:31:34 +01004987 entry->next = list;
4988 list = entry;
4989 }
4990
4991 return list;
4992}
4993
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03004994#define QAPI_LIST_ADD(list, element) do { \
4995 typeof(list) _tmp = g_new(typeof(*(list)), 1); \
4996 _tmp->value = (element); \
4997 _tmp->next = (list); \
4998 (list) = _tmp; \
4999} while (0)
5000
5001typedef struct XDbgBlockGraphConstructor {
5002 XDbgBlockGraph *graph;
5003 GHashTable *graph_nodes;
5004} XDbgBlockGraphConstructor;
5005
5006static XDbgBlockGraphConstructor *xdbg_graph_new(void)
5007{
5008 XDbgBlockGraphConstructor *gr = g_new(XDbgBlockGraphConstructor, 1);
5009
5010 gr->graph = g_new0(XDbgBlockGraph, 1);
5011 gr->graph_nodes = g_hash_table_new(NULL, NULL);
5012
5013 return gr;
5014}
5015
5016static XDbgBlockGraph *xdbg_graph_finalize(XDbgBlockGraphConstructor *gr)
5017{
5018 XDbgBlockGraph *graph = gr->graph;
5019
5020 g_hash_table_destroy(gr->graph_nodes);
5021 g_free(gr);
5022
5023 return graph;
5024}
5025
5026static uintptr_t xdbg_graph_node_num(XDbgBlockGraphConstructor *gr, void *node)
5027{
5028 uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node);
5029
5030 if (ret != 0) {
5031 return ret;
5032 }
5033
5034 /*
5035 * Start counting from 1, not 0, because 0 interferes with not-found (NULL)
5036 * answer of g_hash_table_lookup.
5037 */
5038 ret = g_hash_table_size(gr->graph_nodes) + 1;
5039 g_hash_table_insert(gr->graph_nodes, node, (void *)ret);
5040
5041 return ret;
5042}
5043
5044static void xdbg_graph_add_node(XDbgBlockGraphConstructor *gr, void *node,
5045 XDbgBlockGraphNodeType type, const char *name)
5046{
5047 XDbgBlockGraphNode *n;
5048
5049 n = g_new0(XDbgBlockGraphNode, 1);
5050
5051 n->id = xdbg_graph_node_num(gr, node);
5052 n->type = type;
5053 n->name = g_strdup(name);
5054
5055 QAPI_LIST_ADD(gr->graph->nodes, n);
5056}
5057
5058static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent,
5059 const BdrvChild *child)
5060{
Max Reitzcdb1cec2019-11-08 13:34:52 +01005061 BlockPermission qapi_perm;
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03005062 XDbgBlockGraphEdge *edge;
5063
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03005064 edge = g_new0(XDbgBlockGraphEdge, 1);
5065
5066 edge->parent = xdbg_graph_node_num(gr, parent);
5067 edge->child = xdbg_graph_node_num(gr, child->bs);
5068 edge->name = g_strdup(child->name);
5069
Max Reitzcdb1cec2019-11-08 13:34:52 +01005070 for (qapi_perm = 0; qapi_perm < BLOCK_PERMISSION__MAX; qapi_perm++) {
5071 uint64_t flag = bdrv_qapi_perm_to_blk_perm(qapi_perm);
5072
5073 if (flag & child->perm) {
5074 QAPI_LIST_ADD(edge->perm, qapi_perm);
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03005075 }
Max Reitzcdb1cec2019-11-08 13:34:52 +01005076 if (flag & child->shared_perm) {
5077 QAPI_LIST_ADD(edge->shared_perm, qapi_perm);
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03005078 }
5079 }
5080
5081 QAPI_LIST_ADD(gr->graph->edges, edge);
5082}
5083
5084
5085XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp)
5086{
5087 BlockBackend *blk;
5088 BlockJob *job;
5089 BlockDriverState *bs;
5090 BdrvChild *child;
5091 XDbgBlockGraphConstructor *gr = xdbg_graph_new();
5092
5093 for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {
5094 char *allocated_name = NULL;
5095 const char *name = blk_name(blk);
5096
5097 if (!*name) {
5098 name = allocated_name = blk_get_attached_dev_id(blk);
5099 }
5100 xdbg_graph_add_node(gr, blk, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_BACKEND,
5101 name);
5102 g_free(allocated_name);
5103 if (blk_root(blk)) {
5104 xdbg_graph_add_edge(gr, blk, blk_root(blk));
5105 }
5106 }
5107
5108 for (job = block_job_next(NULL); job; job = block_job_next(job)) {
5109 GSList *el;
5110
5111 xdbg_graph_add_node(gr, job, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_JOB,
5112 job->job.id);
5113 for (el = job->nodes; el; el = el->next) {
5114 xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data);
5115 }
5116 }
5117
5118 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
5119 xdbg_graph_add_node(gr, bs, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_DRIVER,
5120 bs->node_name);
5121 QLIST_FOREACH(child, &bs->children, next) {
5122 xdbg_graph_add_edge(gr, bs, child);
5123 }
5124 }
5125
5126 return xdbg_graph_finalize(gr);
5127}
5128
Benoît Canet12d3ba82014-01-23 21:31:35 +01005129BlockDriverState *bdrv_lookup_bs(const char *device,
5130 const char *node_name,
5131 Error **errp)
5132{
Markus Armbruster7f06d472014-10-07 13:59:12 +02005133 BlockBackend *blk;
5134 BlockDriverState *bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01005135
Benoît Canet12d3ba82014-01-23 21:31:35 +01005136 if (device) {
Markus Armbruster7f06d472014-10-07 13:59:12 +02005137 blk = blk_by_name(device);
Benoît Canet12d3ba82014-01-23 21:31:35 +01005138
Markus Armbruster7f06d472014-10-07 13:59:12 +02005139 if (blk) {
Alberto Garcia9f4ed6f2015-10-26 16:46:49 +02005140 bs = blk_bs(blk);
5141 if (!bs) {
Max Reitz5433c242015-10-19 17:53:29 +02005142 error_setg(errp, "Device '%s' has no medium", device);
Max Reitz5433c242015-10-19 17:53:29 +02005143 }
5144
Alberto Garcia9f4ed6f2015-10-26 16:46:49 +02005145 return bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01005146 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01005147 }
5148
Benoît Canetdd67fa52014-02-12 17:15:06 +01005149 if (node_name) {
5150 bs = bdrv_find_node(node_name);
Benoît Canet12d3ba82014-01-23 21:31:35 +01005151
Benoît Canetdd67fa52014-02-12 17:15:06 +01005152 if (bs) {
5153 return bs;
5154 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01005155 }
5156
Benoît Canetdd67fa52014-02-12 17:15:06 +01005157 error_setg(errp, "Cannot find device=%s nor node_name=%s",
5158 device ? device : "",
5159 node_name ? node_name : "");
5160 return NULL;
Benoît Canet12d3ba82014-01-23 21:31:35 +01005161}
5162
Jeff Cody5a6684d2014-06-25 15:40:09 -04005163/* If 'base' is in the same chain as 'top', return true. Otherwise,
5164 * return false. If either argument is NULL, return false. */
5165bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
5166{
5167 while (top && top != base) {
Kevin Wolf760e0062015-06-17 14:55:21 +02005168 top = backing_bs(top);
Jeff Cody5a6684d2014-06-25 15:40:09 -04005169 }
5170
5171 return top != NULL;
5172}
5173
Fam Zheng04df7652014-10-31 11:32:54 +08005174BlockDriverState *bdrv_next_node(BlockDriverState *bs)
5175{
5176 if (!bs) {
5177 return QTAILQ_FIRST(&graph_bdrv_states);
5178 }
5179 return QTAILQ_NEXT(bs, node_list);
5180}
5181
Kevin Wolf0f122642018-03-28 18:29:18 +02005182BlockDriverState *bdrv_next_all_states(BlockDriverState *bs)
5183{
5184 if (!bs) {
5185 return QTAILQ_FIRST(&all_bdrv_states);
5186 }
5187 return QTAILQ_NEXT(bs, bs_list);
5188}
5189
Fam Zheng20a9e772014-10-31 11:32:55 +08005190const char *bdrv_get_node_name(const BlockDriverState *bs)
5191{
5192 return bs->node_name;
5193}
5194
Kevin Wolf1f0c4612016-03-22 18:38:44 +01005195const char *bdrv_get_parent_name(const BlockDriverState *bs)
Kevin Wolf4c265bf2016-02-26 10:22:16 +01005196{
5197 BdrvChild *c;
5198 const char *name;
5199
5200 /* If multiple parents have a name, just pick the first one. */
5201 QLIST_FOREACH(c, &bs->parents, next_parent) {
5202 if (c->role->get_name) {
5203 name = c->role->get_name(c);
5204 if (name && *name) {
5205 return name;
5206 }
5207 }
5208 }
5209
5210 return NULL;
5211}
5212
Markus Armbruster7f06d472014-10-07 13:59:12 +02005213/* TODO check what callers really want: bs->node_name or blk_name() */
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02005214const char *bdrv_get_device_name(const BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00005215{
Kevin Wolf4c265bf2016-02-26 10:22:16 +01005216 return bdrv_get_parent_name(bs) ?: "";
bellardea2384d2004-08-01 21:59:26 +00005217}
5218
Alberto Garcia9b2aa842015-04-08 12:29:18 +03005219/* This can be used to identify nodes that might not have a device
5220 * name associated. Since node and device names live in the same
5221 * namespace, the result is unambiguous. The exception is if both are
5222 * absent, then this returns an empty (non-null) string. */
5223const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
5224{
Kevin Wolf4c265bf2016-02-26 10:22:16 +01005225 return bdrv_get_parent_name(bs) ?: bs->node_name;
Alberto Garcia9b2aa842015-04-08 12:29:18 +03005226}
5227
Markus Armbrusterc8433282012-06-05 16:49:24 +02005228int bdrv_get_flags(BlockDriverState *bs)
5229{
5230 return bs->open_flags;
5231}
5232
Peter Lieven3ac21622013-06-28 12:47:42 +02005233int bdrv_has_zero_init_1(BlockDriverState *bs)
5234{
5235 return 1;
5236}
5237
Kevin Wolff2feebb2010-04-14 17:30:35 +02005238int bdrv_has_zero_init(BlockDriverState *bs)
5239{
Max Reitzd470ad42017-11-10 21:31:09 +01005240 if (!bs->drv) {
5241 return 0;
5242 }
Kevin Wolff2feebb2010-04-14 17:30:35 +02005243
Paolo Bonzini11212d82013-09-04 19:00:27 +02005244 /* If BS is a copy on write image, it is initialized to
5245 the contents of the base image, which may not be zeroes. */
Kevin Wolf760e0062015-06-17 14:55:21 +02005246 if (bs->backing) {
Paolo Bonzini11212d82013-09-04 19:00:27 +02005247 return 0;
5248 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02005249 if (bs->drv->bdrv_has_zero_init) {
5250 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02005251 }
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03005252 if (bs->file && bs->drv->is_filter) {
5253 return bdrv_has_zero_init(bs->file->bs);
5254 }
Kevin Wolff2feebb2010-04-14 17:30:35 +02005255
Peter Lieven3ac21622013-06-28 12:47:42 +02005256 /* safe default */
5257 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02005258}
5259
Max Reitzceaca562019-07-24 19:12:31 +02005260int bdrv_has_zero_init_truncate(BlockDriverState *bs)
5261{
5262 if (!bs->drv) {
5263 return 0;
5264 }
5265
5266 if (bs->backing) {
5267 /* Depends on the backing image length, but better safe than sorry */
5268 return 0;
5269 }
5270 if (bs->drv->bdrv_has_zero_init_truncate) {
5271 return bs->drv->bdrv_has_zero_init_truncate(bs);
5272 }
5273 if (bs->file && bs->drv->is_filter) {
5274 return bdrv_has_zero_init_truncate(bs->file->bs);
5275 }
5276
5277 /* safe default */
5278 return 0;
5279}
5280
Peter Lieven4ce78692013-10-24 12:06:54 +02005281bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
5282{
5283 BlockDriverInfo bdi;
5284
Kevin Wolf760e0062015-06-17 14:55:21 +02005285 if (bs->backing) {
Peter Lieven4ce78692013-10-24 12:06:54 +02005286 return false;
5287 }
5288
5289 if (bdrv_get_info(bs, &bdi) == 0) {
5290 return bdi.unallocated_blocks_are_zero;
5291 }
5292
5293 return false;
5294}
5295
5296bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
5297{
Denis V. Lunev2f0342e2016-07-14 16:33:26 +03005298 if (!(bs->open_flags & BDRV_O_UNMAP)) {
Peter Lieven4ce78692013-10-24 12:06:54 +02005299 return false;
5300 }
5301
Eric Blakee24d8132018-01-26 13:34:39 -06005302 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP;
Peter Lieven4ce78692013-10-24 12:06:54 +02005303}
5304
ths5fafdf22007-09-16 21:08:06 +00005305void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00005306 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00005307{
Kevin Wolf3574c602011-10-26 11:02:11 +02005308 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00005309}
5310
bellardfaea38e2006-08-05 21:31:00 +00005311int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
5312{
5313 BlockDriver *drv = bs->drv;
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03005314 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
5315 if (!drv) {
bellard19cb3732006-08-19 11:45:59 +00005316 return -ENOMEDIUM;
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03005317 }
5318 if (!drv->bdrv_get_info) {
5319 if (bs->file && drv->is_filter) {
5320 return bdrv_get_info(bs->file->bs, bdi);
5321 }
bellardfaea38e2006-08-05 21:31:00 +00005322 return -ENOTSUP;
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03005323 }
bellardfaea38e2006-08-05 21:31:00 +00005324 memset(bdi, 0, sizeof(*bdi));
5325 return drv->bdrv_get_info(bs, bdi);
5326}
5327
Andrey Shinkevich1bf6e9c2019-02-08 18:06:06 +03005328ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs,
5329 Error **errp)
Max Reitzeae041f2013-10-09 10:46:16 +02005330{
5331 BlockDriver *drv = bs->drv;
5332 if (drv && drv->bdrv_get_specific_info) {
Andrey Shinkevich1bf6e9c2019-02-08 18:06:06 +03005333 return drv->bdrv_get_specific_info(bs, errp);
Max Reitzeae041f2013-10-09 10:46:16 +02005334 }
5335 return NULL;
5336}
5337
Anton Nefedovd9245592019-09-23 15:17:37 +03005338BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs)
5339{
5340 BlockDriver *drv = bs->drv;
5341 if (!drv || !drv->bdrv_get_specific_stats) {
5342 return NULL;
5343 }
5344 return drv->bdrv_get_specific_stats(bs);
5345}
5346
Eric Blakea31939e2015-11-18 01:52:54 -07005347void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01005348{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02005349 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01005350 return;
5351 }
5352
Kevin Wolfbf736fe2013-06-05 15:17:55 +02005353 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01005354}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01005355
Vladimir Sementsov-Ogievskiyd10529a2019-09-20 17:20:49 +03005356static BlockDriverState *bdrv_find_debug_node(BlockDriverState *bs)
Kevin Wolf41c695c2012-12-06 14:32:58 +01005357{
5358 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
Vladimir Sementsov-Ogievskiyd10529a2019-09-20 17:20:49 +03005359 if (bs->file) {
5360 bs = bs->file->bs;
5361 continue;
5362 }
5363
5364 if (bs->drv->is_filter && bs->backing) {
5365 bs = bs->backing->bs;
5366 continue;
5367 }
5368
5369 break;
Kevin Wolf41c695c2012-12-06 14:32:58 +01005370 }
5371
5372 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
Vladimir Sementsov-Ogievskiyd10529a2019-09-20 17:20:49 +03005373 assert(bs->drv->bdrv_debug_remove_breakpoint);
5374 return bs;
5375 }
5376
5377 return NULL;
5378}
5379
5380int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
5381 const char *tag)
5382{
5383 bs = bdrv_find_debug_node(bs);
5384 if (bs) {
Kevin Wolf41c695c2012-12-06 14:32:58 +01005385 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
5386 }
5387
5388 return -ENOTSUP;
5389}
5390
Fam Zheng4cc70e92013-11-20 10:01:54 +08005391int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
5392{
Vladimir Sementsov-Ogievskiyd10529a2019-09-20 17:20:49 +03005393 bs = bdrv_find_debug_node(bs);
5394 if (bs) {
Fam Zheng4cc70e92013-11-20 10:01:54 +08005395 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
5396 }
5397
5398 return -ENOTSUP;
5399}
5400
Kevin Wolf41c695c2012-12-06 14:32:58 +01005401int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
5402{
Max Reitz938789e2014-03-10 23:44:08 +01005403 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02005404 bs = bs->file ? bs->file->bs : NULL;
Kevin Wolf41c695c2012-12-06 14:32:58 +01005405 }
5406
5407 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
5408 return bs->drv->bdrv_debug_resume(bs, tag);
5409 }
5410
5411 return -ENOTSUP;
5412}
5413
5414bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
5415{
5416 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02005417 bs = bs->file ? bs->file->bs : NULL;
Kevin Wolf41c695c2012-12-06 14:32:58 +01005418 }
5419
5420 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
5421 return bs->drv->bdrv_debug_is_suspended(bs, tag);
5422 }
5423
5424 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01005425}
5426
Jeff Codyb1b1d782012-10-16 15:49:09 -04005427/* backing_file can either be relative, or absolute, or a protocol. If it is
5428 * relative, it must be relative to the chain. So, passing in bs->filename
5429 * from a BDS as backing_file should not be done, as that may be relative to
5430 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00005431BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
5432 const char *backing_file)
5433{
Jeff Codyb1b1d782012-10-16 15:49:09 -04005434 char *filename_full = NULL;
5435 char *backing_file_full = NULL;
5436 char *filename_tmp = NULL;
5437 int is_protocol = 0;
5438 BlockDriverState *curr_bs = NULL;
5439 BlockDriverState *retval = NULL;
5440
5441 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00005442 return NULL;
5443 }
5444
Jeff Codyb1b1d782012-10-16 15:49:09 -04005445 filename_full = g_malloc(PATH_MAX);
5446 backing_file_full = g_malloc(PATH_MAX);
Jeff Codyb1b1d782012-10-16 15:49:09 -04005447
5448 is_protocol = path_has_protocol(backing_file);
5449
Kevin Wolf760e0062015-06-17 14:55:21 +02005450 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
Jeff Codyb1b1d782012-10-16 15:49:09 -04005451
5452 /* If either of the filename paths is actually a protocol, then
5453 * compare unmodified paths; otherwise make paths relative */
5454 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
Max Reitz6b6833c2019-02-01 20:29:15 +01005455 char *backing_file_full_ret;
5456
Jeff Codyb1b1d782012-10-16 15:49:09 -04005457 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
Kevin Wolf760e0062015-06-17 14:55:21 +02005458 retval = curr_bs->backing->bs;
Jeff Codyb1b1d782012-10-16 15:49:09 -04005459 break;
5460 }
Jeff Cody418661e2017-01-25 20:08:20 -05005461 /* Also check against the full backing filename for the image */
Max Reitz6b6833c2019-02-01 20:29:15 +01005462 backing_file_full_ret = bdrv_get_full_backing_filename(curr_bs,
5463 NULL);
5464 if (backing_file_full_ret) {
5465 bool equal = strcmp(backing_file, backing_file_full_ret) == 0;
5466 g_free(backing_file_full_ret);
5467 if (equal) {
Jeff Cody418661e2017-01-25 20:08:20 -05005468 retval = curr_bs->backing->bs;
5469 break;
5470 }
Jeff Cody418661e2017-01-25 20:08:20 -05005471 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00005472 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04005473 /* If not an absolute filename path, make it relative to the current
5474 * image's filename path */
Max Reitz2d9158c2019-02-01 20:29:17 +01005475 filename_tmp = bdrv_make_absolute_filename(curr_bs, backing_file,
5476 NULL);
5477 /* We are going to compare canonicalized absolute pathnames */
5478 if (!filename_tmp || !realpath(filename_tmp, filename_full)) {
5479 g_free(filename_tmp);
Jeff Codyb1b1d782012-10-16 15:49:09 -04005480 continue;
5481 }
Max Reitz2d9158c2019-02-01 20:29:17 +01005482 g_free(filename_tmp);
Jeff Codyb1b1d782012-10-16 15:49:09 -04005483
5484 /* We need to make sure the backing filename we are comparing against
5485 * is relative to the current image filename (or absolute) */
Max Reitz2d9158c2019-02-01 20:29:17 +01005486 filename_tmp = bdrv_get_full_backing_filename(curr_bs, NULL);
5487 if (!filename_tmp || !realpath(filename_tmp, backing_file_full)) {
5488 g_free(filename_tmp);
Jeff Codyb1b1d782012-10-16 15:49:09 -04005489 continue;
5490 }
Max Reitz2d9158c2019-02-01 20:29:17 +01005491 g_free(filename_tmp);
Jeff Codyb1b1d782012-10-16 15:49:09 -04005492
5493 if (strcmp(backing_file_full, filename_full) == 0) {
Kevin Wolf760e0062015-06-17 14:55:21 +02005494 retval = curr_bs->backing->bs;
Jeff Codyb1b1d782012-10-16 15:49:09 -04005495 break;
5496 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00005497 }
5498 }
5499
Jeff Codyb1b1d782012-10-16 15:49:09 -04005500 g_free(filename_full);
5501 g_free(backing_file_full);
Jeff Codyb1b1d782012-10-16 15:49:09 -04005502 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00005503}
5504
bellardea2384d2004-08-01 21:59:26 +00005505void bdrv_init(void)
5506{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05005507 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00005508}
pbrookce1a14d2006-08-07 02:38:06 +00005509
Markus Armbrustereb852012009-10-27 18:41:44 +01005510void bdrv_init_with_whitelist(void)
5511{
5512 use_bdrv_whitelist = 1;
5513 bdrv_init();
5514}
5515
Paolo Bonzini2b148f32018-03-01 17:36:18 +01005516static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
5517 Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06005518{
Kevin Wolf4417ab72017-05-04 18:52:37 +02005519 BdrvChild *child, *parent;
Kevin Wolf9c5e6592017-05-04 18:52:40 +02005520 uint64_t perm, shared_perm;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005521 Error *local_err = NULL;
5522 int ret;
Vladimir Sementsov-Ogievskiy9c98f142018-10-29 16:23:17 -04005523 BdrvDirtyBitmap *bm;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005524
Kevin Wolf3456a8d2014-03-11 10:58:39 +01005525 if (!bs->drv) {
5526 return;
Anthony Liguori0f154232011-11-14 15:09:45 -06005527 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01005528
Vladimir Sementsov-Ogievskiy16e977d2017-01-31 14:23:08 +03005529 QLIST_FOREACH(child, &bs->children, next) {
Paolo Bonzini2b148f32018-03-01 17:36:18 +01005530 bdrv_co_invalidate_cache(child->bs, &local_err);
Fam Zheng0d1c5c92016-05-11 10:45:33 +08005531 if (local_err) {
Fam Zheng0d1c5c92016-05-11 10:45:33 +08005532 error_propagate(errp, local_err);
5533 return;
5534 }
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005535 }
Fam Zheng0d1c5c92016-05-11 10:45:33 +08005536
Kevin Wolfdafe0962017-11-16 13:00:01 +01005537 /*
5538 * Update permissions, they may differ for inactive nodes.
5539 *
5540 * Note that the required permissions of inactive images are always a
5541 * subset of the permissions required after activating the image. This
5542 * allows us to just get the permissions upfront without restricting
5543 * drv->bdrv_invalidate_cache().
5544 *
5545 * It also means that in error cases, we don't have to try and revert to
5546 * the old permissions (which is an operation that could fail, too). We can
5547 * just keep the extended permissions for the next time that an activation
5548 * of the image is tried.
5549 */
Kevin Wolf7bb49412019-12-17 15:06:38 +01005550 if (bs->open_flags & BDRV_O_INACTIVE) {
5551 bs->open_flags &= ~BDRV_O_INACTIVE;
5552 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
5553 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, &local_err);
5554 if (ret < 0) {
Fam Zheng0d1c5c92016-05-11 10:45:33 +08005555 bs->open_flags |= BDRV_O_INACTIVE;
5556 error_propagate(errp, local_err);
5557 return;
5558 }
Kevin Wolf7bb49412019-12-17 15:06:38 +01005559 bdrv_set_perm(bs, perm, shared_perm);
Kevin Wolf3456a8d2014-03-11 10:58:39 +01005560
Kevin Wolf7bb49412019-12-17 15:06:38 +01005561 if (bs->drv->bdrv_co_invalidate_cache) {
5562 bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
5563 if (local_err) {
5564 bs->open_flags |= BDRV_O_INACTIVE;
5565 error_propagate(errp, local_err);
5566 return;
5567 }
5568 }
Vladimir Sementsov-Ogievskiy9c98f142018-10-29 16:23:17 -04005569
Kevin Wolf7bb49412019-12-17 15:06:38 +01005570 FOR_EACH_DIRTY_BITMAP(bs, bm) {
5571 bdrv_dirty_bitmap_skip_store(bm, false);
5572 }
5573
5574 ret = refresh_total_sectors(bs, bs->total_sectors);
5575 if (ret < 0) {
5576 bs->open_flags |= BDRV_O_INACTIVE;
5577 error_setg_errno(errp, -ret, "Could not refresh total sector count");
5578 return;
5579 }
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005580 }
Kevin Wolf4417ab72017-05-04 18:52:37 +02005581
5582 QLIST_FOREACH(parent, &bs->parents, next_parent) {
5583 if (parent->role->activate) {
5584 parent->role->activate(parent, &local_err);
5585 if (local_err) {
Kevin Wolf78fc3b32019-01-31 15:16:10 +01005586 bs->open_flags |= BDRV_O_INACTIVE;
Kevin Wolf4417ab72017-05-04 18:52:37 +02005587 error_propagate(errp, local_err);
5588 return;
5589 }
5590 }
5591 }
Anthony Liguori0f154232011-11-14 15:09:45 -06005592}
5593
Paolo Bonzini2b148f32018-03-01 17:36:18 +01005594typedef struct InvalidateCacheCo {
5595 BlockDriverState *bs;
5596 Error **errp;
5597 bool done;
5598} InvalidateCacheCo;
5599
5600static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque)
5601{
5602 InvalidateCacheCo *ico = opaque;
5603 bdrv_co_invalidate_cache(ico->bs, ico->errp);
5604 ico->done = true;
Kevin Wolf4720cbe2019-01-07 13:02:48 +01005605 aio_wait_kick();
Paolo Bonzini2b148f32018-03-01 17:36:18 +01005606}
5607
5608void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
5609{
5610 Coroutine *co;
5611 InvalidateCacheCo ico = {
5612 .bs = bs,
5613 .done = false,
5614 .errp = errp
5615 };
5616
5617 if (qemu_in_coroutine()) {
5618 /* Fast-path if already in coroutine context */
5619 bdrv_invalidate_cache_co_entry(&ico);
5620 } else {
5621 co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico);
Kevin Wolf4720cbe2019-01-07 13:02:48 +01005622 bdrv_coroutine_enter(bs, co);
Paolo Bonzini2b148f32018-03-01 17:36:18 +01005623 BDRV_POLL_WHILE(bs, !ico.done);
5624 }
5625}
5626
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005627void bdrv_invalidate_cache_all(Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06005628{
Kevin Wolf7c8eece2016-03-22 18:58:50 +01005629 BlockDriverState *bs;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005630 Error *local_err = NULL;
Kevin Wolf88be7b42016-05-20 18:49:07 +02005631 BdrvNextIterator it;
Anthony Liguori0f154232011-11-14 15:09:45 -06005632
Kevin Wolf88be7b42016-05-20 18:49:07 +02005633 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02005634 AioContext *aio_context = bdrv_get_aio_context(bs);
5635
5636 aio_context_acquire(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005637 bdrv_invalidate_cache(bs, &local_err);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02005638 aio_context_release(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005639 if (local_err) {
5640 error_propagate(errp, local_err);
Max Reitz5e003f12017-11-10 18:25:45 +01005641 bdrv_next_cleanup(&it);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005642 return;
5643 }
Anthony Liguori0f154232011-11-14 15:09:45 -06005644 }
5645}
5646
Kevin Wolf9e372712018-11-23 15:11:14 +01005647static bool bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
5648{
5649 BdrvChild *parent;
5650
5651 QLIST_FOREACH(parent, &bs->parents, next_parent) {
5652 if (parent->role->parent_is_bds) {
5653 BlockDriverState *parent_bs = parent->opaque;
5654 if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) {
5655 return true;
5656 }
5657 }
5658 }
5659
5660 return false;
5661}
5662
5663static int bdrv_inactivate_recurse(BlockDriverState *bs)
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01005664{
Kevin Wolfcfa1a572017-05-04 18:52:38 +02005665 BdrvChild *child, *parent;
Max Reitz10467792019-05-22 19:03:51 +02005666 bool tighten_restrictions;
Kevin Wolf9e372712018-11-23 15:11:14 +01005667 uint64_t perm, shared_perm;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01005668 int ret;
5669
Max Reitzd470ad42017-11-10 21:31:09 +01005670 if (!bs->drv) {
5671 return -ENOMEDIUM;
5672 }
5673
Kevin Wolf9e372712018-11-23 15:11:14 +01005674 /* Make sure that we don't inactivate a child before its parent.
5675 * It will be covered by recursion from the yet active parent. */
5676 if (bdrv_has_bds_parent(bs, true)) {
5677 return 0;
5678 }
5679
5680 assert(!(bs->open_flags & BDRV_O_INACTIVE));
5681
5682 /* Inactivate this node */
5683 if (bs->drv->bdrv_inactivate) {
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01005684 ret = bs->drv->bdrv_inactivate(bs);
5685 if (ret < 0) {
5686 return ret;
5687 }
5688 }
5689
Kevin Wolf9e372712018-11-23 15:11:14 +01005690 QLIST_FOREACH(parent, &bs->parents, next_parent) {
5691 if (parent->role->inactivate) {
5692 ret = parent->role->inactivate(parent);
5693 if (ret < 0) {
5694 return ret;
Kevin Wolfcfa1a572017-05-04 18:52:38 +02005695 }
5696 }
Fam Zhengaad0b7a2016-05-11 10:45:35 +08005697 }
Kevin Wolf38701b62017-05-04 18:52:39 +02005698
Kevin Wolf9e372712018-11-23 15:11:14 +01005699 bs->open_flags |= BDRV_O_INACTIVE;
5700
5701 /* Update permissions, they may differ for inactive nodes */
5702 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
Max Reitz10467792019-05-22 19:03:51 +02005703 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL,
5704 &tighten_restrictions, NULL);
5705 assert(tighten_restrictions == false);
5706 if (ret < 0) {
5707 /* We only tried to loosen restrictions, so errors are not fatal */
5708 bdrv_abort_perm_update(bs);
5709 } else {
5710 bdrv_set_perm(bs, perm, shared_perm);
5711 }
Kevin Wolf9e372712018-11-23 15:11:14 +01005712
5713
5714 /* Recursively inactivate children */
Kevin Wolf38701b62017-05-04 18:52:39 +02005715 QLIST_FOREACH(child, &bs->children, next) {
Kevin Wolf9e372712018-11-23 15:11:14 +01005716 ret = bdrv_inactivate_recurse(child->bs);
Kevin Wolf38701b62017-05-04 18:52:39 +02005717 if (ret < 0) {
5718 return ret;
5719 }
5720 }
5721
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01005722 return 0;
5723}
5724
5725int bdrv_inactivate_all(void)
5726{
Max Reitz79720af2016-03-16 19:54:44 +01005727 BlockDriverState *bs = NULL;
Kevin Wolf88be7b42016-05-20 18:49:07 +02005728 BdrvNextIterator it;
Fam Zhengaad0b7a2016-05-11 10:45:35 +08005729 int ret = 0;
Paolo Bonzinibd6458e2017-12-07 20:13:15 +00005730 GSList *aio_ctxs = NULL, *ctx;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01005731
Kevin Wolf88be7b42016-05-20 18:49:07 +02005732 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Paolo Bonzinibd6458e2017-12-07 20:13:15 +00005733 AioContext *aio_context = bdrv_get_aio_context(bs);
5734
5735 if (!g_slist_find(aio_ctxs, aio_context)) {
5736 aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
5737 aio_context_acquire(aio_context);
5738 }
Fam Zhengaad0b7a2016-05-11 10:45:35 +08005739 }
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01005740
Kevin Wolf9e372712018-11-23 15:11:14 +01005741 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
5742 /* Nodes with BDS parents are covered by recursion from the last
5743 * parent that gets inactivated. Don't inactivate them a second
5744 * time if that has already happened. */
5745 if (bdrv_has_bds_parent(bs, false)) {
5746 continue;
5747 }
5748 ret = bdrv_inactivate_recurse(bs);
5749 if (ret < 0) {
5750 bdrv_next_cleanup(&it);
5751 goto out;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01005752 }
5753 }
5754
Fam Zhengaad0b7a2016-05-11 10:45:35 +08005755out:
Paolo Bonzinibd6458e2017-12-07 20:13:15 +00005756 for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
5757 AioContext *aio_context = ctx->data;
5758 aio_context_release(aio_context);
Fam Zhengaad0b7a2016-05-11 10:45:35 +08005759 }
Paolo Bonzinibd6458e2017-12-07 20:13:15 +00005760 g_slist_free(aio_ctxs);
Fam Zhengaad0b7a2016-05-11 10:45:35 +08005761
5762 return ret;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01005763}
5764
Kevin Wolff9f05dc2011-07-15 13:50:26 +02005765/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00005766/* removable device support */
5767
5768/**
5769 * Return TRUE if the media is present
5770 */
Max Reitze031f752015-10-19 17:53:11 +02005771bool bdrv_is_inserted(BlockDriverState *bs)
bellard19cb3732006-08-19 11:45:59 +00005772{
5773 BlockDriver *drv = bs->drv;
Max Reitz28d7a782015-10-19 17:53:13 +02005774 BdrvChild *child;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02005775
Max Reitze031f752015-10-19 17:53:11 +02005776 if (!drv) {
5777 return false;
5778 }
Max Reitz28d7a782015-10-19 17:53:13 +02005779 if (drv->bdrv_is_inserted) {
5780 return drv->bdrv_is_inserted(bs);
Max Reitze031f752015-10-19 17:53:11 +02005781 }
Max Reitz28d7a782015-10-19 17:53:13 +02005782 QLIST_FOREACH(child, &bs->children, next) {
5783 if (!bdrv_is_inserted(child->bs)) {
5784 return false;
5785 }
5786 }
5787 return true;
bellard19cb3732006-08-19 11:45:59 +00005788}
5789
5790/**
bellard19cb3732006-08-19 11:45:59 +00005791 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5792 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02005793void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00005794{
5795 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00005796
Markus Armbruster822e1cd2011-07-20 18:23:42 +02005797 if (drv && drv->bdrv_eject) {
5798 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00005799 }
bellard19cb3732006-08-19 11:45:59 +00005800}
5801
bellard19cb3732006-08-19 11:45:59 +00005802/**
5803 * Lock or unlock the media (if it is locked, the user won't be able
5804 * to eject it manually).
5805 */
Markus Armbruster025e8492011-09-06 18:58:47 +02005806void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00005807{
5808 BlockDriver *drv = bs->drv;
5809
Markus Armbruster025e8492011-09-06 18:58:47 +02005810 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01005811
Markus Armbruster025e8492011-09-06 18:58:47 +02005812 if (drv && drv->bdrv_lock_medium) {
5813 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00005814 }
5815}
ths985a03b2007-12-24 16:10:43 +00005816
Fam Zheng9fcb0252013-08-23 09:14:46 +08005817/* Get a reference to bs */
5818void bdrv_ref(BlockDriverState *bs)
5819{
5820 bs->refcnt++;
5821}
5822
5823/* Release a previously grabbed reference to bs.
5824 * If after releasing, reference count is zero, the BlockDriverState is
5825 * deleted. */
5826void bdrv_unref(BlockDriverState *bs)
5827{
Jeff Cody9a4d5ca2014-07-23 17:22:57 -04005828 if (!bs) {
5829 return;
5830 }
Fam Zheng9fcb0252013-08-23 09:14:46 +08005831 assert(bs->refcnt > 0);
5832 if (--bs->refcnt == 0) {
5833 bdrv_delete(bs);
5834 }
5835}
5836
Fam Zhengfbe40ff2014-05-23 21:29:42 +08005837struct BdrvOpBlocker {
5838 Error *reason;
5839 QLIST_ENTRY(BdrvOpBlocker) list;
5840};
5841
5842bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5843{
5844 BdrvOpBlocker *blocker;
5845 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5846 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5847 blocker = QLIST_FIRST(&bs->op_blockers[op]);
Markus Armbruster4b576642018-10-17 10:26:25 +02005848 error_propagate_prepend(errp, error_copy(blocker->reason),
5849 "Node '%s' is busy: ",
5850 bdrv_get_device_or_node_name(bs));
Fam Zhengfbe40ff2014-05-23 21:29:42 +08005851 return true;
5852 }
5853 return false;
5854}
5855
5856void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5857{
5858 BdrvOpBlocker *blocker;
5859 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5860
Markus Armbruster5839e532014-08-19 10:31:08 +02005861 blocker = g_new0(BdrvOpBlocker, 1);
Fam Zhengfbe40ff2014-05-23 21:29:42 +08005862 blocker->reason = reason;
5863 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5864}
5865
5866void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5867{
5868 BdrvOpBlocker *blocker, *next;
5869 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5870 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5871 if (blocker->reason == reason) {
5872 QLIST_REMOVE(blocker, list);
5873 g_free(blocker);
5874 }
5875 }
5876}
5877
5878void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5879{
5880 int i;
5881 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5882 bdrv_op_block(bs, i, reason);
5883 }
5884}
5885
5886void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5887{
5888 int i;
5889 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5890 bdrv_op_unblock(bs, i, reason);
5891 }
5892}
5893
5894bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5895{
5896 int i;
5897
5898 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5899 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5900 return false;
5901 }
5902 }
5903 return true;
5904}
5905
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005906void bdrv_img_create(const char *filename, const char *fmt,
5907 const char *base_filename, const char *base_fmt,
Fam Zheng92172832017-04-21 20:27:01 +08005908 char *options, uint64_t img_size, int flags, bool quiet,
5909 Error **errp)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005910{
Chunyan Liu83d05212014-06-05 17:20:51 +08005911 QemuOptsList *create_opts = NULL;
5912 QemuOpts *opts = NULL;
5913 const char *backing_fmt, *backing_file;
5914 int64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005915 BlockDriver *drv, *proto_drv;
Max Reitzcc84d902013-09-06 17:14:26 +02005916 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005917 int ret = 0;
5918
5919 /* Find driver and parse its options */
5920 drv = bdrv_find_format(fmt);
5921 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005922 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005923 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005924 }
5925
Max Reitzb65a5e12015-02-05 13:58:12 -05005926 proto_drv = bdrv_find_protocol(filename, true, errp);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005927 if (!proto_drv) {
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005928 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005929 }
5930
Max Reitzc6149722014-12-02 18:32:45 +01005931 if (!drv->create_opts) {
5932 error_setg(errp, "Format driver '%s' does not support image creation",
5933 drv->format_name);
5934 return;
5935 }
5936
Kevin Wolff6dc1c32019-11-26 16:45:49 +01005937 /* Create parameter list */
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005938 create_opts = qemu_opts_append(create_opts, drv->create_opts);
Max Reitzfd171462020-01-22 17:45:29 +01005939 if (proto_drv->create_opts) {
5940 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
5941 } else {
5942 create_opts = qemu_opts_append(create_opts, &fallback_create_opts);
5943 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005944
Chunyan Liu83d05212014-06-05 17:20:51 +08005945 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005946
5947 /* Parse -o options */
5948 if (options) {
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01005949 qemu_opts_do_parse(opts, options, NULL, &local_err);
5950 if (local_err) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005951 goto out;
5952 }
5953 }
5954
Kevin Wolff6dc1c32019-11-26 16:45:49 +01005955 if (!qemu_opt_get(opts, BLOCK_OPT_SIZE)) {
5956 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
5957 } else if (img_size != UINT64_C(-1)) {
5958 error_setg(errp, "The image size must be specified only once");
5959 goto out;
5960 }
5961
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005962 if (base_filename) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01005963 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
Markus Armbruster6be41942015-02-12 17:49:02 +01005964 if (local_err) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005965 error_setg(errp, "Backing file not supported for file format '%s'",
5966 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005967 goto out;
5968 }
5969 }
5970
5971 if (base_fmt) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01005972 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
Markus Armbruster6be41942015-02-12 17:49:02 +01005973 if (local_err) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005974 error_setg(errp, "Backing file format not supported for file "
5975 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005976 goto out;
5977 }
5978 }
5979
Chunyan Liu83d05212014-06-05 17:20:51 +08005980 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5981 if (backing_file) {
5982 if (!strcmp(filename, backing_file)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005983 error_setg(errp, "Error: Trying to create an image with the "
5984 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01005985 goto out;
5986 }
5987 }
5988
Chunyan Liu83d05212014-06-05 17:20:51 +08005989 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005990
John Snow6e6e55f2017-07-17 20:34:22 -04005991 /* The size for the image must always be specified, unless we have a backing
5992 * file and we have not been forbidden from opening it. */
Eric Blakea8b42a12017-09-25 09:55:07 -05005993 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
John Snow6e6e55f2017-07-17 20:34:22 -04005994 if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
5995 BlockDriverState *bs;
Max Reitz645ae7d2019-02-01 20:29:14 +01005996 char *full_backing;
John Snow6e6e55f2017-07-17 20:34:22 -04005997 int back_flags;
5998 QDict *backing_options = NULL;
Paolo Bonzini63090da2012-04-12 14:01:03 +02005999
Max Reitz645ae7d2019-02-01 20:29:14 +01006000 full_backing =
6001 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
6002 &local_err);
John Snow6e6e55f2017-07-17 20:34:22 -04006003 if (local_err) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01006004 goto out;
6005 }
Max Reitz645ae7d2019-02-01 20:29:14 +01006006 assert(full_backing);
John Snow6e6e55f2017-07-17 20:34:22 -04006007
6008 /* backing files always opened read-only */
6009 back_flags = flags;
6010 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
6011
Fam Zhengcc954f02017-12-15 16:04:45 +08006012 backing_options = qdict_new();
John Snow6e6e55f2017-07-17 20:34:22 -04006013 if (backing_fmt) {
John Snow6e6e55f2017-07-17 20:34:22 -04006014 qdict_put_str(backing_options, "driver", backing_fmt);
6015 }
Fam Zhengcc954f02017-12-15 16:04:45 +08006016 qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
John Snow6e6e55f2017-07-17 20:34:22 -04006017
6018 bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
6019 &local_err);
6020 g_free(full_backing);
6021 if (!bs && size != -1) {
6022 /* Couldn't open BS, but we have a size, so it's nonfatal */
6023 warn_reportf_err(local_err,
6024 "Could not verify backing image. "
6025 "This may become an error in future versions.\n");
6026 local_err = NULL;
6027 } else if (!bs) {
6028 /* Couldn't open bs, do not have size */
6029 error_append_hint(&local_err,
6030 "Could not open backing image to determine size.\n");
6031 goto out;
6032 } else {
6033 if (size == -1) {
6034 /* Opened BS, have no size */
6035 size = bdrv_getlength(bs);
6036 if (size < 0) {
6037 error_setg_errno(errp, -size, "Could not get size of '%s'",
6038 backing_file);
6039 bdrv_unref(bs);
6040 goto out;
6041 }
6042 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
6043 }
6044 bdrv_unref(bs);
6045 }
6046 } /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */
6047
6048 if (size == -1) {
6049 error_setg(errp, "Image creation needs a size parameter");
6050 goto out;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01006051 }
6052
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01006053 if (!quiet) {
Kővágó, Zoltánfe646692015-07-07 16:42:10 +02006054 printf("Formatting '%s', fmt=%s ", filename, fmt);
Fam Zheng43c5d8f2014-12-09 15:38:04 +08006055 qemu_opts_print(opts, " ");
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01006056 puts("");
6057 }
Chunyan Liu83d05212014-06-05 17:20:51 +08006058
Chunyan Liuc282e1f2014-06-05 17:21:11 +08006059 ret = bdrv_create(drv, filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08006060
Max Reitzcc84d902013-09-06 17:14:26 +02006061 if (ret == -EFBIG) {
6062 /* This is generally a better message than whatever the driver would
6063 * deliver (especially because of the cluster_size_hint), since that
6064 * is most probably not much different from "image too large". */
6065 const char *cluster_size_hint = "";
Chunyan Liu83d05212014-06-05 17:20:51 +08006066 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
Max Reitzcc84d902013-09-06 17:14:26 +02006067 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01006068 }
Max Reitzcc84d902013-09-06 17:14:26 +02006069 error_setg(errp, "The image size is too large for file format '%s'"
6070 "%s", fmt, cluster_size_hint);
6071 error_free(local_err);
6072 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01006073 }
6074
6075out:
Chunyan Liu83d05212014-06-05 17:20:51 +08006076 qemu_opts_del(opts);
6077 qemu_opts_free(create_opts);
Eduardo Habkost621ff942016-06-13 18:57:56 -03006078 error_propagate(errp, local_err);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01006079}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01006080
6081AioContext *bdrv_get_aio_context(BlockDriverState *bs)
6082{
Stefan Hajnoczi33f2a752018-02-16 16:50:13 +00006083 return bs ? bs->aio_context : qemu_get_aio_context();
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006084}
6085
Fam Zheng052a7572017-04-10 20:09:25 +08006086void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)
6087{
6088 aio_co_enter(bdrv_get_aio_context(bs), co);
6089}
6090
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006091static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
6092{
6093 QLIST_REMOVE(ban, list);
6094 g_free(ban);
6095}
6096
Kevin Wolfa3a683c2019-05-06 19:17:57 +02006097static void bdrv_detach_aio_context(BlockDriverState *bs)
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006098{
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006099 BdrvAioNotifier *baf, *baf_tmp;
Max Reitz33384422014-06-20 21:57:33 +02006100
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006101 assert(!bs->walking_aio_notifiers);
6102 bs->walking_aio_notifiers = true;
6103 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
6104 if (baf->deleted) {
6105 bdrv_do_remove_aio_context_notifier(baf);
6106 } else {
6107 baf->detach_aio_context(baf->opaque);
6108 }
Max Reitz33384422014-06-20 21:57:33 +02006109 }
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006110 /* Never mind iterating again to check for ->deleted. bdrv_close() will
6111 * remove remaining aio notifiers if we aren't called again.
6112 */
6113 bs->walking_aio_notifiers = false;
Max Reitz33384422014-06-20 21:57:33 +02006114
Kevin Wolf1bffe1a2019-04-17 17:15:25 +02006115 if (bs->drv && bs->drv->bdrv_detach_aio_context) {
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006116 bs->drv->bdrv_detach_aio_context(bs);
6117 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006118
Kevin Wolfe64f25f2019-02-08 16:51:17 +01006119 if (bs->quiesce_counter) {
6120 aio_enable_external(bs->aio_context);
6121 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006122 bs->aio_context = NULL;
6123}
6124
Kevin Wolfa3a683c2019-05-06 19:17:57 +02006125static void bdrv_attach_aio_context(BlockDriverState *bs,
6126 AioContext *new_context)
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006127{
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006128 BdrvAioNotifier *ban, *ban_tmp;
Max Reitz33384422014-06-20 21:57:33 +02006129
Kevin Wolfe64f25f2019-02-08 16:51:17 +01006130 if (bs->quiesce_counter) {
6131 aio_disable_external(new_context);
6132 }
6133
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006134 bs->aio_context = new_context;
6135
Kevin Wolf1bffe1a2019-04-17 17:15:25 +02006136 if (bs->drv && bs->drv->bdrv_attach_aio_context) {
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006137 bs->drv->bdrv_attach_aio_context(bs, new_context);
6138 }
Max Reitz33384422014-06-20 21:57:33 +02006139
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006140 assert(!bs->walking_aio_notifiers);
6141 bs->walking_aio_notifiers = true;
6142 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
6143 if (ban->deleted) {
6144 bdrv_do_remove_aio_context_notifier(ban);
6145 } else {
6146 ban->attached_aio_context(new_context, ban->opaque);
6147 }
Max Reitz33384422014-06-20 21:57:33 +02006148 }
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006149 bs->walking_aio_notifiers = false;
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006150}
6151
Kevin Wolf42a65f02019-05-07 18:31:38 +02006152/*
6153 * Changes the AioContext used for fd handlers, timers, and BHs by this
6154 * BlockDriverState and all its children and parents.
6155 *
Max Reitz43eaaae2019-07-22 15:30:54 +02006156 * Must be called from the main AioContext.
6157 *
Kevin Wolf42a65f02019-05-07 18:31:38 +02006158 * The caller must own the AioContext lock for the old AioContext of bs, but it
6159 * must not own the AioContext lock for new_context (unless new_context is the
6160 * same as the current context of bs).
6161 *
6162 * @ignore will accumulate all visited BdrvChild object. The caller is
6163 * responsible for freeing the list afterwards.
6164 */
Kevin Wolf53a7d042019-05-06 19:17:59 +02006165void bdrv_set_aio_context_ignore(BlockDriverState *bs,
6166 AioContext *new_context, GSList **ignore)
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006167{
Max Reitze037c092019-07-19 11:26:14 +02006168 AioContext *old_context = bdrv_get_aio_context(bs);
Kevin Wolf0d837082019-05-06 19:17:58 +02006169 BdrvChild *child;
6170
Max Reitz43eaaae2019-07-22 15:30:54 +02006171 g_assert(qemu_get_current_aio_context() == qemu_get_aio_context());
6172
Max Reitze037c092019-07-19 11:26:14 +02006173 if (old_context == new_context) {
Denis Plotnikov57830a42019-02-15 16:03:25 +03006174 return;
6175 }
6176
Kevin Wolfd70d5952019-02-08 16:53:37 +01006177 bdrv_drained_begin(bs);
Kevin Wolf0d837082019-05-06 19:17:58 +02006178
6179 QLIST_FOREACH(child, &bs->children, next) {
Kevin Wolf53a7d042019-05-06 19:17:59 +02006180 if (g_slist_find(*ignore, child)) {
6181 continue;
6182 }
6183 *ignore = g_slist_prepend(*ignore, child);
6184 bdrv_set_aio_context_ignore(child->bs, new_context, ignore);
6185 }
6186 QLIST_FOREACH(child, &bs->parents, next_parent) {
6187 if (g_slist_find(*ignore, child)) {
6188 continue;
6189 }
Kevin Wolf42a65f02019-05-07 18:31:38 +02006190 assert(child->role->set_aio_ctx);
6191 *ignore = g_slist_prepend(*ignore, child);
6192 child->role->set_aio_ctx(child, new_context, ignore);
Kevin Wolf0d837082019-05-06 19:17:58 +02006193 }
6194
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006195 bdrv_detach_aio_context(bs);
6196
Max Reitze037c092019-07-19 11:26:14 +02006197 /* Acquire the new context, if necessary */
Max Reitz43eaaae2019-07-22 15:30:54 +02006198 if (qemu_get_aio_context() != new_context) {
Max Reitze037c092019-07-19 11:26:14 +02006199 aio_context_acquire(new_context);
6200 }
6201
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02006202 bdrv_attach_aio_context(bs, new_context);
Max Reitze037c092019-07-19 11:26:14 +02006203
6204 /*
6205 * If this function was recursively called from
6206 * bdrv_set_aio_context_ignore(), there may be nodes in the
6207 * subtree that have not yet been moved to the new AioContext.
6208 * Release the old one so bdrv_drained_end() can poll them.
6209 */
Max Reitz43eaaae2019-07-22 15:30:54 +02006210 if (qemu_get_aio_context() != old_context) {
Max Reitze037c092019-07-19 11:26:14 +02006211 aio_context_release(old_context);
6212 }
6213
Kevin Wolfd70d5952019-02-08 16:53:37 +01006214 bdrv_drained_end(bs);
Max Reitze037c092019-07-19 11:26:14 +02006215
Max Reitz43eaaae2019-07-22 15:30:54 +02006216 if (qemu_get_aio_context() != old_context) {
Max Reitze037c092019-07-19 11:26:14 +02006217 aio_context_acquire(old_context);
6218 }
Max Reitz43eaaae2019-07-22 15:30:54 +02006219 if (qemu_get_aio_context() != new_context) {
Max Reitze037c092019-07-19 11:26:14 +02006220 aio_context_release(new_context);
6221 }
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01006222}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02006223
Kevin Wolf5d231842019-05-06 19:17:56 +02006224static bool bdrv_parent_can_set_aio_context(BdrvChild *c, AioContext *ctx,
6225 GSList **ignore, Error **errp)
6226{
6227 if (g_slist_find(*ignore, c)) {
6228 return true;
6229 }
6230 *ignore = g_slist_prepend(*ignore, c);
6231
6232 /* A BdrvChildRole that doesn't handle AioContext changes cannot
6233 * tolerate any AioContext changes */
6234 if (!c->role->can_set_aio_ctx) {
6235 char *user = bdrv_child_user_desc(c);
6236 error_setg(errp, "Changing iothreads is not supported by %s", user);
6237 g_free(user);
6238 return false;
6239 }
6240 if (!c->role->can_set_aio_ctx(c, ctx, ignore, errp)) {
6241 assert(!errp || *errp);
6242 return false;
6243 }
6244 return true;
6245}
6246
6247bool bdrv_child_can_set_aio_context(BdrvChild *c, AioContext *ctx,
6248 GSList **ignore, Error **errp)
6249{
6250 if (g_slist_find(*ignore, c)) {
6251 return true;
6252 }
6253 *ignore = g_slist_prepend(*ignore, c);
6254 return bdrv_can_set_aio_context(c->bs, ctx, ignore, errp);
6255}
6256
6257/* @ignore will accumulate all visited BdrvChild object. The caller is
6258 * responsible for freeing the list afterwards. */
6259bool bdrv_can_set_aio_context(BlockDriverState *bs, AioContext *ctx,
6260 GSList **ignore, Error **errp)
6261{
6262 BdrvChild *c;
6263
6264 if (bdrv_get_aio_context(bs) == ctx) {
6265 return true;
6266 }
6267
6268 QLIST_FOREACH(c, &bs->parents, next_parent) {
6269 if (!bdrv_parent_can_set_aio_context(c, ctx, ignore, errp)) {
6270 return false;
6271 }
6272 }
6273 QLIST_FOREACH(c, &bs->children, next) {
6274 if (!bdrv_child_can_set_aio_context(c, ctx, ignore, errp)) {
6275 return false;
6276 }
6277 }
6278
6279 return true;
6280}
6281
6282int bdrv_child_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,
6283 BdrvChild *ignore_child, Error **errp)
6284{
6285 GSList *ignore;
6286 bool ret;
6287
6288 ignore = ignore_child ? g_slist_prepend(NULL, ignore_child) : NULL;
6289 ret = bdrv_can_set_aio_context(bs, ctx, &ignore, errp);
6290 g_slist_free(ignore);
6291
6292 if (!ret) {
6293 return -EPERM;
6294 }
6295
Kevin Wolf53a7d042019-05-06 19:17:59 +02006296 ignore = ignore_child ? g_slist_prepend(NULL, ignore_child) : NULL;
6297 bdrv_set_aio_context_ignore(bs, ctx, &ignore);
6298 g_slist_free(ignore);
6299
Kevin Wolf5d231842019-05-06 19:17:56 +02006300 return 0;
6301}
6302
6303int bdrv_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,
6304 Error **errp)
6305{
6306 return bdrv_child_try_set_aio_context(bs, ctx, NULL, errp);
6307}
6308
Max Reitz33384422014-06-20 21:57:33 +02006309void bdrv_add_aio_context_notifier(BlockDriverState *bs,
6310 void (*attached_aio_context)(AioContext *new_context, void *opaque),
6311 void (*detach_aio_context)(void *opaque), void *opaque)
6312{
6313 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
6314 *ban = (BdrvAioNotifier){
6315 .attached_aio_context = attached_aio_context,
6316 .detach_aio_context = detach_aio_context,
6317 .opaque = opaque
6318 };
6319
6320 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
6321}
6322
6323void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
6324 void (*attached_aio_context)(AioContext *,
6325 void *),
6326 void (*detach_aio_context)(void *),
6327 void *opaque)
6328{
6329 BdrvAioNotifier *ban, *ban_next;
6330
6331 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
6332 if (ban->attached_aio_context == attached_aio_context &&
6333 ban->detach_aio_context == detach_aio_context &&
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006334 ban->opaque == opaque &&
6335 ban->deleted == false)
Max Reitz33384422014-06-20 21:57:33 +02006336 {
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01006337 if (bs->walking_aio_notifiers) {
6338 ban->deleted = true;
6339 } else {
6340 bdrv_do_remove_aio_context_notifier(ban);
6341 }
Max Reitz33384422014-06-20 21:57:33 +02006342 return;
6343 }
6344 }
6345
6346 abort();
6347}
6348
Max Reitz77485432014-10-27 11:12:50 +01006349int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
Max Reitzd1402b52018-05-09 23:00:18 +02006350 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
6351 Error **errp)
Max Reitz6f176b42013-09-03 10:09:50 +02006352{
Max Reitzd470ad42017-11-10 21:31:09 +01006353 if (!bs->drv) {
Max Reitzd1402b52018-05-09 23:00:18 +02006354 error_setg(errp, "Node is ejected");
Max Reitzd470ad42017-11-10 21:31:09 +01006355 return -ENOMEDIUM;
6356 }
Chunyan Liuc282e1f2014-06-05 17:21:11 +08006357 if (!bs->drv->bdrv_amend_options) {
Max Reitzd1402b52018-05-09 23:00:18 +02006358 error_setg(errp, "Block driver '%s' does not support option amendment",
6359 bs->drv->format_name);
Max Reitz6f176b42013-09-03 10:09:50 +02006360 return -ENOTSUP;
6361 }
Max Reitzd1402b52018-05-09 23:00:18 +02006362 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque, errp);
Max Reitz6f176b42013-09-03 10:09:50 +02006363}
Benoît Canetf6186f42013-10-02 14:33:48 +02006364
Max Reitz5d69b5a2020-02-18 11:34:41 +01006365/*
6366 * This function checks whether the given @to_replace is allowed to be
6367 * replaced by a node that always shows the same data as @bs. This is
6368 * used for example to verify whether the mirror job can replace
6369 * @to_replace by the target mirrored from @bs.
6370 * To be replaceable, @bs and @to_replace may either be guaranteed to
6371 * always show the same data (because they are only connected through
6372 * filters), or some driver may allow replacing one of its children
6373 * because it can guarantee that this child's data is not visible at
6374 * all (for example, for dissenting quorum children that have no other
6375 * parents).
6376 */
6377bool bdrv_recurse_can_replace(BlockDriverState *bs,
6378 BlockDriverState *to_replace)
6379{
6380 if (!bs || !bs->drv) {
6381 return false;
6382 }
6383
6384 if (bs == to_replace) {
6385 return true;
6386 }
6387
6388 /* See what the driver can do */
6389 if (bs->drv->bdrv_recurse_can_replace) {
6390 return bs->drv->bdrv_recurse_can_replace(bs, to_replace);
6391 }
6392
6393 /* For filters without an own implementation, we can recurse on our own */
6394 if (bs->drv->is_filter) {
6395 BdrvChild *child = bs->file ?: bs->backing;
6396 return bdrv_recurse_can_replace(child->bs, to_replace);
6397 }
6398
6399 /* Safe default */
6400 return false;
6401}
6402
Max Reitz810803a2020-02-18 11:34:44 +01006403/*
6404 * Check whether the given @node_name can be replaced by a node that
6405 * has the same data as @parent_bs. If so, return @node_name's BDS;
6406 * NULL otherwise.
6407 *
6408 * @node_name must be a (recursive) *child of @parent_bs (or this
6409 * function will return NULL).
6410 *
6411 * The result (whether the node can be replaced or not) is only valid
6412 * for as long as no graph or permission changes occur.
6413 */
Wen Congyange12f3782015-07-17 10:12:22 +08006414BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
6415 const char *node_name, Error **errp)
Benoît Canet09158f02014-06-27 18:25:25 +02006416{
6417 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01006418 AioContext *aio_context;
6419
Benoît Canet09158f02014-06-27 18:25:25 +02006420 if (!to_replace_bs) {
6421 error_setg(errp, "Node name '%s' not found", node_name);
6422 return NULL;
6423 }
6424
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01006425 aio_context = bdrv_get_aio_context(to_replace_bs);
6426 aio_context_acquire(aio_context);
6427
Benoît Canet09158f02014-06-27 18:25:25 +02006428 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01006429 to_replace_bs = NULL;
6430 goto out;
Benoît Canet09158f02014-06-27 18:25:25 +02006431 }
6432
6433 /* We don't want arbitrary node of the BDS chain to be replaced only the top
6434 * most non filter in order to prevent data corruption.
6435 * Another benefit is that this tests exclude backing files which are
6436 * blocked by the backing blockers.
6437 */
Max Reitz810803a2020-02-18 11:34:44 +01006438 if (!bdrv_recurse_can_replace(parent_bs, to_replace_bs)) {
6439 error_setg(errp, "Cannot replace '%s' by a node mirrored from '%s', "
6440 "because it cannot be guaranteed that doing so would not "
6441 "lead to an abrupt change of visible data",
6442 node_name, parent_bs->node_name);
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01006443 to_replace_bs = NULL;
6444 goto out;
Benoît Canet09158f02014-06-27 18:25:25 +02006445 }
6446
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01006447out:
6448 aio_context_release(aio_context);
Benoît Canet09158f02014-06-27 18:25:25 +02006449 return to_replace_bs;
6450}
Ming Lei448ad912014-07-04 18:04:33 +08006451
Max Reitz97e2f022019-02-01 20:29:27 +01006452/**
6453 * Iterates through the list of runtime option keys that are said to
6454 * be "strong" for a BDS. An option is called "strong" if it changes
6455 * a BDS's data. For example, the null block driver's "size" and
6456 * "read-zeroes" options are strong, but its "latency-ns" option is
6457 * not.
6458 *
6459 * If a key returned by this function ends with a dot, all options
6460 * starting with that prefix are strong.
6461 */
6462static const char *const *strong_options(BlockDriverState *bs,
6463 const char *const *curopt)
6464{
6465 static const char *const global_options[] = {
6466 "driver", "filename", NULL
6467 };
6468
6469 if (!curopt) {
6470 return &global_options[0];
6471 }
6472
6473 curopt++;
6474 if (curopt == &global_options[ARRAY_SIZE(global_options) - 1] && bs->drv) {
6475 curopt = bs->drv->strong_runtime_opts;
6476 }
6477
6478 return (curopt && *curopt) ? curopt : NULL;
6479}
6480
6481/**
6482 * Copies all strong runtime options from bs->options to the given
6483 * QDict. The set of strong option keys is determined by invoking
6484 * strong_options().
6485 *
6486 * Returns true iff any strong option was present in bs->options (and
6487 * thus copied to the target QDict) with the exception of "filename"
6488 * and "driver". The caller is expected to use this value to decide
6489 * whether the existence of strong options prevents the generation of
6490 * a plain filename.
6491 */
6492static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs)
6493{
6494 bool found_any = false;
6495 const char *const *option_name = NULL;
6496
6497 if (!bs->drv) {
6498 return false;
6499 }
6500
6501 while ((option_name = strong_options(bs, option_name))) {
6502 bool option_given = false;
6503
6504 assert(strlen(*option_name) > 0);
6505 if ((*option_name)[strlen(*option_name) - 1] != '.') {
6506 QObject *entry = qdict_get(bs->options, *option_name);
6507 if (!entry) {
6508 continue;
6509 }
6510
6511 qdict_put_obj(d, *option_name, qobject_ref(entry));
6512 option_given = true;
6513 } else {
6514 const QDictEntry *entry;
6515 for (entry = qdict_first(bs->options); entry;
6516 entry = qdict_next(bs->options, entry))
6517 {
6518 if (strstart(qdict_entry_key(entry), *option_name, NULL)) {
6519 qdict_put_obj(d, qdict_entry_key(entry),
6520 qobject_ref(qdict_entry_value(entry)));
6521 option_given = true;
6522 }
6523 }
6524 }
6525
6526 /* While "driver" and "filename" need to be included in a JSON filename,
6527 * their existence does not prohibit generation of a plain filename. */
6528 if (!found_any && option_given &&
6529 strcmp(*option_name, "driver") && strcmp(*option_name, "filename"))
6530 {
6531 found_any = true;
6532 }
6533 }
6534
Max Reitz62a01a272019-02-01 20:29:34 +01006535 if (!qdict_haskey(d, "driver")) {
6536 /* Drivers created with bdrv_new_open_driver() may not have a
6537 * @driver option. Add it here. */
6538 qdict_put_str(d, "driver", bs->drv->format_name);
6539 }
6540
Max Reitz97e2f022019-02-01 20:29:27 +01006541 return found_any;
6542}
6543
Max Reitz90993622019-02-01 20:29:09 +01006544/* Note: This function may return false positives; it may return true
6545 * even if opening the backing file specified by bs's image header
6546 * would result in exactly bs->backing. */
6547static bool bdrv_backing_overridden(BlockDriverState *bs)
6548{
6549 if (bs->backing) {
6550 return strcmp(bs->auto_backing_file,
6551 bs->backing->bs->filename);
6552 } else {
6553 /* No backing BDS, so if the image header reports any backing
6554 * file, it must have been suppressed */
6555 return bs->auto_backing_file[0] != '\0';
6556 }
6557}
6558
Max Reitz91af7012014-07-18 20:24:56 +02006559/* Updates the following BDS fields:
6560 * - exact_filename: A filename which may be used for opening a block device
6561 * which (mostly) equals the given BDS (even without any
6562 * other options; so reading and writing must return the same
6563 * results, but caching etc. may be different)
6564 * - full_open_options: Options which, when given when opening a block device
6565 * (without a filename), result in a BDS (mostly)
6566 * equalling the given one
6567 * - filename: If exact_filename is set, it is copied here. Otherwise,
6568 * full_open_options is converted to a JSON object, prefixed with
6569 * "json:" (for use through the JSON pseudo protocol) and put here.
6570 */
6571void bdrv_refresh_filename(BlockDriverState *bs)
6572{
6573 BlockDriver *drv = bs->drv;
Max Reitze24518e2019-02-01 20:29:06 +01006574 BdrvChild *child;
Max Reitz91af7012014-07-18 20:24:56 +02006575 QDict *opts;
Max Reitz90993622019-02-01 20:29:09 +01006576 bool backing_overridden;
Max Reitz998b3a12019-02-01 20:29:28 +01006577 bool generate_json_filename; /* Whether our default implementation should
6578 fill exact_filename (false) or not (true) */
Max Reitz91af7012014-07-18 20:24:56 +02006579
6580 if (!drv) {
6581 return;
6582 }
6583
Max Reitze24518e2019-02-01 20:29:06 +01006584 /* This BDS's file name may depend on any of its children's file names, so
6585 * refresh those first */
6586 QLIST_FOREACH(child, &bs->children, next) {
6587 bdrv_refresh_filename(child->bs);
Max Reitz91af7012014-07-18 20:24:56 +02006588 }
6589
Max Reitzbb808d52019-02-01 20:29:07 +01006590 if (bs->implicit) {
6591 /* For implicit nodes, just copy everything from the single child */
6592 child = QLIST_FIRST(&bs->children);
6593 assert(QLIST_NEXT(child, next) == NULL);
6594
6595 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
6596 child->bs->exact_filename);
6597 pstrcpy(bs->filename, sizeof(bs->filename), child->bs->filename);
6598
Pan Nengyuancb895612020-01-16 16:56:00 +08006599 qobject_unref(bs->full_open_options);
Max Reitzbb808d52019-02-01 20:29:07 +01006600 bs->full_open_options = qobject_ref(child->bs->full_open_options);
6601
6602 return;
6603 }
6604
Max Reitz90993622019-02-01 20:29:09 +01006605 backing_overridden = bdrv_backing_overridden(bs);
6606
6607 if (bs->open_flags & BDRV_O_NO_IO) {
6608 /* Without I/O, the backing file does not change anything.
6609 * Therefore, in such a case (primarily qemu-img), we can
6610 * pretend the backing file has not been overridden even if
6611 * it technically has been. */
6612 backing_overridden = false;
6613 }
6614
Max Reitz97e2f022019-02-01 20:29:27 +01006615 /* Gather the options QDict */
6616 opts = qdict_new();
Max Reitz998b3a12019-02-01 20:29:28 +01006617 generate_json_filename = append_strong_runtime_options(opts, bs);
6618 generate_json_filename |= backing_overridden;
Max Reitz97e2f022019-02-01 20:29:27 +01006619
6620 if (drv->bdrv_gather_child_options) {
6621 /* Some block drivers may not want to present all of their children's
6622 * options, or name them differently from BdrvChild.name */
6623 drv->bdrv_gather_child_options(bs, opts, backing_overridden);
6624 } else {
6625 QLIST_FOREACH(child, &bs->children, next) {
6626 if (child->role == &child_backing && !backing_overridden) {
6627 /* We can skip the backing BDS if it has not been overridden */
6628 continue;
6629 }
6630
6631 qdict_put(opts, child->name,
6632 qobject_ref(child->bs->full_open_options));
6633 }
6634
6635 if (backing_overridden && !bs->backing) {
6636 /* Force no backing file */
6637 qdict_put_null(opts, "backing");
6638 }
6639 }
6640
6641 qobject_unref(bs->full_open_options);
6642 bs->full_open_options = opts;
6643
Max Reitz998b3a12019-02-01 20:29:28 +01006644 if (drv->bdrv_refresh_filename) {
6645 /* Obsolete information is of no use here, so drop the old file name
6646 * information before refreshing it */
6647 bs->exact_filename[0] = '\0';
6648
6649 drv->bdrv_refresh_filename(bs);
6650 } else if (bs->file) {
6651 /* Try to reconstruct valid information from the underlying file */
6652
6653 bs->exact_filename[0] = '\0';
6654
Max Reitzfb695c72019-02-01 20:29:29 +01006655 /*
6656 * We can use the underlying file's filename if:
6657 * - it has a filename,
6658 * - the file is a protocol BDS, and
6659 * - opening that file (as this BDS's format) will automatically create
6660 * the BDS tree we have right now, that is:
6661 * - the user did not significantly change this BDS's behavior with
6662 * some explicit (strong) options
6663 * - no non-file child of this BDS has been overridden by the user
6664 * Both of these conditions are represented by generate_json_filename.
6665 */
6666 if (bs->file->bs->exact_filename[0] &&
6667 bs->file->bs->drv->bdrv_file_open &&
6668 !generate_json_filename)
6669 {
Max Reitz998b3a12019-02-01 20:29:28 +01006670 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
6671 }
6672 }
6673
Max Reitz91af7012014-07-18 20:24:56 +02006674 if (bs->exact_filename[0]) {
6675 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
Max Reitz97e2f022019-02-01 20:29:27 +01006676 } else {
Max Reitz91af7012014-07-18 20:24:56 +02006677 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
6678 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
6679 qstring_get_str(json));
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02006680 qobject_unref(json);
Max Reitz91af7012014-07-18 20:24:56 +02006681 }
6682}
Wen Congyange06018a2016-05-10 15:36:37 +08006683
Max Reitz1e89d0f2019-02-01 20:29:18 +01006684char *bdrv_dirname(BlockDriverState *bs, Error **errp)
6685{
6686 BlockDriver *drv = bs->drv;
6687
6688 if (!drv) {
6689 error_setg(errp, "Node '%s' is ejected", bs->node_name);
6690 return NULL;
6691 }
6692
6693 if (drv->bdrv_dirname) {
6694 return drv->bdrv_dirname(bs, errp);
6695 }
6696
6697 if (bs->file) {
6698 return bdrv_dirname(bs->file->bs, errp);
6699 }
6700
6701 bdrv_refresh_filename(bs);
6702 if (bs->exact_filename[0] != '\0') {
6703 return path_combine(bs->exact_filename, "");
6704 }
6705
6706 error_setg(errp, "Cannot generate a base directory for %s nodes",
6707 drv->format_name);
6708 return NULL;
6709}
6710
Wen Congyange06018a2016-05-10 15:36:37 +08006711/*
6712 * Hot add/remove a BDS's child. So the user can take a child offline when
6713 * it is broken and take a new child online
6714 */
6715void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
6716 Error **errp)
6717{
6718
6719 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
6720 error_setg(errp, "The node %s does not support adding a child",
6721 bdrv_get_device_or_node_name(parent_bs));
6722 return;
6723 }
6724
6725 if (!QLIST_EMPTY(&child_bs->parents)) {
6726 error_setg(errp, "The node %s already has a parent",
6727 child_bs->node_name);
6728 return;
6729 }
6730
6731 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
6732}
6733
6734void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
6735{
6736 BdrvChild *tmp;
6737
6738 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
6739 error_setg(errp, "The node %s does not support removing a child",
6740 bdrv_get_device_or_node_name(parent_bs));
6741 return;
6742 }
6743
6744 QLIST_FOREACH(tmp, &parent_bs->children, next) {
6745 if (tmp == child) {
6746 break;
6747 }
6748 }
6749
6750 if (!tmp) {
6751 error_setg(errp, "The node %s does not have a child named %s",
6752 bdrv_get_device_or_node_name(parent_bs),
6753 bdrv_get_device_or_node_name(child->bs));
6754 return;
6755 }
6756
6757 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
6758}