blob: 7d90007cae860689610d4e954ff25d86a9010fb8 [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
Vladimir Sementsov-Ogievskiyc20555e2021-04-28 18:18:04 +03005 * Copyright (c) 2020 Virtuozzo International GmbH.
ths5fafdf22007-09-16 21:08:06 +00006 *
bellardfc01f7e2003-06-30 10:03:06 +00007 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
Markus Armbrustere688df62018-02-01 12:18:31 +010025
Peter Maydelld38ea872016-01-29 17:50:05 +000026#include "qemu/osdep.h"
Daniel P. Berrange0ab8ed12017-01-25 16:14:15 +000027#include "block/trace.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010028#include "block/block_int.h"
29#include "block/blockjob.h"
Markus Armbrustere2c1c342022-12-21 14:35:49 +010030#include "block/dirty-bitmap.h"
Max Reitz0c9b70d2020-10-27 20:05:42 +010031#include "block/fuse.h"
Kevin Wolfcd7fca92016-07-06 11:22:39 +020032#include "block/nbd.h"
Max Reitz609f45e2018-06-14 21:14:28 +020033#include "block/qdict.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010034#include "qemu/error-report.h"
Marc-André Lureau5e5733e2019-08-29 22:34:43 +040035#include "block/module_block.h"
Markus Armbrusterdb725812019-08-12 07:23:50 +020036#include "qemu/main-loop.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010037#include "qemu/module.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010038#include "qapi/error.h"
Markus Armbruster452fcdb2018-02-01 12:18:39 +010039#include "qapi/qmp/qdict.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010040#include "qapi/qmp/qjson.h"
Max Reitze59a0cf2018-02-24 16:40:32 +010041#include "qapi/qmp/qnull.h"
Markus Armbrusterfc81fa12018-02-01 12:18:40 +010042#include "qapi/qmp/qstring.h"
Kevin Wolfe1d74bc2018-01-10 15:52:33 +010043#include "qapi/qobject-output-visitor.h"
44#include "qapi/qapi-visit-block-core.h"
Markus Armbrusterbfb197e2014-10-07 13:59:11 +020045#include "sysemu/block-backend.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010046#include "qemu/notify.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010047#include "qemu/option.h"
Daniel P. Berrange10817bf2015-09-01 14:48:02 +010048#include "qemu/coroutine.h"
Benoît Canetc13163f2014-01-23 21:31:34 +010049#include "block/qapi.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010050#include "qemu/timer.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020051#include "qemu/cutils.h"
52#include "qemu/id.h"
Hanna Reitz0bc329f2021-08-12 10:41:44 +020053#include "qemu/range.h"
54#include "qemu/rcu.h"
Vladimir Sementsov-Ogievskiy21c22832020-09-24 21:54:10 +030055#include "block/coroutines.h"
bellardfc01f7e2003-06-30 10:03:06 +000056
Juan Quintela71e72a12009-07-27 16:12:56 +020057#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000058#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000059#include <sys/queue.h>
Joelle van Dynefeccdce2021-03-15 11:03:39 -070060#if defined(HAVE_SYS_DISK_H)
bellard7674e7b2005-04-26 21:59:26 +000061#include <sys/disk.h>
62#endif
blueswir1c5e97232009-03-07 20:06:23 +000063#endif
bellard7674e7b2005-04-26 21:59:26 +000064
aliguori49dc7682009-03-08 16:26:59 +000065#ifdef _WIN32
66#include <windows.h>
67#endif
68
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010069#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
70
Emanuele Giuseppe Esposito3b491a92022-03-03 10:15:48 -050071/* Protected by BQL */
Benoît Canetdc364f42014-01-23 21:31:32 +010072static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
73 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
74
Emanuele Giuseppe Esposito3b491a92022-03-03 10:15:48 -050075/* Protected by BQL */
Max Reitz2c1d04e2016-01-29 16:36:11 +010076static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
77 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
78
Emanuele Giuseppe Esposito3b491a92022-03-03 10:15:48 -050079/* Protected by BQL */
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010080static QLIST_HEAD(, BlockDriver) bdrv_drivers =
81 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +000082
Max Reitz5b363932016-05-17 16:41:31 +020083static BlockDriverState *bdrv_open_inherit(const char *filename,
84 const char *reference,
85 QDict *options, int flags,
86 BlockDriverState *parent,
Max Reitzbd86fb92020-05-13 13:05:13 +020087 const BdrvChildClass *child_class,
Max Reitz272c02e2020-05-13 13:05:17 +020088 BdrvChildRole child_role,
Kevin Wolf7ead9462024-04-25 14:56:02 +020089 bool parse_filename,
Max Reitz5b363932016-05-17 16:41:31 +020090 Error **errp);
Kevin Wolff3930ed2015-04-08 13:43:47 +020091
Kevin Wolfbfb8aa62021-10-18 15:47:14 +020092static bool bdrv_recurse_has_child(BlockDriverState *bs,
93 BlockDriverState *child);
94
Kevin Wolfad29eb32023-09-11 11:46:07 +020095static void GRAPH_WRLOCK
96bdrv_replace_child_noperm(BdrvChild *child, BlockDriverState *new_bs);
97
Kevin Wolf2f64e1f2023-09-11 11:46:08 +020098static void GRAPH_WRLOCK
99bdrv_remove_child(BdrvChild *child, Transaction *tran);
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +0300100
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +0300101static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
102 BlockReopenQueue *queue,
Alberto Garciaecd30d22021-06-10 15:05:36 +0300103 Transaction *change_child_tran, Error **errp);
Vladimir Sementsov-Ogievskiy53e96d12021-04-28 18:17:35 +0300104static void bdrv_reopen_commit(BDRVReopenState *reopen_state);
105static void bdrv_reopen_abort(BDRVReopenState *reopen_state);
106
Emanuele Giuseppe Espositofa8fc1d2021-12-15 07:11:38 -0500107static bool bdrv_backing_overridden(BlockDriverState *bs);
108
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -0400109static bool bdrv_change_aio_context(BlockDriverState *bs, AioContext *ctx,
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -0400110 GHashTable *visited, Transaction *tran,
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -0400111 Error **errp);
112
Markus Armbrustereb852012009-10-27 18:41:44 +0100113/* If non-zero, use only whitelisted block drivers */
114static int use_bdrv_whitelist;
115
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000116#ifdef _WIN32
117static int is_windows_drive_prefix(const char *filename)
118{
119 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
120 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
121 filename[1] == ':');
122}
123
124int is_windows_drive(const char *filename)
125{
126 if (is_windows_drive_prefix(filename) &&
127 filename[2] == '\0')
128 return 1;
129 if (strstart(filename, "\\\\.\\", NULL) ||
130 strstart(filename, "//./", NULL))
131 return 1;
132 return 0;
133}
134#endif
135
Kevin Wolf339064d2013-11-28 10:23:32 +0100136size_t bdrv_opt_mem_align(BlockDriverState *bs)
137{
138 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300139 /* page size or 4k (hdd sector size) should be on the safe side */
Marc-André Lureau8e3b0cb2022-03-23 19:57:22 +0400140 return MAX(4096, qemu_real_host_page_size());
Kevin Wolf339064d2013-11-28 10:23:32 +0100141 }
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -0500142 IO_CODE();
Kevin Wolf339064d2013-11-28 10:23:32 +0100143
144 return bs->bl.opt_mem_alignment;
145}
146
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300147size_t bdrv_min_mem_align(BlockDriverState *bs)
148{
149 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300150 /* page size or 4k (hdd sector size) should be on the safe side */
Marc-André Lureau8e3b0cb2022-03-23 19:57:22 +0400151 return MAX(4096, qemu_real_host_page_size());
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300152 }
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -0500153 IO_CODE();
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300154
155 return bs->bl.min_mem_alignment;
156}
157
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000158/* check if the path starts with "<protocol>:" */
Max Reitz5c984152014-12-03 14:57:22 +0100159int path_has_protocol(const char *path)
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000160{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200161 const char *p;
162
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000163#ifdef _WIN32
164 if (is_windows_drive(path) ||
165 is_windows_drive_prefix(path)) {
166 return 0;
167 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200168 p = path + strcspn(path, ":/\\");
169#else
170 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000171#endif
172
Paolo Bonzini947995c2012-05-08 16:51:48 +0200173 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000174}
175
bellard83f64092006-08-01 16:21:11 +0000176int path_is_absolute(const char *path)
177{
bellard21664422007-01-07 18:22:37 +0000178#ifdef _WIN32
179 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200180 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000181 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200182 }
183 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000184#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200185 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000186#endif
bellard83f64092006-08-01 16:21:11 +0000187}
188
Max Reitz009b03a2019-02-01 20:29:13 +0100189/* if filename is absolute, just return its duplicate. Otherwise, build a
bellard83f64092006-08-01 16:21:11 +0000190 path to it by considering it is relative to base_path. URL are
191 supported. */
Max Reitz009b03a2019-02-01 20:29:13 +0100192char *path_combine(const char *base_path, const char *filename)
bellard83f64092006-08-01 16:21:11 +0000193{
Max Reitz009b03a2019-02-01 20:29:13 +0100194 const char *protocol_stripped = NULL;
bellard83f64092006-08-01 16:21:11 +0000195 const char *p, *p1;
Max Reitz009b03a2019-02-01 20:29:13 +0100196 char *result;
bellard83f64092006-08-01 16:21:11 +0000197 int len;
198
bellard83f64092006-08-01 16:21:11 +0000199 if (path_is_absolute(filename)) {
Max Reitz009b03a2019-02-01 20:29:13 +0100200 return g_strdup(filename);
bellard83f64092006-08-01 16:21:11 +0000201 }
Max Reitz009b03a2019-02-01 20:29:13 +0100202
203 if (path_has_protocol(base_path)) {
204 protocol_stripped = strchr(base_path, ':');
205 if (protocol_stripped) {
206 protocol_stripped++;
207 }
208 }
209 p = protocol_stripped ?: base_path;
210
211 p1 = strrchr(base_path, '/');
212#ifdef _WIN32
213 {
214 const char *p2;
215 p2 = strrchr(base_path, '\\');
216 if (!p1 || p2 > p1) {
217 p1 = p2;
218 }
219 }
220#endif
221 if (p1) {
222 p1++;
223 } else {
224 p1 = base_path;
225 }
226 if (p1 > p) {
227 p = p1;
228 }
229 len = p - base_path;
230
231 result = g_malloc(len + strlen(filename) + 1);
232 memcpy(result, base_path, len);
233 strcpy(result + len, filename);
234
235 return result;
236}
237
Max Reitz03c320d2017-05-22 21:52:16 +0200238/*
239 * Helper function for bdrv_parse_filename() implementations to remove optional
240 * protocol prefixes (especially "file:") from a filename and for putting the
241 * stripped filename into the options QDict if there is such a prefix.
242 */
243void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix,
244 QDict *options)
245{
246 if (strstart(filename, prefix, &filename)) {
247 /* Stripping the explicit protocol prefix may result in a protocol
248 * prefix being (wrongly) detected (if the filename contains a colon) */
249 if (path_has_protocol(filename)) {
Markus Armbruster18cf67c2020-12-11 18:11:51 +0100250 GString *fat_filename;
Max Reitz03c320d2017-05-22 21:52:16 +0200251
252 /* This means there is some colon before the first slash; therefore,
253 * this cannot be an absolute path */
254 assert(!path_is_absolute(filename));
255
256 /* And we can thus fix the protocol detection issue by prefixing it
257 * by "./" */
Markus Armbruster18cf67c2020-12-11 18:11:51 +0100258 fat_filename = g_string_new("./");
259 g_string_append(fat_filename, filename);
Max Reitz03c320d2017-05-22 21:52:16 +0200260
Markus Armbruster18cf67c2020-12-11 18:11:51 +0100261 assert(!path_has_protocol(fat_filename->str));
Max Reitz03c320d2017-05-22 21:52:16 +0200262
Markus Armbruster18cf67c2020-12-11 18:11:51 +0100263 qdict_put(options, "filename",
264 qstring_from_gstring(fat_filename));
Max Reitz03c320d2017-05-22 21:52:16 +0200265 } else {
266 /* If no protocol prefix was detected, we can use the shortened
267 * filename as-is */
268 qdict_put_str(options, "filename", filename);
269 }
270 }
271}
272
273
Kevin Wolf9c5e6592017-05-04 18:52:40 +0200274/* Returns whether the image file is opened as read-only. Note that this can
275 * return false and writing to the image file is still not possible because the
276 * image is inactivated. */
Jeff Cody93ed5242017-04-07 16:55:28 -0400277bool bdrv_is_read_only(BlockDriverState *bs)
278{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -0500279 IO_CODE();
Vladimir Sementsov-Ogievskiy975da072021-05-27 18:40:55 +0300280 return !(bs->open_flags & BDRV_O_RDWR);
Jeff Cody93ed5242017-04-07 16:55:28 -0400281}
282
Kevin Wolf4026f1c2023-09-29 16:51:47 +0200283static int GRAPH_RDLOCK
284bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
285 bool ignore_allow_rdw, Error **errp)
Jeff Codyfe5241b2017-04-07 16:55:25 -0400286{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -0500287 IO_CODE();
288
Jeff Codye2b82472017-04-07 16:55:26 -0400289 /* Do not set read_only if copy_on_read is enabled */
290 if (bs->copy_on_read && read_only) {
291 error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
292 bdrv_get_device_or_node_name(bs));
293 return -EINVAL;
294 }
295
Jeff Codyd6fcdf02017-04-07 16:55:27 -0400296 /* Do not clear read_only if it is prohibited */
Kevin Wolf54a32bf2017-08-03 17:02:58 +0200297 if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&
298 !ignore_allow_rdw)
299 {
Jeff Codyd6fcdf02017-04-07 16:55:27 -0400300 error_setg(errp, "Node '%s' is read only",
301 bdrv_get_device_or_node_name(bs));
302 return -EPERM;
303 }
304
Jeff Cody45803a02017-04-07 16:55:29 -0400305 return 0;
306}
307
Kevin Wolfeaa24102018-10-12 11:27:41 +0200308/*
309 * Called by a driver that can only provide a read-only image.
310 *
311 * Returns 0 if the node is already read-only or it could switch the node to
312 * read-only because BDRV_O_AUTO_RDONLY is set.
313 *
314 * Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set
315 * or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg
316 * is not NULL, it is used as the error message for the Error object.
317 */
318int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
319 Error **errp)
Jeff Cody45803a02017-04-07 16:55:29 -0400320{
321 int ret = 0;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -0500322 IO_CODE();
Jeff Cody45803a02017-04-07 16:55:29 -0400323
Kevin Wolfeaa24102018-10-12 11:27:41 +0200324 if (!(bs->open_flags & BDRV_O_RDWR)) {
325 return 0;
326 }
327 if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) {
328 goto fail;
329 }
330
331 ret = bdrv_can_set_read_only(bs, true, false, NULL);
Jeff Cody45803a02017-04-07 16:55:29 -0400332 if (ret < 0) {
Kevin Wolfeaa24102018-10-12 11:27:41 +0200333 goto fail;
Jeff Cody45803a02017-04-07 16:55:29 -0400334 }
335
Kevin Wolfeaa24102018-10-12 11:27:41 +0200336 bs->open_flags &= ~BDRV_O_RDWR;
Kevin Wolfeeae6a52018-10-09 16:57:12 +0200337
Jeff Codye2b82472017-04-07 16:55:26 -0400338 return 0;
Kevin Wolfeaa24102018-10-12 11:27:41 +0200339
340fail:
341 error_setg(errp, "%s", errmsg ?: "Image is read-only");
342 return -EACCES;
Jeff Codyfe5241b2017-04-07 16:55:25 -0400343}
344
Max Reitz645ae7d2019-02-01 20:29:14 +0100345/*
346 * If @backing is empty, this function returns NULL without setting
347 * @errp. In all other cases, NULL will only be returned with @errp
348 * set.
349 *
350 * Therefore, a return value of NULL without @errp set means that
351 * there is no backing file; if @errp is set, there is one but its
352 * absolute filename cannot be generated.
353 */
354char *bdrv_get_full_backing_filename_from_filename(const char *backed,
355 const char *backing,
356 Error **errp)
Max Reitz0a828552014-11-26 17:20:25 +0100357{
Max Reitz645ae7d2019-02-01 20:29:14 +0100358 if (backing[0] == '\0') {
359 return NULL;
360 } else if (path_has_protocol(backing) || path_is_absolute(backing)) {
361 return g_strdup(backing);
Max Reitz9f074292014-11-26 17:20:26 +0100362 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
363 error_setg(errp, "Cannot use relative backing file names for '%s'",
364 backed);
Max Reitz645ae7d2019-02-01 20:29:14 +0100365 return NULL;
Max Reitz0a828552014-11-26 17:20:25 +0100366 } else {
Max Reitz645ae7d2019-02-01 20:29:14 +0100367 return path_combine(backed, backing);
Max Reitz0a828552014-11-26 17:20:25 +0100368 }
369}
370
Max Reitz9f4793d2019-02-01 20:29:16 +0100371/*
372 * If @filename is empty or NULL, this function returns NULL without
373 * setting @errp. In all other cases, NULL will only be returned with
374 * @errp set.
375 */
Kevin Wolfb7cfc7d2023-09-29 16:51:45 +0200376static char * GRAPH_RDLOCK
377bdrv_make_absolute_filename(BlockDriverState *relative_to,
378 const char *filename, Error **errp)
Max Reitz9f4793d2019-02-01 20:29:16 +0100379{
Max Reitz8df68612019-02-01 20:29:23 +0100380 char *dir, *full_name;
Max Reitz9f4793d2019-02-01 20:29:16 +0100381
Max Reitz8df68612019-02-01 20:29:23 +0100382 if (!filename || filename[0] == '\0') {
383 return NULL;
384 } else if (path_has_protocol(filename) || path_is_absolute(filename)) {
385 return g_strdup(filename);
386 }
Max Reitz9f4793d2019-02-01 20:29:16 +0100387
Max Reitz8df68612019-02-01 20:29:23 +0100388 dir = bdrv_dirname(relative_to, errp);
389 if (!dir) {
390 return NULL;
391 }
Max Reitz9f4793d2019-02-01 20:29:16 +0100392
Max Reitz8df68612019-02-01 20:29:23 +0100393 full_name = g_strconcat(dir, filename, NULL);
394 g_free(dir);
395 return full_name;
Max Reitz9f4793d2019-02-01 20:29:16 +0100396}
397
Max Reitz6b6833c2019-02-01 20:29:15 +0100398char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp)
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200399{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500400 GLOBAL_STATE_CODE();
Max Reitz9f4793d2019-02-01 20:29:16 +0100401 return bdrv_make_absolute_filename(bs, bs->backing_file, errp);
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200402}
403
Stefan Hajnoczi0eb72172015-04-28 14:27:51 +0100404void bdrv_register(BlockDriver *bdrv)
405{
Philippe Mathieu-Daudéa15f08d2020-03-18 23:22:35 +0100406 assert(bdrv->format_name);
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500407 GLOBAL_STATE_CODE();
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100408 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000409}
bellardb3380822004-03-14 21:38:54 +0000410
Markus Armbrustere4e99862014-10-07 13:59:03 +0200411BlockDriverState *bdrv_new(void)
412{
413 BlockDriverState *bs;
414 int i;
415
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500416 GLOBAL_STATE_CODE();
417
Markus Armbruster5839e532014-08-19 10:31:08 +0200418 bs = g_new0(BlockDriverState, 1);
Fam Zhenge4654d22013-11-13 18:29:43 +0800419 QLIST_INIT(&bs->dirty_bitmaps);
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800420 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
421 QLIST_INIT(&bs->op_blockers[i]);
422 }
Stefan Hajnoczifa9185f2023-08-08 11:58:52 -0400423 qemu_mutex_init(&bs->reqs_lock);
Paolo Bonzini21198822017-06-05 14:39:03 +0200424 qemu_mutex_init(&bs->dirty_bitmap_mutex);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800425 bs->refcnt = 1;
Stefan Hajnoczidcd04222014-05-08 16:34:37 +0200426 bs->aio_context = qemu_get_aio_context();
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200427
Evgeny Yakovlev3ff2f672016-07-18 22:39:52 +0300428 qemu_co_queue_init(&bs->flush_queue);
429
Hanna Reitz0bc329f2021-08-12 10:41:44 +0200430 qemu_co_mutex_init(&bs->bsc_modify_lock);
431 bs->block_status_cache = g_new0(BdrvBlockStatusCache, 1);
432
Kevin Wolf0f122642018-03-28 18:29:18 +0200433 for (i = 0; i < bdrv_drain_all_count; i++) {
434 bdrv_drained_begin(bs);
435 }
436
Max Reitz2c1d04e2016-01-29 16:36:11 +0100437 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
438
bellardb3380822004-03-14 21:38:54 +0000439 return bs;
440}
441
Marc Mari88d88792016-08-12 09:27:03 -0400442static BlockDriver *bdrv_do_find_format(const char *format_name)
bellardea2384d2004-08-01 21:59:26 +0000443{
444 BlockDriver *drv1;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -0500445 GLOBAL_STATE_CODE();
Marc Mari88d88792016-08-12 09:27:03 -0400446
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100447 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
448 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000449 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100450 }
bellardea2384d2004-08-01 21:59:26 +0000451 }
Marc Mari88d88792016-08-12 09:27:03 -0400452
bellardea2384d2004-08-01 21:59:26 +0000453 return NULL;
454}
455
Marc Mari88d88792016-08-12 09:27:03 -0400456BlockDriver *bdrv_find_format(const char *format_name)
457{
458 BlockDriver *drv1;
459 int i;
460
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500461 GLOBAL_STATE_CODE();
462
Marc Mari88d88792016-08-12 09:27:03 -0400463 drv1 = bdrv_do_find_format(format_name);
464 if (drv1) {
465 return drv1;
466 }
467
468 /* The driver isn't registered, maybe we need to load a module */
469 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
470 if (!strcmp(block_driver_modules[i].format_name, format_name)) {
Claudio Fontanac551fb02022-09-29 11:30:33 +0200471 Error *local_err = NULL;
472 int rv = block_module_load(block_driver_modules[i].library_name,
473 &local_err);
474 if (rv > 0) {
475 return bdrv_do_find_format(format_name);
476 } else if (rv < 0) {
477 error_report_err(local_err);
478 }
Marc Mari88d88792016-08-12 09:27:03 -0400479 break;
480 }
481 }
Claudio Fontanac551fb02022-09-29 11:30:33 +0200482 return NULL;
Marc Mari88d88792016-08-12 09:27:03 -0400483}
484
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300485static int bdrv_format_is_whitelisted(const char *format_name, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100486{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800487 static const char *whitelist_rw[] = {
488 CONFIG_BDRV_RW_WHITELIST
Paolo Bonzini859aef02020-08-04 18:14:26 +0200489 NULL
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800490 };
491 static const char *whitelist_ro[] = {
492 CONFIG_BDRV_RO_WHITELIST
Paolo Bonzini859aef02020-08-04 18:14:26 +0200493 NULL
Markus Armbrustereb852012009-10-27 18:41:44 +0100494 };
495 const char **p;
496
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800497 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100498 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800499 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100500
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800501 for (p = whitelist_rw; *p; p++) {
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300502 if (!strcmp(format_name, *p)) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100503 return 1;
504 }
505 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800506 if (read_only) {
507 for (p = whitelist_ro; *p; p++) {
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300508 if (!strcmp(format_name, *p)) {
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800509 return 1;
510 }
511 }
512 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100513 return 0;
514}
515
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300516int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
517{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500518 GLOBAL_STATE_CODE();
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +0300519 return bdrv_format_is_whitelisted(drv->format_name, read_only);
520}
521
Daniel P. Berrangee6ff69b2016-03-21 14:11:48 +0000522bool bdrv_uses_whitelist(void)
523{
524 return use_bdrv_whitelist;
525}
526
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800527typedef struct CreateCo {
528 BlockDriver *drv;
529 char *filename;
Chunyan Liu83d05212014-06-05 17:20:51 +0800530 QemuOpts *opts;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800531 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200532 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800533} CreateCo;
534
Emanuele Giuseppe Esposito741443e2022-11-28 09:23:36 -0500535int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,
536 QemuOpts *opts, Error **errp)
Emanuele Giuseppe Esposito84bdf212022-11-28 09:23:30 -0500537{
Zhao Liu46ff64a2024-03-12 14:03:37 +0800538 ERRP_GUARD();
Emanuele Giuseppe Esposito84bdf212022-11-28 09:23:30 -0500539 int ret;
540 GLOBAL_STATE_CODE();
Emanuele Giuseppe Esposito84bdf212022-11-28 09:23:30 -0500541
542 if (!drv->bdrv_co_create_opts) {
543 error_setg(errp, "Driver '%s' does not support image creation",
544 drv->format_name);
545 return -ENOTSUP;
546 }
547
548 ret = drv->bdrv_co_create_opts(drv, filename, opts, errp);
549 if (ret < 0 && !*errp) {
550 error_setg_errno(errp, -ret, "Could not create image");
551 }
552
553 return ret;
554}
555
Max Reitzfd171462020-01-22 17:45:29 +0100556/**
557 * Helper function for bdrv_create_file_fallback(): Resize @blk to at
558 * least the given @minimum_size.
559 *
560 * On success, return @blk's actual length.
561 * Otherwise, return -errno.
562 */
Paolo Bonzini84569a72023-06-01 13:51:38 +0200563static int64_t coroutine_fn GRAPH_UNLOCKED
564create_file_fallback_truncate(BlockBackend *blk, int64_t minimum_size,
565 Error **errp)
Max Reitzfd171462020-01-22 17:45:29 +0100566{
567 Error *local_err = NULL;
568 int64_t size;
569 int ret;
570
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -0500571 GLOBAL_STATE_CODE();
572
Paolo Bonzini84569a72023-06-01 13:51:38 +0200573 ret = blk_co_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
574 &local_err);
Max Reitzfd171462020-01-22 17:45:29 +0100575 if (ret < 0 && ret != -ENOTSUP) {
576 error_propagate(errp, local_err);
577 return ret;
578 }
579
Paolo Bonzini84569a72023-06-01 13:51:38 +0200580 size = blk_co_getlength(blk);
Max Reitzfd171462020-01-22 17:45:29 +0100581 if (size < 0) {
582 error_free(local_err);
583 error_setg_errno(errp, -size,
584 "Failed to inquire the new image file's length");
585 return size;
586 }
587
588 if (size < minimum_size) {
589 /* Need to grow the image, but we failed to do that */
590 error_propagate(errp, local_err);
591 return -ENOTSUP;
592 }
593
594 error_free(local_err);
595 local_err = NULL;
596
597 return size;
598}
599
600/**
601 * Helper function for bdrv_create_file_fallback(): Zero the first
602 * sector to remove any potentially pre-existing image header.
603 */
Paolo Bonzini881a4c52022-09-22 10:49:00 +0200604static int coroutine_fn
605create_file_fallback_zero_first_sector(BlockBackend *blk,
606 int64_t current_size,
607 Error **errp)
Max Reitzfd171462020-01-22 17:45:29 +0100608{
609 int64_t bytes_to_clear;
610 int ret;
611
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -0500612 GLOBAL_STATE_CODE();
613
Max Reitzfd171462020-01-22 17:45:29 +0100614 bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE);
615 if (bytes_to_clear) {
Alberto Fariace47ff22022-10-13 14:37:02 +0200616 ret = blk_co_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP);
Max Reitzfd171462020-01-22 17:45:29 +0100617 if (ret < 0) {
618 error_setg_errno(errp, -ret,
619 "Failed to clear the new image's first sector");
620 return ret;
621 }
622 }
623
624 return 0;
625}
626
Maxim Levitsky5a5e7f82020-03-26 03:12:18 +0200627/**
628 * Simple implementation of bdrv_co_create_opts for protocol drivers
629 * which only support creation via opening a file
630 * (usually existing raw storage device)
631 */
632int coroutine_fn bdrv_co_create_opts_simple(BlockDriver *drv,
633 const char *filename,
634 QemuOpts *opts,
635 Error **errp)
Max Reitzfd171462020-01-22 17:45:29 +0100636{
Zhao Liu7b22e052024-03-11 11:37:56 +0800637 ERRP_GUARD();
Max Reitzfd171462020-01-22 17:45:29 +0100638 BlockBackend *blk;
Max Reitzeeea1fa2020-02-25 16:56:18 +0100639 QDict *options;
Max Reitzfd171462020-01-22 17:45:29 +0100640 int64_t size = 0;
641 char *buf = NULL;
642 PreallocMode prealloc;
643 Error *local_err = NULL;
644 int ret;
645
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -0500646 GLOBAL_STATE_CODE();
647
Max Reitzfd171462020-01-22 17:45:29 +0100648 size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
649 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
650 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
651 PREALLOC_MODE_OFF, &local_err);
652 g_free(buf);
653 if (local_err) {
654 error_propagate(errp, local_err);
655 return -EINVAL;
656 }
657
658 if (prealloc != PREALLOC_MODE_OFF) {
659 error_setg(errp, "Unsupported preallocation mode '%s'",
660 PreallocMode_str(prealloc));
661 return -ENOTSUP;
662 }
663
Max Reitzeeea1fa2020-02-25 16:56:18 +0100664 options = qdict_new();
Max Reitzfd171462020-01-22 17:45:29 +0100665 qdict_put_str(options, "driver", drv->format_name);
666
Kevin Wolfbe1a7322023-01-26 18:24:31 +0100667 blk = blk_co_new_open(filename, NULL, options,
668 BDRV_O_RDWR | BDRV_O_RESIZE, errp);
Max Reitzfd171462020-01-22 17:45:29 +0100669 if (!blk) {
Hanna Czenczek81624862023-07-20 16:00:24 +0200670 error_prepend(errp, "Protocol driver '%s' does not support creating "
671 "new images, so an existing image must be selected as "
672 "the target; however, opening the given target as an "
673 "existing image failed: ",
Max Reitzfd171462020-01-22 17:45:29 +0100674 drv->format_name);
675 return -EINVAL;
676 }
677
678 size = create_file_fallback_truncate(blk, size, errp);
679 if (size < 0) {
680 ret = size;
681 goto out;
682 }
683
684 ret = create_file_fallback_zero_first_sector(blk, size, errp);
685 if (ret < 0) {
686 goto out;
687 }
688
689 ret = 0;
690out:
Kevin Wolfb2ab5f52023-05-04 13:57:33 +0200691 blk_co_unref(blk);
Max Reitzfd171462020-01-22 17:45:29 +0100692 return ret;
693}
694
Emanuele Giuseppe Esposito2475a0d2022-11-28 09:23:31 -0500695int coroutine_fn bdrv_co_create_file(const char *filename, QemuOpts *opts,
696 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200697{
Stefano Garzarella729222a2021-03-08 17:12:32 +0100698 QemuOpts *protocol_opts;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200699 BlockDriver *drv;
Stefano Garzarella729222a2021-03-08 17:12:32 +0100700 QDict *qdict;
701 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200702
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500703 GLOBAL_STATE_CODE();
704
Max Reitzb65a5e12015-02-05 13:58:12 -0500705 drv = bdrv_find_protocol(filename, true, errp);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200706 if (drv == NULL) {
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000707 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200708 }
709
Stefano Garzarella729222a2021-03-08 17:12:32 +0100710 if (!drv->create_opts) {
711 error_setg(errp, "Driver '%s' does not support image creation",
712 drv->format_name);
713 return -ENOTSUP;
714 }
715
716 /*
717 * 'opts' contains a QemuOptsList with a combination of format and protocol
718 * default values.
719 *
720 * The format properly removes its options, but the default values remain
721 * in 'opts->list'. So if the protocol has options with the same name
722 * (e.g. rbd has 'cluster_size' as qcow2), it will see the default values
723 * of the format, since for overlapping options, the format wins.
724 *
725 * To avoid this issue, lets convert QemuOpts to QDict, in this way we take
726 * only the set options, and then convert it back to QemuOpts, using the
727 * create_opts of the protocol. So the new QemuOpts, will contain only the
728 * protocol defaults.
729 */
730 qdict = qemu_opts_to_qdict(opts, NULL);
731 protocol_opts = qemu_opts_from_qdict(drv->create_opts, qdict, errp);
732 if (protocol_opts == NULL) {
733 ret = -EINVAL;
734 goto out;
735 }
736
Emanuele Giuseppe Esposito2475a0d2022-11-28 09:23:31 -0500737 ret = bdrv_co_create(drv, filename, protocol_opts, errp);
Stefano Garzarella729222a2021-03-08 17:12:32 +0100738out:
739 qemu_opts_del(protocol_opts);
740 qobject_unref(qdict);
741 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200742}
743
Daniel Henrique Barbozae1d7f8b2020-01-30 18:39:05 -0300744int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp)
745{
746 Error *local_err = NULL;
747 int ret;
748
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -0500749 IO_CODE();
Daniel Henrique Barbozae1d7f8b2020-01-30 18:39:05 -0300750 assert(bs != NULL);
Kevin Wolf48aef792023-02-03 16:22:00 +0100751 assert_bdrv_graph_readable();
Daniel Henrique Barbozae1d7f8b2020-01-30 18:39:05 -0300752
753 if (!bs->drv) {
754 error_setg(errp, "Block node '%s' is not opened", bs->filename);
755 return -ENOMEDIUM;
756 }
757
758 if (!bs->drv->bdrv_co_delete_file) {
759 error_setg(errp, "Driver '%s' does not support image deletion",
760 bs->drv->format_name);
761 return -ENOTSUP;
762 }
763
764 ret = bs->drv->bdrv_co_delete_file(bs, &local_err);
765 if (ret < 0) {
766 error_propagate(errp, local_err);
767 }
768
769 return ret;
770}
771
Maxim Levitskya890f082020-12-17 19:09:03 +0200772void coroutine_fn bdrv_co_delete_file_noerr(BlockDriverState *bs)
773{
774 Error *local_err = NULL;
775 int ret;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -0500776 IO_CODE();
Maxim Levitskya890f082020-12-17 19:09:03 +0200777
778 if (!bs) {
779 return;
780 }
781
782 ret = bdrv_co_delete_file(bs, &local_err);
783 /*
784 * ENOTSUP will happen if the block driver doesn't support
785 * the 'bdrv_co_delete_file' interface. This is a predictable
786 * scenario and shouldn't be reported back to the user.
787 */
788 if (ret == -ENOTSUP) {
789 error_free(local_err);
790 } else if (ret < 0) {
791 error_report_err(local_err);
792 }
793}
794
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100795/**
796 * Try to get @bs's logical and physical block size.
797 * On success, store them in @bsz struct and return 0.
798 * On failure return -errno.
799 * @bs must not be empty.
800 */
801int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
802{
803 BlockDriver *drv = bs->drv;
Max Reitz93393e62019-06-12 17:03:38 +0200804 BlockDriverState *filtered = bdrv_filter_bs(bs);
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500805 GLOBAL_STATE_CODE();
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100806
807 if (drv && drv->bdrv_probe_blocksizes) {
808 return drv->bdrv_probe_blocksizes(bs, bsz);
Max Reitz93393e62019-06-12 17:03:38 +0200809 } else if (filtered) {
810 return bdrv_probe_blocksizes(filtered, bsz);
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100811 }
812
813 return -ENOTSUP;
814}
815
816/**
817 * Try to get @bs's geometry (cyls, heads, sectors).
818 * On success, store them in @geo struct and return 0.
819 * On failure return -errno.
820 * @bs must not be empty.
821 */
822int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
823{
824 BlockDriver *drv = bs->drv;
Kevin Wolff5a3a272023-10-27 17:53:12 +0200825 BlockDriverState *filtered;
826
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500827 GLOBAL_STATE_CODE();
Kevin Wolff5a3a272023-10-27 17:53:12 +0200828 GRAPH_RDLOCK_GUARD_MAINLOOP();
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100829
830 if (drv && drv->bdrv_probe_geometry) {
831 return drv->bdrv_probe_geometry(bs, geo);
Kevin Wolff5a3a272023-10-27 17:53:12 +0200832 }
833
834 filtered = bdrv_filter_bs(bs);
835 if (filtered) {
Max Reitz93393e62019-06-12 17:03:38 +0200836 return bdrv_probe_geometry(filtered, geo);
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100837 }
838
839 return -ENOTSUP;
840}
841
Jim Meyeringeba25052012-05-28 09:27:54 +0200842/*
843 * Create a uniquely-named empty temporary file.
Bin Meng69fbfff2022-10-10 12:04:31 +0800844 * Return the actual file name used upon success, otherwise NULL.
845 * This string should be freed with g_free() when not needed any longer.
846 *
847 * Note: creating a temporary file for the caller to (re)open is
848 * inherently racy. Use g_file_open_tmp() instead whenever practical.
Jim Meyeringeba25052012-05-28 09:27:54 +0200849 */
Bin Meng69fbfff2022-10-10 12:04:31 +0800850char *create_tmp_file(Error **errp)
Jim Meyeringeba25052012-05-28 09:27:54 +0200851{
bellardea2384d2004-08-01 21:59:26 +0000852 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000853 const char *tmpdir;
Bin Meng69fbfff2022-10-10 12:04:31 +0800854 g_autofree char *filename = NULL;
855
856 tmpdir = g_get_tmp_dir();
857#ifndef _WIN32
858 /*
859 * See commit 69bef79 ("block: use /var/tmp instead of /tmp for -snapshot")
860 *
861 * This function is used to create temporary disk images (like -snapshot),
862 * so the files can become very large. /tmp is often a tmpfs where as
863 * /var/tmp is usually on a disk, so more appropriate for disk images.
864 */
865 if (!g_strcmp0(tmpdir, "/tmp")) {
Amit Shah69bef792014-02-26 15:12:37 +0530866 tmpdir = "/var/tmp";
867 }
bellardd5249392004-08-03 21:14:23 +0000868#endif
Bin Meng69fbfff2022-10-10 12:04:31 +0800869
870 filename = g_strdup_printf("%s/vl.XXXXXX", tmpdir);
871 fd = g_mkstemp(filename);
bellardea2384d2004-08-01 21:59:26 +0000872 if (fd < 0) {
Bin Meng69fbfff2022-10-10 12:04:31 +0800873 error_setg_errno(errp, errno, "Could not open temporary file '%s'",
874 filename);
875 return NULL;
bellardea2384d2004-08-01 21:59:26 +0000876 }
Bin Meng6b6471e2022-10-10 12:04:30 +0800877 close(fd);
Bin Meng69fbfff2022-10-10 12:04:31 +0800878
879 return g_steal_pointer(&filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200880}
bellardea2384d2004-08-01 21:59:26 +0000881
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200882/*
883 * Detect host devices. By convention, /dev/cdrom[N] is always
884 * recognized as a host CDROM.
885 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200886static BlockDriver *find_hdev_driver(const char *filename)
887{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200888 int score_max = 0, score;
889 BlockDriver *drv = NULL, *d;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -0500890 GLOBAL_STATE_CODE();
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200891
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100892 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200893 if (d->bdrv_probe_device) {
894 score = d->bdrv_probe_device(filename);
895 if (score > score_max) {
896 score_max = score;
897 drv = d;
898 }
899 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200900 }
901
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200902 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200903}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200904
Marc Mari88d88792016-08-12 09:27:03 -0400905static BlockDriver *bdrv_do_find_protocol(const char *protocol)
906{
907 BlockDriver *drv1;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -0500908 GLOBAL_STATE_CODE();
Marc Mari88d88792016-08-12 09:27:03 -0400909
910 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
911 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
912 return drv1;
913 }
914 }
915
916 return NULL;
917}
918
Kevin Wolf98289622013-07-10 15:47:39 +0200919BlockDriver *bdrv_find_protocol(const char *filename,
Max Reitzb65a5e12015-02-05 13:58:12 -0500920 bool allow_protocol_prefix,
921 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200922{
923 BlockDriver *drv1;
924 char protocol[128];
925 int len;
926 const char *p;
Marc Mari88d88792016-08-12 09:27:03 -0400927 int i;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200928
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -0500929 GLOBAL_STATE_CODE();
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200930
Christoph Hellwig39508e72010-06-23 12:25:17 +0200931 /*
932 * XXX(hch): we really should not let host device detection
933 * override an explicit protocol specification, but moving this
934 * later breaks access to device names with colons in them.
935 * Thanks to the brain-dead persistent naming schemes on udev-
936 * based Linux systems those actually are quite common.
937 */
938 drv1 = find_hdev_driver(filename);
939 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200940 return drv1;
941 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200942
Kevin Wolf98289622013-07-10 15:47:39 +0200943 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Max Reitzef810432014-12-02 18:32:42 +0100944 return &bdrv_file;
Christoph Hellwig39508e72010-06-23 12:25:17 +0200945 }
Kevin Wolf98289622013-07-10 15:47:39 +0200946
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000947 p = strchr(filename, ':');
948 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200949 len = p - filename;
950 if (len > sizeof(protocol) - 1)
951 len = sizeof(protocol) - 1;
952 memcpy(protocol, filename, len);
953 protocol[len] = '\0';
Marc Mari88d88792016-08-12 09:27:03 -0400954
955 drv1 = bdrv_do_find_protocol(protocol);
956 if (drv1) {
957 return drv1;
958 }
959
960 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
961 if (block_driver_modules[i].protocol_name &&
962 !strcmp(block_driver_modules[i].protocol_name, protocol)) {
Claudio Fontanac551fb02022-09-29 11:30:33 +0200963 int rv = block_module_load(block_driver_modules[i].library_name, errp);
964 if (rv > 0) {
965 drv1 = bdrv_do_find_protocol(protocol);
966 } else if (rv < 0) {
967 return NULL;
968 }
Marc Mari88d88792016-08-12 09:27:03 -0400969 break;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200970 }
971 }
Max Reitzb65a5e12015-02-05 13:58:12 -0500972
Marc Mari88d88792016-08-12 09:27:03 -0400973 if (!drv1) {
974 error_setg(errp, "Unknown protocol '%s'", protocol);
975 }
976 return drv1;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200977}
978
Markus Armbrusterc6684242014-11-20 16:27:10 +0100979/*
980 * Guess image format by probing its contents.
981 * This is not a good idea when your image is raw (CVE-2008-2004), but
982 * we do it anyway for backward compatibility.
983 *
984 * @buf contains the image's first @buf_size bytes.
Kevin Wolf7cddd372014-11-20 16:27:11 +0100985 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
986 * but can be smaller if the image file is smaller)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100987 * @filename is its filename.
988 *
989 * For all block drivers, call the bdrv_probe() method to get its
990 * probing score.
991 * Return the first block driver with the highest probing score.
992 */
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100993BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
994 const char *filename)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100995{
996 int score_max = 0, score;
997 BlockDriver *drv = NULL, *d;
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -0500998 IO_CODE();
Markus Armbrusterc6684242014-11-20 16:27:10 +0100999
1000 QLIST_FOREACH(d, &bdrv_drivers, list) {
1001 if (d->bdrv_probe) {
1002 score = d->bdrv_probe(buf, buf_size, filename);
1003 if (score > score_max) {
1004 score_max = score;
1005 drv = d;
1006 }
1007 }
1008 }
1009
1010 return drv;
1011}
1012
Kevin Wolf5696c6e2017-02-17 18:39:24 +01001013static int find_image_format(BlockBackend *file, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +02001014 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001015{
Markus Armbrusterc6684242014-11-20 16:27:10 +01001016 BlockDriver *drv;
Kevin Wolf7cddd372014-11-20 16:27:11 +01001017 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
Kevin Wolff500a6d2012-11-12 17:35:27 +01001018 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -07001019
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001020 GLOBAL_STATE_CODE();
1021
Kevin Wolf08a00552010-06-01 18:37:31 +02001022 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Kevin Wolf5696c6e2017-02-17 18:39:24 +01001023 if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
Max Reitzef810432014-12-02 18:32:42 +01001024 *pdrv = &bdrv_raw;
Stefan Weilc98ac352010-07-21 21:51:51 +02001025 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -07001026 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -07001027
Alberto Fariaa9262f52022-07-05 17:15:11 +01001028 ret = blk_pread(file, 0, sizeof(buf), buf, 0);
bellard83f64092006-08-01 16:21:11 +00001029 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001030 error_setg_errno(errp, -ret, "Could not read image for determining its "
1031 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +02001032 *pdrv = NULL;
1033 return ret;
bellard83f64092006-08-01 16:21:11 +00001034 }
1035
Alberto Fariabf5b16f2022-07-05 17:15:09 +01001036 drv = bdrv_probe_all(buf, sizeof(buf), filename);
Stefan Weilc98ac352010-07-21 21:51:51 +02001037 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001038 error_setg(errp, "Could not determine image format: No compatible "
1039 "driver found");
Alberto Fariabf5b16f2022-07-05 17:15:09 +01001040 *pdrv = NULL;
1041 return -ENOENT;
Stefan Weilc98ac352010-07-21 21:51:51 +02001042 }
Alberto Fariabf5b16f2022-07-05 17:15:09 +01001043
Stefan Weilc98ac352010-07-21 21:51:51 +02001044 *pdrv = drv;
Alberto Fariabf5b16f2022-07-05 17:15:09 +01001045 return 0;
bellardea2384d2004-08-01 21:59:26 +00001046}
1047
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001048/**
1049 * Set the current 'total_sectors' value
Markus Armbruster65a9bb22014-06-26 13:23:17 +02001050 * Return 0 on success, -errno on error.
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001051 */
Emanuele Giuseppe Espositoc86422c2023-01-13 21:42:04 +01001052int coroutine_fn bdrv_co_refresh_total_sectors(BlockDriverState *bs,
1053 int64_t hint)
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001054{
1055 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05001056 IO_CODE();
Kevin Wolf8ab81402023-02-03 16:22:02 +01001057 assert_bdrv_graph_readable();
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001058
Max Reitzd470ad42017-11-10 21:31:09 +01001059 if (!drv) {
1060 return -ENOMEDIUM;
1061 }
1062
Emanuele Giuseppe Espositoc86422c2023-01-13 21:42:04 +01001063 /* Do not attempt drv->bdrv_co_getlength() on scsi-generic devices */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +03001064 if (bdrv_is_sg(bs))
Nicholas Bellinger396759a2010-05-17 09:46:04 -07001065 return 0;
1066
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001067 /* query actual device if possible, otherwise just trust the hint */
Emanuele Giuseppe Espositoc86422c2023-01-13 21:42:04 +01001068 if (drv->bdrv_co_getlength) {
1069 int64_t length = drv->bdrv_co_getlength(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001070 if (length < 0) {
1071 return length;
1072 }
Fam Zheng7e382002013-11-06 19:48:06 +08001073 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001074 }
1075
1076 bs->total_sectors = hint;
Vladimir Sementsov-Ogievskiy8b117002020-12-04 01:27:13 +03001077
1078 if (bs->total_sectors * BDRV_SECTOR_SIZE > BDRV_MAX_LENGTH) {
1079 return -EFBIG;
1080 }
1081
Stefan Hajnoczi51762282010-04-19 16:56:41 +01001082 return 0;
1083}
1084
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001085/**
Kevin Wolfcddff5b2015-11-16 16:43:27 +01001086 * Combines a QDict of new block driver @options with any missing options taken
1087 * from @old_options, so that leaving out an option defaults to its old value.
1088 */
1089static void bdrv_join_options(BlockDriverState *bs, QDict *options,
1090 QDict *old_options)
1091{
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05001092 GLOBAL_STATE_CODE();
Kevin Wolfcddff5b2015-11-16 16:43:27 +01001093 if (bs->drv && bs->drv->bdrv_join_options) {
1094 bs->drv->bdrv_join_options(options, old_options);
1095 } else {
1096 qdict_join(options, old_options, false);
1097 }
1098}
1099
Alberto Garcia543770b2018-09-06 12:37:09 +03001100static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
1101 int open_flags,
1102 Error **errp)
1103{
1104 Error *local_err = NULL;
1105 char *value = qemu_opt_get_del(opts, "detect-zeroes");
1106 BlockdevDetectZeroesOptions detect_zeroes =
1107 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup, value,
1108 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, &local_err);
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001109 GLOBAL_STATE_CODE();
Alberto Garcia543770b2018-09-06 12:37:09 +03001110 g_free(value);
1111 if (local_err) {
1112 error_propagate(errp, local_err);
1113 return detect_zeroes;
1114 }
1115
1116 if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
1117 !(open_flags & BDRV_O_UNMAP))
1118 {
1119 error_setg(errp, "setting detect-zeroes to unmap is not allowed "
1120 "without setting discard operation to unmap");
1121 }
1122
1123 return detect_zeroes;
1124}
1125
Kevin Wolfcddff5b2015-11-16 16:43:27 +01001126/**
Aarushi Mehtaf80f2672020-01-20 14:18:50 +00001127 * Set open flags for aio engine
1128 *
1129 * Return 0 on success, -1 if the engine specified is invalid
1130 */
1131int bdrv_parse_aio(const char *mode, int *flags)
1132{
1133 if (!strcmp(mode, "threads")) {
1134 /* do nothing, default */
1135 } else if (!strcmp(mode, "native")) {
1136 *flags |= BDRV_O_NATIVE_AIO;
1137#ifdef CONFIG_LINUX_IO_URING
1138 } else if (!strcmp(mode, "io_uring")) {
1139 *flags |= BDRV_O_IO_URING;
1140#endif
1141 } else {
1142 return -1;
1143 }
1144
1145 return 0;
1146}
1147
1148/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +01001149 * Set open flags for a given discard mode
1150 *
1151 * Return 0 on success, -1 if the discard mode was invalid.
1152 */
1153int bdrv_parse_discard_flags(const char *mode, int *flags)
1154{
1155 *flags &= ~BDRV_O_UNMAP;
1156
1157 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
1158 /* do nothing */
1159 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
1160 *flags |= BDRV_O_UNMAP;
1161 } else {
1162 return -1;
1163 }
1164
1165 return 0;
1166}
1167
1168/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001169 * Set open flags for a given cache mode
1170 *
1171 * Return 0 on success, -1 if the cache mode was invalid.
1172 */
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001173int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001174{
1175 *flags &= ~BDRV_O_CACHE_MASK;
1176
1177 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001178 *writethrough = false;
1179 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +01001180 } else if (!strcmp(mode, "directsync")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001181 *writethrough = true;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +01001182 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001183 } else if (!strcmp(mode, "writeback")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001184 *writethrough = false;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001185 } else if (!strcmp(mode, "unsafe")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001186 *writethrough = false;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001187 *flags |= BDRV_O_NO_FLUSH;
1188 } else if (!strcmp(mode, "writethrough")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +01001189 *writethrough = true;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +01001190 } else {
1191 return -1;
1192 }
1193
1194 return 0;
1195}
1196
Kevin Wolfb5411552017-01-17 15:56:16 +01001197static char *bdrv_child_get_parent_desc(BdrvChild *c)
1198{
1199 BlockDriverState *parent = c->opaque;
Vladimir Sementsov-Ogievskiy2c0a3ac2021-06-01 10:52:15 +03001200 return g_strdup_printf("node '%s'", bdrv_get_node_name(parent));
Kevin Wolfb5411552017-01-17 15:56:16 +01001201}
1202
Emanuele Giuseppe Espositod05ab382023-09-29 16:51:40 +02001203static void GRAPH_RDLOCK bdrv_child_cb_drained_begin(BdrvChild *child)
Kevin Wolf20018e12016-05-23 18:46:59 +02001204{
1205 BlockDriverState *bs = child->opaque;
Kevin Wolfa82a3bd2022-11-18 18:41:07 +01001206 bdrv_do_drained_begin_quiesce(bs, NULL);
Kevin Wolf20018e12016-05-23 18:46:59 +02001207}
1208
Emanuele Giuseppe Espositod05ab382023-09-29 16:51:40 +02001209static bool GRAPH_RDLOCK bdrv_child_cb_drained_poll(BdrvChild *child)
Kevin Wolf89bd0302018-03-22 14:11:20 +01001210{
1211 BlockDriverState *bs = child->opaque;
Kevin Wolf299403a2022-11-18 18:41:05 +01001212 return bdrv_drain_poll(bs, NULL, false);
Kevin Wolf89bd0302018-03-22 14:11:20 +01001213}
1214
Emanuele Giuseppe Espositod05ab382023-09-29 16:51:40 +02001215static void GRAPH_RDLOCK bdrv_child_cb_drained_end(BdrvChild *child)
Kevin Wolf20018e12016-05-23 18:46:59 +02001216{
1217 BlockDriverState *bs = child->opaque;
Kevin Wolf2f65df62022-11-18 18:40:59 +01001218 bdrv_drained_end(bs);
Kevin Wolf20018e12016-05-23 18:46:59 +02001219}
1220
Kevin Wolf38701b62017-05-04 18:52:39 +02001221static int bdrv_child_cb_inactivate(BdrvChild *child)
1222{
1223 BlockDriverState *bs = child->opaque;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001224 GLOBAL_STATE_CODE();
Kevin Wolf38701b62017-05-04 18:52:39 +02001225 assert(bs->open_flags & BDRV_O_INACTIVE);
1226 return 0;
1227}
1228
Emanuele Giuseppe Esposito27633e72022-10-25 04:49:47 -04001229static bool bdrv_child_cb_change_aio_ctx(BdrvChild *child, AioContext *ctx,
1230 GHashTable *visited, Transaction *tran,
1231 Error **errp)
Kevin Wolf5d231842019-05-06 19:17:56 +02001232{
1233 BlockDriverState *bs = child->opaque;
Emanuele Giuseppe Esposito27633e72022-10-25 04:49:47 -04001234 return bdrv_change_aio_context(bs, ctx, visited, tran, errp);
Kevin Wolf53a7d042019-05-06 19:17:59 +02001235}
1236
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001237/*
Kevin Wolf73176be2016-03-07 13:02:15 +01001238 * Returns the options and flags that a temporary snapshot should get, based on
1239 * the originally requested flags (the originally requested image will have
1240 * flags like a backing file)
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001241 */
Kevin Wolf73176be2016-03-07 13:02:15 +01001242static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
1243 int parent_flags, QDict *parent_options)
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001244{
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001245 GLOBAL_STATE_CODE();
Kevin Wolf73176be2016-03-07 13:02:15 +01001246 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
1247
1248 /* For temporary files, unconditional cache=unsafe is fine */
Kevin Wolf73176be2016-03-07 13:02:15 +01001249 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
1250 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
Kevin Wolf41869042016-06-16 12:59:30 +02001251
Kevin Wolf3f486862019-04-04 17:04:43 +02001252 /* Copy the read-only and discard options from the parent */
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001253 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
Kevin Wolf3f486862019-04-04 17:04:43 +02001254 qdict_copy_default(child_options, parent_options, BDRV_OPT_DISCARD);
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001255
Kevin Wolf41869042016-06-16 12:59:30 +02001256 /* aio=native doesn't work for cache.direct=off, so disable it for the
1257 * temporary snapshot */
1258 *child_flags &= ~BDRV_O_NATIVE_AIO;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001259}
1260
Kevin Wolfb7cfc7d2023-09-29 16:51:45 +02001261static void GRAPH_WRLOCK bdrv_backing_attach(BdrvChild *c)
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001262{
1263 BlockDriverState *parent = c->opaque;
1264 BlockDriverState *backing_hd = c->bs;
1265
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001266 GLOBAL_STATE_CODE();
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001267 assert(!parent->backing_blocker);
1268 error_setg(&parent->backing_blocker,
1269 "node is used as backing hd of '%s'",
1270 bdrv_get_device_or_node_name(parent));
1271
Max Reitzf30c66b2019-02-01 20:29:05 +01001272 bdrv_refresh_filename(backing_hd);
1273
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001274 parent->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001275
1276 bdrv_op_block_all(backing_hd, parent->backing_blocker);
1277 /* Otherwise we won't be able to commit or stream */
1278 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1279 parent->backing_blocker);
1280 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
1281 parent->backing_blocker);
1282 /*
1283 * We do backup in 3 ways:
1284 * 1. drive backup
1285 * The target bs is new opened, and the source is top BDS
1286 * 2. blockdev backup
1287 * Both the source and the target are top BDSes.
1288 * 3. internal backup(used for block replication)
1289 * Both the source and the target are backing file
1290 *
1291 * In case 1 and 2, neither the source nor the target is the backing file.
1292 * In case 3, we will block the top BDS, so there is only one block job
1293 * for the top BDS and its backing chain.
1294 */
1295 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
1296 parent->backing_blocker);
1297 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
1298 parent->backing_blocker);
Max Reitzca2f1232020-05-13 13:05:22 +02001299}
Kevin Wolfd736f112017-12-18 16:05:48 +01001300
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001301static void bdrv_backing_detach(BdrvChild *c)
1302{
1303 BlockDriverState *parent = c->opaque;
1304
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001305 GLOBAL_STATE_CODE();
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01001306 assert(parent->backing_blocker);
1307 bdrv_op_unblock_all(c->bs, parent->backing_blocker);
1308 error_free(parent->backing_blocker);
1309 parent->backing_blocker = NULL;
Max Reitz48e08282020-05-13 13:05:23 +02001310}
Kevin Wolfd736f112017-12-18 16:05:48 +01001311
Kevin Wolf6858eba2017-06-29 19:32:21 +02001312static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
Peter Krempa4b028cb2023-12-05 18:14:41 +01001313 const char *filename,
1314 bool backing_mask_protocol,
1315 Error **errp)
Kevin Wolf6858eba2017-06-29 19:32:21 +02001316{
1317 BlockDriverState *parent = c->opaque;
Alberto Garciae94d3db2018-11-12 16:00:34 +02001318 bool read_only = bdrv_is_read_only(parent);
Kevin Wolf6858eba2017-06-29 19:32:21 +02001319 int ret;
Peter Krempa4b028cb2023-12-05 18:14:41 +01001320 const char *format_name;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001321 GLOBAL_STATE_CODE();
Kevin Wolf6858eba2017-06-29 19:32:21 +02001322
Alberto Garciae94d3db2018-11-12 16:00:34 +02001323 if (read_only) {
1324 ret = bdrv_reopen_set_read_only(parent, false, errp);
Kevin Wolf61f09ce2017-09-19 16:22:54 +02001325 if (ret < 0) {
1326 return ret;
1327 }
1328 }
1329
Peter Krempa4b028cb2023-12-05 18:14:41 +01001330 if (base->drv) {
1331 /*
1332 * If the new base image doesn't have a format driver layer, which we
1333 * detect by the fact that @base is a protocol driver, we record
1334 * 'raw' as the format instead of putting the protocol name as the
1335 * backing format
1336 */
1337 if (backing_mask_protocol && base->drv->protocol_name) {
1338 format_name = "raw";
1339 } else {
1340 format_name = base->drv->format_name;
1341 }
1342 } else {
1343 format_name = "";
1344 }
1345
1346 ret = bdrv_change_backing_file(parent, filename, format_name, false);
Kevin Wolf6858eba2017-06-29 19:32:21 +02001347 if (ret < 0) {
Kevin Wolf64730692017-11-06 17:52:58 +01001348 error_setg_errno(errp, -ret, "Could not update backing file link");
Kevin Wolf6858eba2017-06-29 19:32:21 +02001349 }
1350
Alberto Garciae94d3db2018-11-12 16:00:34 +02001351 if (read_only) {
1352 bdrv_reopen_set_read_only(parent, true, NULL);
Kevin Wolf61f09ce2017-09-19 16:22:54 +02001353 }
1354
Kevin Wolf6858eba2017-06-29 19:32:21 +02001355 return ret;
1356}
1357
Max Reitzfae8bd32020-05-13 13:05:20 +02001358/*
1359 * Returns the options and flags that a generic child of a BDS should
1360 * get, based on the given options and flags for the parent BDS.
1361 */
Max Reitz00ff7ff2020-05-13 13:05:21 +02001362static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
1363 int *child_flags, QDict *child_options,
1364 int parent_flags, QDict *parent_options)
Max Reitzfae8bd32020-05-13 13:05:20 +02001365{
1366 int flags = parent_flags;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001367 GLOBAL_STATE_CODE();
Max Reitzfae8bd32020-05-13 13:05:20 +02001368
1369 /*
1370 * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
1371 * Generally, the question to answer is: Should this child be
1372 * format-probed by default?
1373 */
1374
1375 /*
1376 * Pure and non-filtered data children of non-format nodes should
1377 * be probed by default (even when the node itself has BDRV_O_PROTOCOL
1378 * set). This only affects a very limited set of drivers (namely
1379 * quorum and blkverify when this comment was written).
1380 * Force-clear BDRV_O_PROTOCOL then.
1381 */
1382 if (!parent_is_format &&
1383 (role & BDRV_CHILD_DATA) &&
1384 !(role & (BDRV_CHILD_METADATA | BDRV_CHILD_FILTERED)))
1385 {
1386 flags &= ~BDRV_O_PROTOCOL;
1387 }
1388
1389 /*
1390 * All children of format nodes (except for COW children) and all
1391 * metadata children in general should never be format-probed.
1392 * Force-set BDRV_O_PROTOCOL then.
1393 */
1394 if ((parent_is_format && !(role & BDRV_CHILD_COW)) ||
1395 (role & BDRV_CHILD_METADATA))
1396 {
1397 flags |= BDRV_O_PROTOCOL;
1398 }
1399
1400 /*
1401 * If the cache mode isn't explicitly set, inherit direct and no-flush from
1402 * the parent.
1403 */
1404 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
1405 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
1406 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
1407
1408 if (role & BDRV_CHILD_COW) {
1409 /* backing files are opened read-only by default */
1410 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
1411 qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
1412 } else {
1413 /* Inherit the read-only option from the parent if it's not set */
1414 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
1415 qdict_copy_default(child_options, parent_options,
1416 BDRV_OPT_AUTO_READ_ONLY);
1417 }
1418
1419 /*
1420 * bdrv_co_pdiscard() respects unmap policy for the parent, so we
1421 * can default to enable it on lower layers regardless of the
1422 * parent option.
1423 */
1424 qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
1425
1426 /* Clear flags that only apply to the top layer */
1427 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
1428
1429 if (role & BDRV_CHILD_METADATA) {
1430 flags &= ~BDRV_O_NO_IO;
1431 }
1432 if (role & BDRV_CHILD_COW) {
1433 flags &= ~BDRV_O_TEMPORARY;
1434 }
1435
1436 *child_flags = flags;
1437}
1438
Kevin Wolf303de472022-12-07 14:18:35 +01001439static void GRAPH_WRLOCK bdrv_child_cb_attach(BdrvChild *child)
Max Reitzca2f1232020-05-13 13:05:22 +02001440{
1441 BlockDriverState *bs = child->opaque;
1442
Emanuele Giuseppe Esposito3f35f822022-12-07 14:18:33 +01001443 assert_bdrv_graph_writable();
Hanna Reitza2253692021-11-15 15:53:58 +01001444 QLIST_INSERT_HEAD(&bs->children, child, next);
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03001445 if (bs->drv->is_filter || (child->role & BDRV_CHILD_FILTERED)) {
1446 /*
1447 * Here we handle filters and block/raw-format.c when it behave like
1448 * filter. They generally have a single PRIMARY child, which is also the
1449 * FILTERED child, and that they may have multiple more children, which
1450 * are neither PRIMARY nor FILTERED. And never we have a COW child here.
1451 * So bs->file will be the PRIMARY child, unless the PRIMARY child goes
1452 * into bs->backing on exceptional cases; and bs->backing will be
1453 * nothing else.
1454 */
1455 assert(!(child->role & BDRV_CHILD_COW));
1456 if (child->role & BDRV_CHILD_PRIMARY) {
1457 assert(child->role & BDRV_CHILD_FILTERED);
1458 assert(!bs->backing);
1459 assert(!bs->file);
Hanna Reitza2253692021-11-15 15:53:58 +01001460
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03001461 if (bs->drv->filtered_child_is_backing) {
1462 bs->backing = child;
1463 } else {
1464 bs->file = child;
1465 }
1466 } else {
1467 assert(!(child->role & BDRV_CHILD_FILTERED));
1468 }
1469 } else if (child->role & BDRV_CHILD_COW) {
1470 assert(bs->drv->supports_backing);
1471 assert(!(child->role & BDRV_CHILD_PRIMARY));
1472 assert(!bs->backing);
1473 bs->backing = child;
Max Reitzca2f1232020-05-13 13:05:22 +02001474 bdrv_backing_attach(child);
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03001475 } else if (child->role & BDRV_CHILD_PRIMARY) {
1476 assert(!bs->file);
1477 bs->file = child;
Max Reitzca2f1232020-05-13 13:05:22 +02001478 }
Max Reitzca2f1232020-05-13 13:05:22 +02001479}
1480
Kevin Wolf303de472022-12-07 14:18:35 +01001481static void GRAPH_WRLOCK bdrv_child_cb_detach(BdrvChild *child)
Max Reitz48e08282020-05-13 13:05:23 +02001482{
1483 BlockDriverState *bs = child->opaque;
1484
1485 if (child->role & BDRV_CHILD_COW) {
1486 bdrv_backing_detach(child);
1487 }
1488
Emanuele Giuseppe Esposito3f35f822022-12-07 14:18:33 +01001489 assert_bdrv_graph_writable();
Hanna Reitza2253692021-11-15 15:53:58 +01001490 QLIST_REMOVE(child, next);
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03001491 if (child == bs->backing) {
1492 assert(child != bs->file);
1493 bs->backing = NULL;
1494 } else if (child == bs->file) {
1495 bs->file = NULL;
1496 }
Max Reitz48e08282020-05-13 13:05:23 +02001497}
1498
Max Reitz43483552020-05-13 13:05:24 +02001499static int bdrv_child_cb_update_filename(BdrvChild *c, BlockDriverState *base,
Peter Krempa4b028cb2023-12-05 18:14:41 +01001500 const char *filename,
1501 bool backing_mask_protocol,
1502 Error **errp)
Max Reitz43483552020-05-13 13:05:24 +02001503{
1504 if (c->role & BDRV_CHILD_COW) {
Peter Krempa4b028cb2023-12-05 18:14:41 +01001505 return bdrv_backing_update_filename(c, base, filename,
1506 backing_mask_protocol,
1507 errp);
Max Reitz43483552020-05-13 13:05:24 +02001508 }
1509 return 0;
1510}
1511
Vladimir Sementsov-Ogievskiyfb62b582021-05-24 13:12:56 +03001512AioContext *child_of_bds_get_parent_aio_context(BdrvChild *c)
Vladimir Sementsov-Ogievskiy3ca1f322021-04-28 18:17:33 +03001513{
1514 BlockDriverState *bs = c->opaque;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05001515 IO_CODE();
Vladimir Sementsov-Ogievskiy3ca1f322021-04-28 18:17:33 +03001516
1517 return bdrv_get_aio_context(bs);
1518}
1519
Max Reitz43483552020-05-13 13:05:24 +02001520const BdrvChildClass child_of_bds = {
1521 .parent_is_bds = true,
1522 .get_parent_desc = bdrv_child_get_parent_desc,
1523 .inherit_options = bdrv_inherited_options,
1524 .drained_begin = bdrv_child_cb_drained_begin,
1525 .drained_poll = bdrv_child_cb_drained_poll,
1526 .drained_end = bdrv_child_cb_drained_end,
1527 .attach = bdrv_child_cb_attach,
1528 .detach = bdrv_child_cb_detach,
1529 .inactivate = bdrv_child_cb_inactivate,
Emanuele Giuseppe Esposito27633e72022-10-25 04:49:47 -04001530 .change_aio_ctx = bdrv_child_cb_change_aio_ctx,
Max Reitz43483552020-05-13 13:05:24 +02001531 .update_filename = bdrv_child_cb_update_filename,
Vladimir Sementsov-Ogievskiyfb62b582021-05-24 13:12:56 +03001532 .get_parent_aio_context = child_of_bds_get_parent_aio_context,
Max Reitz43483552020-05-13 13:05:24 +02001533};
1534
Vladimir Sementsov-Ogievskiy3ca1f322021-04-28 18:17:33 +03001535AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c)
1536{
Hanna Reitzd5f8d792022-11-07 16:13:19 +01001537 IO_CODE();
Vladimir Sementsov-Ogievskiy3ca1f322021-04-28 18:17:33 +03001538 return c->klass->get_parent_aio_context(c);
1539}
1540
Kevin Wolf7b272452012-11-12 17:05:39 +01001541static int bdrv_open_flags(BlockDriverState *bs, int flags)
1542{
Kevin Wolf61de4c62016-03-18 17:46:45 +01001543 int open_flags = flags;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001544 GLOBAL_STATE_CODE();
Kevin Wolf7b272452012-11-12 17:05:39 +01001545
1546 /*
1547 * Clear flags that are internal to the block layer before opening the
1548 * image.
1549 */
Kevin Wolf20cca272014-06-04 14:33:27 +02001550 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
Kevin Wolf7b272452012-11-12 17:05:39 +01001551
Kevin Wolf7b272452012-11-12 17:05:39 +01001552 return open_flags;
1553}
1554
Kevin Wolf91a097e2015-05-08 17:49:53 +02001555static void update_flags_from_options(int *flags, QemuOpts *opts)
1556{
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001557 GLOBAL_STATE_CODE();
1558
Alberto Garcia2a3d4332018-11-12 16:00:48 +02001559 *flags &= ~(BDRV_O_CACHE_MASK | BDRV_O_RDWR | BDRV_O_AUTO_RDONLY);
Kevin Wolf91a097e2015-05-08 17:49:53 +02001560
Alberto Garcia57f9db92018-09-06 12:37:06 +03001561 if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
Kevin Wolf91a097e2015-05-08 17:49:53 +02001562 *flags |= BDRV_O_NO_FLUSH;
1563 }
1564
Alberto Garcia57f9db92018-09-06 12:37:06 +03001565 if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_DIRECT, false)) {
Kevin Wolf91a097e2015-05-08 17:49:53 +02001566 *flags |= BDRV_O_NOCACHE;
1567 }
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001568
Alberto Garcia57f9db92018-09-06 12:37:06 +03001569 if (!qemu_opt_get_bool_del(opts, BDRV_OPT_READ_ONLY, false)) {
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001570 *flags |= BDRV_O_RDWR;
1571 }
1572
Kevin Wolfe35bdc12018-10-05 18:57:40 +02001573 if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
1574 *flags |= BDRV_O_AUTO_RDONLY;
1575 }
Kevin Wolf91a097e2015-05-08 17:49:53 +02001576}
1577
1578static void update_options_from_flags(QDict *options, int flags)
1579{
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001580 GLOBAL_STATE_CODE();
Kevin Wolf91a097e2015-05-08 17:49:53 +02001581 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
Eric Blake46f5ac22017-04-27 16:58:17 -05001582 qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
Kevin Wolf91a097e2015-05-08 17:49:53 +02001583 }
1584 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
Eric Blake46f5ac22017-04-27 16:58:17 -05001585 qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
1586 flags & BDRV_O_NO_FLUSH);
Kevin Wolf91a097e2015-05-08 17:49:53 +02001587 }
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001588 if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
Eric Blake46f5ac22017-04-27 16:58:17 -05001589 qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001590 }
Kevin Wolfe35bdc12018-10-05 18:57:40 +02001591 if (!qdict_haskey(options, BDRV_OPT_AUTO_READ_ONLY)) {
1592 qdict_put_bool(options, BDRV_OPT_AUTO_READ_ONLY,
1593 flags & BDRV_O_AUTO_RDONLY);
1594 }
Kevin Wolf91a097e2015-05-08 17:49:53 +02001595}
1596
Kevin Wolf636ea372014-01-24 14:11:52 +01001597static void bdrv_assign_node_name(BlockDriverState *bs,
1598 const char *node_name,
1599 Error **errp)
Benoît Canet6913c0c2014-01-23 21:31:33 +01001600{
Jeff Cody15489c72015-10-12 19:36:50 -04001601 char *gen_node_name = NULL;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05001602 GLOBAL_STATE_CODE();
Benoît Canet6913c0c2014-01-23 21:31:33 +01001603
Jeff Cody15489c72015-10-12 19:36:50 -04001604 if (!node_name) {
1605 node_name = gen_node_name = id_generate(ID_BLOCK);
1606 } else if (!id_wellformed(node_name)) {
1607 /*
1608 * Check for empty string or invalid characters, but not if it is
1609 * generated (generated names use characters not available to the user)
1610 */
Connor Kuehl785ec4b2021-03-05 09:19:28 -06001611 error_setg(errp, "Invalid node-name: '%s'", node_name);
Kevin Wolf636ea372014-01-24 14:11:52 +01001612 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +01001613 }
1614
Benoît Canet0c5e94e2014-02-12 17:15:07 +01001615 /* takes care of avoiding namespaces collisions */
Markus Armbruster7f06d472014-10-07 13:59:12 +02001616 if (blk_by_name(node_name)) {
Benoît Canet0c5e94e2014-02-12 17:15:07 +01001617 error_setg(errp, "node-name=%s is conflicting with a device id",
1618 node_name);
Jeff Cody15489c72015-10-12 19:36:50 -04001619 goto out;
Benoît Canet0c5e94e2014-02-12 17:15:07 +01001620 }
1621
Benoît Canet6913c0c2014-01-23 21:31:33 +01001622 /* takes care of avoiding duplicates node names */
1623 if (bdrv_find_node(node_name)) {
Connor Kuehl785ec4b2021-03-05 09:19:28 -06001624 error_setg(errp, "Duplicate nodes with node-name='%s'", node_name);
Jeff Cody15489c72015-10-12 19:36:50 -04001625 goto out;
Benoît Canet6913c0c2014-01-23 21:31:33 +01001626 }
1627
Kevin Wolf824808d2018-07-04 13:28:29 +02001628 /* Make sure that the node name isn't truncated */
1629 if (strlen(node_name) >= sizeof(bs->node_name)) {
1630 error_setg(errp, "Node name too long");
1631 goto out;
1632 }
1633
Benoît Canet6913c0c2014-01-23 21:31:33 +01001634 /* copy node name into the bs and insert it into the graph list */
1635 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
1636 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
Jeff Cody15489c72015-10-12 19:36:50 -04001637out:
1638 g_free(gen_node_name);
Benoît Canet6913c0c2014-01-23 21:31:33 +01001639}
1640
Kevin Wolf1a30b0f2023-05-04 13:57:38 +02001641static int no_coroutine_fn GRAPH_UNLOCKED
1642bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, const char *node_name,
1643 QDict *options, int open_flags, Error **errp)
Kevin Wolf01a56502017-01-18 15:51:56 +01001644{
1645 Error *local_err = NULL;
Kevin Wolf0f122642018-03-28 18:29:18 +02001646 int i, ret;
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05001647 GLOBAL_STATE_CODE();
Kevin Wolf01a56502017-01-18 15:51:56 +01001648
1649 bdrv_assign_node_name(bs, node_name, &local_err);
1650 if (local_err) {
1651 error_propagate(errp, local_err);
1652 return -EINVAL;
1653 }
1654
1655 bs->drv = drv;
1656 bs->opaque = g_malloc0(drv->instance_size);
1657
Paolo Bonziniae8b45d2022-11-24 16:29:06 +01001658 assert(!drv->bdrv_needs_filename || bs->filename[0]);
Paolo Bonzini44b424d2022-11-24 16:22:22 +01001659 if (drv->bdrv_open) {
Kevin Wolf01a56502017-01-18 15:51:56 +01001660 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf680c7f92017-01-18 17:16:41 +01001661 } else {
1662 ret = 0;
Kevin Wolf01a56502017-01-18 15:51:56 +01001663 }
1664
1665 if (ret < 0) {
1666 if (local_err) {
1667 error_propagate(errp, local_err);
1668 } else if (bs->filename[0]) {
1669 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1670 } else {
1671 error_setg_errno(errp, -ret, "Could not open image");
1672 }
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001673 goto open_failed;
Kevin Wolf01a56502017-01-18 15:51:56 +01001674 }
1675
Stefan Hajnoczie8b65352022-10-13 14:59:01 -04001676 assert(!(bs->supported_read_flags & ~BDRV_REQ_MASK));
1677 assert(!(bs->supported_write_flags & ~BDRV_REQ_MASK));
1678
1679 /*
1680 * Always allow the BDRV_REQ_REGISTERED_BUF optimization hint. This saves
1681 * drivers that pass read/write requests through to a child the trouble of
1682 * declaring support explicitly.
1683 *
1684 * Drivers must not propagate this flag accidentally when they initiate I/O
1685 * to a bounce buffer. That case should be rare though.
1686 */
1687 bs->supported_read_flags |= BDRV_REQ_REGISTERED_BUF;
1688 bs->supported_write_flags |= BDRV_REQ_REGISTERED_BUF;
1689
Emanuele Giuseppe Espositoc0579602023-01-13 21:42:03 +01001690 ret = bdrv_refresh_total_sectors(bs, bs->total_sectors);
Kevin Wolf01a56502017-01-18 15:51:56 +01001691 if (ret < 0) {
1692 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001693 return ret;
Kevin Wolf01a56502017-01-18 15:51:56 +01001694 }
1695
Kevin Wolfe19b1572023-05-04 13:57:50 +02001696 bdrv_graph_rdlock_main_loop();
Vladimir Sementsov-Ogievskiy1e4c7972021-04-28 18:17:55 +03001697 bdrv_refresh_limits(bs, NULL, &local_err);
Kevin Wolfe19b1572023-05-04 13:57:50 +02001698 bdrv_graph_rdunlock_main_loop();
1699
Kevin Wolf01a56502017-01-18 15:51:56 +01001700 if (local_err) {
1701 error_propagate(errp, local_err);
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001702 return -EINVAL;
Kevin Wolf01a56502017-01-18 15:51:56 +01001703 }
1704
1705 assert(bdrv_opt_mem_align(bs) != 0);
1706 assert(bdrv_min_mem_align(bs) != 0);
1707 assert(is_power_of_2(bs->bl.request_alignment));
1708
Kevin Wolf0f122642018-03-28 18:29:18 +02001709 for (i = 0; i < bs->quiesce_counter; i++) {
Kevin Wolf5e8ac212022-11-18 18:40:58 +01001710 if (drv->bdrv_drain_begin) {
1711 drv->bdrv_drain_begin(bs);
Kevin Wolf0f122642018-03-28 18:29:18 +02001712 }
1713 }
1714
Kevin Wolf01a56502017-01-18 15:51:56 +01001715 return 0;
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001716open_failed:
1717 bs->drv = NULL;
Kevin Wolf1f051dc2023-10-27 17:53:33 +02001718
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05001719 bdrv_graph_wrlock();
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001720 if (bs->file != NULL) {
1721 bdrv_unref_child(bs, bs->file);
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03001722 assert(!bs->file);
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001723 }
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05001724 bdrv_graph_wrunlock();
Kevin Wolf1f051dc2023-10-27 17:53:33 +02001725
Kevin Wolf01a56502017-01-18 15:51:56 +01001726 g_free(bs->opaque);
1727 bs->opaque = NULL;
Kevin Wolf01a56502017-01-18 15:51:56 +01001728 return ret;
1729}
1730
Vladimir Sementsov-Ogievskiy621d1732021-09-20 14:55:34 +03001731/*
1732 * Create and open a block node.
1733 *
1734 * @options is a QDict of options to pass to the block drivers, or NULL for an
1735 * empty set of options. The reference to the QDict belongs to the block layer
1736 * after the call (even on failure), so if the caller intends to reuse the
1737 * dictionary, it needs to use qobject_ref() before calling bdrv_open.
1738 */
1739BlockDriverState *bdrv_new_open_driver_opts(BlockDriver *drv,
1740 const char *node_name,
1741 QDict *options, int flags,
1742 Error **errp)
Kevin Wolf680c7f92017-01-18 17:16:41 +01001743{
1744 BlockDriverState *bs;
1745 int ret;
1746
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05001747 GLOBAL_STATE_CODE();
1748
Kevin Wolf680c7f92017-01-18 17:16:41 +01001749 bs = bdrv_new();
1750 bs->open_flags = flags;
Vladimir Sementsov-Ogievskiy621d1732021-09-20 14:55:34 +03001751 bs->options = options ?: qdict_new();
1752 bs->explicit_options = qdict_clone_shallow(bs->options);
Kevin Wolf680c7f92017-01-18 17:16:41 +01001753 bs->opaque = NULL;
1754
1755 update_options_from_flags(bs->options, flags);
1756
1757 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
1758 if (ret < 0) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001759 qobject_unref(bs->explicit_options);
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001760 bs->explicit_options = NULL;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001761 qobject_unref(bs->options);
Manos Pitsidianakis180ca192017-07-14 17:35:48 +03001762 bs->options = NULL;
Kevin Wolf680c7f92017-01-18 17:16:41 +01001763 bdrv_unref(bs);
1764 return NULL;
1765 }
1766
1767 return bs;
1768}
1769
Vladimir Sementsov-Ogievskiy621d1732021-09-20 14:55:34 +03001770/* Create and open a block node. */
1771BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
1772 int flags, Error **errp)
1773{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05001774 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy621d1732021-09-20 14:55:34 +03001775 return bdrv_new_open_driver_opts(drv, node_name, NULL, flags, errp);
1776}
1777
Kevin Wolfc5f30142016-10-06 11:33:17 +02001778QemuOptsList bdrv_runtime_opts = {
Kevin Wolf18edf282015-04-07 17:12:56 +02001779 .name = "bdrv_common",
1780 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
1781 .desc = {
1782 {
1783 .name = "node-name",
1784 .type = QEMU_OPT_STRING,
1785 .help = "Node name of the block device node",
1786 },
Kevin Wolf62392eb2015-04-24 16:38:02 +02001787 {
1788 .name = "driver",
1789 .type = QEMU_OPT_STRING,
1790 .help = "Block driver to use for the node",
1791 },
Kevin Wolf91a097e2015-05-08 17:49:53 +02001792 {
Kevin Wolf91a097e2015-05-08 17:49:53 +02001793 .name = BDRV_OPT_CACHE_DIRECT,
1794 .type = QEMU_OPT_BOOL,
1795 .help = "Bypass software writeback cache on the host",
1796 },
1797 {
1798 .name = BDRV_OPT_CACHE_NO_FLUSH,
1799 .type = QEMU_OPT_BOOL,
1800 .help = "Ignore flush requests",
1801 },
Alberto Garciaf87a0e22016-09-15 17:53:02 +03001802 {
1803 .name = BDRV_OPT_READ_ONLY,
1804 .type = QEMU_OPT_BOOL,
1805 .help = "Node is opened in read-only mode",
1806 },
Kevin Wolf692e01a2016-09-12 21:00:41 +02001807 {
Kevin Wolfe35bdc12018-10-05 18:57:40 +02001808 .name = BDRV_OPT_AUTO_READ_ONLY,
1809 .type = QEMU_OPT_BOOL,
1810 .help = "Node can become read-only if opening read-write fails",
1811 },
1812 {
Kevin Wolf692e01a2016-09-12 21:00:41 +02001813 .name = "detect-zeroes",
1814 .type = QEMU_OPT_STRING,
1815 .help = "try to optimize zero writes (off, on, unmap)",
1816 },
Kevin Wolf818584a2016-09-12 18:03:18 +02001817 {
Alberto Garcia415bbca2018-10-03 13:23:13 +03001818 .name = BDRV_OPT_DISCARD,
Kevin Wolf818584a2016-09-12 18:03:18 +02001819 .type = QEMU_OPT_STRING,
1820 .help = "discard operation (ignore/off, unmap/on)",
1821 },
Fam Zheng5a9347c2017-05-03 00:35:37 +08001822 {
1823 .name = BDRV_OPT_FORCE_SHARE,
1824 .type = QEMU_OPT_BOOL,
1825 .help = "always accept other writers (default: off)",
1826 },
Kevin Wolf18edf282015-04-07 17:12:56 +02001827 { /* end of list */ }
1828 },
1829};
1830
Maxim Levitsky5a5e7f82020-03-26 03:12:18 +02001831QemuOptsList bdrv_create_opts_simple = {
1832 .name = "simple-create-opts",
1833 .head = QTAILQ_HEAD_INITIALIZER(bdrv_create_opts_simple.head),
Max Reitzfd171462020-01-22 17:45:29 +01001834 .desc = {
1835 {
1836 .name = BLOCK_OPT_SIZE,
1837 .type = QEMU_OPT_SIZE,
1838 .help = "Virtual disk size"
1839 },
1840 {
1841 .name = BLOCK_OPT_PREALLOC,
1842 .type = QEMU_OPT_STRING,
1843 .help = "Preallocation mode (allowed values: off)"
1844 },
1845 { /* end of list */ }
1846 }
1847};
1848
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001849/*
Kevin Wolf57915332010-04-14 15:24:50 +02001850 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001851 *
1852 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +02001853 */
Kevin Wolf5696c6e2017-02-17 18:39:24 +01001854static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001855 QDict *options, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +02001856{
1857 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +02001858 const char *filename;
Kevin Wolf62392eb2015-04-24 16:38:02 +02001859 const char *driver_name = NULL;
Benoît Canet6913c0c2014-01-23 21:31:33 +01001860 const char *node_name = NULL;
Kevin Wolf818584a2016-09-12 18:03:18 +02001861 const char *discard;
Kevin Wolf18edf282015-04-07 17:12:56 +02001862 QemuOpts *opts;
Kevin Wolf62392eb2015-04-24 16:38:02 +02001863 BlockDriver *drv;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001864 Error *local_err = NULL;
Vladimir Sementsov-Ogievskiy307261b2021-05-27 18:40:54 +03001865 bool ro;
Kevin Wolf57915332010-04-14 15:24:50 +02001866
Kevin Wolf1f051dc2023-10-27 17:53:33 +02001867 GLOBAL_STATE_CODE();
1868
1869 bdrv_graph_rdlock_main_loop();
Paolo Bonzini64058752012-05-08 16:51:49 +02001870 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +01001871 assert(options != NULL && bs->options != options);
Kevin Wolf1f051dc2023-10-27 17:53:33 +02001872 bdrv_graph_rdunlock_main_loop();
Kevin Wolf57915332010-04-14 15:24:50 +02001873
Kevin Wolf62392eb2015-04-24 16:38:02 +02001874 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
Markus Armbrusteraf175e82020-07-07 18:06:03 +02001875 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
Kevin Wolf62392eb2015-04-24 16:38:02 +02001876 ret = -EINVAL;
1877 goto fail_opts;
1878 }
1879
Alberto Garcia9b7e8692016-09-15 17:53:01 +03001880 update_flags_from_options(&bs->open_flags, opts);
1881
Kevin Wolf62392eb2015-04-24 16:38:02 +02001882 driver_name = qemu_opt_get(opts, "driver");
1883 drv = bdrv_find_format(driver_name);
1884 assert(drv != NULL);
1885
Fam Zheng5a9347c2017-05-03 00:35:37 +08001886 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);
1887
1888 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {
1889 error_setg(errp,
1890 BDRV_OPT_FORCE_SHARE
1891 "=on can only be used with read-only images");
1892 ret = -EINVAL;
1893 goto fail_opts;
1894 }
1895
Kevin Wolf45673672013-04-22 17:48:40 +02001896 if (file != NULL) {
Kevin Wolfb7cfc7d2023-09-29 16:51:45 +02001897 bdrv_graph_rdlock_main_loop();
Max Reitzf30c66b2019-02-01 20:29:05 +01001898 bdrv_refresh_filename(blk_bs(file));
Kevin Wolfb7cfc7d2023-09-29 16:51:45 +02001899 bdrv_graph_rdunlock_main_loop();
1900
Kevin Wolf5696c6e2017-02-17 18:39:24 +01001901 filename = blk_bs(file)->filename;
Kevin Wolf45673672013-04-22 17:48:40 +02001902 } else {
Markus Armbruster129c7d12017-03-30 19:43:12 +02001903 /*
1904 * Caution: while qdict_get_try_str() is fine, getting
1905 * non-string types would require more care. When @options
1906 * come from -blockdev or blockdev_add, its members are typed
1907 * according to the QAPI schema, but when they come from
1908 * -drive, they're all QString.
1909 */
Kevin Wolf45673672013-04-22 17:48:40 +02001910 filename = qdict_get_try_str(options, "filename");
1911 }
1912
Max Reitz4a008242017-04-13 18:06:24 +02001913 if (drv->bdrv_needs_filename && (!filename || !filename[0])) {
Kevin Wolf765003d2014-02-03 14:49:42 +01001914 error_setg(errp, "The '%s' block driver requires a file name",
1915 drv->format_name);
Kevin Wolf18edf282015-04-07 17:12:56 +02001916 ret = -EINVAL;
1917 goto fail_opts;
1918 }
1919
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001920 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
1921 drv->format_name);
Kevin Wolf62392eb2015-04-24 16:38:02 +02001922
Vladimir Sementsov-Ogievskiy307261b2021-05-27 18:40:54 +03001923 ro = bdrv_is_read_only(bs);
1924
1925 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, ro)) {
1926 if (!ro && bdrv_is_whitelisted(drv, true)) {
Kevin Wolf018f9de2023-09-29 16:51:53 +02001927 bdrv_graph_rdlock_main_loop();
Kevin Wolf8be25de2019-01-22 13:15:31 +01001928 ret = bdrv_apply_auto_read_only(bs, NULL, NULL);
Kevin Wolf018f9de2023-09-29 16:51:53 +02001929 bdrv_graph_rdunlock_main_loop();
Kevin Wolf8be25de2019-01-22 13:15:31 +01001930 } else {
1931 ret = -ENOTSUP;
1932 }
1933 if (ret < 0) {
1934 error_setg(errp,
Vladimir Sementsov-Ogievskiy307261b2021-05-27 18:40:54 +03001935 !ro && bdrv_is_whitelisted(drv, true)
Kevin Wolf8be25de2019-01-22 13:15:31 +01001936 ? "Driver '%s' can only be used for read-only devices"
1937 : "Driver '%s' is not whitelisted",
1938 drv->format_name);
1939 goto fail_opts;
1940 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +08001941 }
Kevin Wolf57915332010-04-14 15:24:50 +02001942
Paolo Bonzinid3faa132017-06-05 14:38:50 +02001943 /* bdrv_new() and bdrv_close() make it so */
Stefan Hajnoczid73415a2020-09-23 11:56:46 +01001944 assert(qatomic_read(&bs->copy_on_read) == 0);
Paolo Bonzinid3faa132017-06-05 14:38:50 +02001945
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001946 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
Vladimir Sementsov-Ogievskiy307261b2021-05-27 18:40:54 +03001947 if (!ro) {
Kevin Wolf0ebd24e2013-09-19 15:12:18 +02001948 bdrv_enable_copy_on_read(bs);
1949 } else {
1950 error_setg(errp, "Can't use copy-on-read on read-only device");
Kevin Wolf18edf282015-04-07 17:12:56 +02001951 ret = -EINVAL;
1952 goto fail_opts;
Kevin Wolf0ebd24e2013-09-19 15:12:18 +02001953 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001954 }
1955
Alberto Garcia415bbca2018-10-03 13:23:13 +03001956 discard = qemu_opt_get(opts, BDRV_OPT_DISCARD);
Kevin Wolf818584a2016-09-12 18:03:18 +02001957 if (discard != NULL) {
1958 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
1959 error_setg(errp, "Invalid discard option");
1960 ret = -EINVAL;
1961 goto fail_opts;
1962 }
1963 }
1964
Alberto Garcia543770b2018-09-06 12:37:09 +03001965 bs->detect_zeroes =
1966 bdrv_parse_detect_zeroes(opts, bs->open_flags, &local_err);
1967 if (local_err) {
1968 error_propagate(errp, local_err);
1969 ret = -EINVAL;
1970 goto fail_opts;
Kevin Wolf692e01a2016-09-12 21:00:41 +02001971 }
1972
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001973 if (filename != NULL) {
1974 pstrcpy(bs->filename, sizeof(bs->filename), filename);
1975 } else {
1976 bs->filename[0] = '\0';
1977 }
Max Reitz91af7012014-07-18 20:24:56 +02001978 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
Kevin Wolf57915332010-04-14 15:24:50 +02001979
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001980 /* Open the image, either directly or using a protocol */
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001981 open_flags = bdrv_open_flags(bs, bs->open_flags);
Kevin Wolf01a56502017-01-18 15:51:56 +01001982 node_name = qemu_opt_get(opts, "node-name");
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001983
Paolo Bonzini41770f62022-11-24 16:21:18 +01001984 assert(!drv->protocol_name || file == NULL);
Kevin Wolf01a56502017-01-18 15:51:56 +01001985 ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
Kevin Wolf57915332010-04-14 15:24:50 +02001986 if (ret < 0) {
Kevin Wolf01a56502017-01-18 15:51:56 +01001987 goto fail_opts;
Kevin Wolf57915332010-04-14 15:24:50 +02001988 }
1989
Kevin Wolf18edf282015-04-07 17:12:56 +02001990 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +02001991 return 0;
1992
Kevin Wolf18edf282015-04-07 17:12:56 +02001993fail_opts:
1994 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +02001995 return ret;
1996}
1997
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001998static QDict *parse_json_filename(const char *filename, Error **errp)
1999{
Zhao Liu7b22e052024-03-11 11:37:56 +08002000 ERRP_GUARD();
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02002001 QObject *options_obj;
2002 QDict *options;
2003 int ret;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05002004 GLOBAL_STATE_CODE();
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02002005
2006 ret = strstart(filename, "json:", &filename);
2007 assert(ret);
2008
Markus Armbruster5577fff2017-02-28 22:26:59 +01002009 options_obj = qobject_from_json(filename, errp);
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02002010 if (!options_obj) {
Markus Armbruster5577fff2017-02-28 22:26:59 +01002011 error_prepend(errp, "Could not parse the JSON options: ");
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02002012 return NULL;
2013 }
2014
Max Reitz7dc847e2018-02-24 16:40:29 +01002015 options = qobject_to(QDict, options_obj);
Markus Armbrusterca6b6e12017-02-17 21:38:18 +01002016 if (!options) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02002017 qobject_unref(options_obj);
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02002018 error_setg(errp, "Invalid JSON object given");
2019 return NULL;
2020 }
2021
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02002022 qdict_flatten(options);
2023
2024 return options;
2025}
2026
Kevin Wolfde3b53f2015-10-29 15:24:41 +01002027static void parse_json_protocol(QDict *options, const char **pfilename,
2028 Error **errp)
2029{
2030 QDict *json_options;
2031 Error *local_err = NULL;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05002032 GLOBAL_STATE_CODE();
Kevin Wolfde3b53f2015-10-29 15:24:41 +01002033
2034 /* Parse json: pseudo-protocol */
2035 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
2036 return;
2037 }
2038
2039 json_options = parse_json_filename(*pfilename, &local_err);
2040 if (local_err) {
2041 error_propagate(errp, local_err);
2042 return;
2043 }
2044
2045 /* Options given in the filename have lower priority than options
2046 * specified directly */
2047 qdict_join(options, json_options, false);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02002048 qobject_unref(json_options);
Kevin Wolfde3b53f2015-10-29 15:24:41 +01002049 *pfilename = NULL;
2050}
2051
Kevin Wolf57915332010-04-14 15:24:50 +02002052/*
Kevin Wolff54120f2014-05-26 11:09:59 +02002053 * Fills in default options for opening images and converts the legacy
2054 * filename/flags pair to option QDict entries.
Max Reitz53a29512015-03-19 14:53:16 -04002055 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
2056 * block driver has been specified explicitly.
Kevin Wolff54120f2014-05-26 11:09:59 +02002057 */
Kevin Wolfde3b53f2015-10-29 15:24:41 +01002058static int bdrv_fill_options(QDict **options, const char *filename,
Kevin Wolf7ead9462024-04-25 14:56:02 +02002059 int *flags, bool allow_parse_filename,
2060 Error **errp)
Kevin Wolff54120f2014-05-26 11:09:59 +02002061{
2062 const char *drvname;
Max Reitz53a29512015-03-19 14:53:16 -04002063 bool protocol = *flags & BDRV_O_PROTOCOL;
Kevin Wolff54120f2014-05-26 11:09:59 +02002064 bool parse_filename = false;
Max Reitz053e1572015-08-26 19:47:51 +02002065 BlockDriver *drv = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02002066 Error *local_err = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02002067
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05002068 GLOBAL_STATE_CODE();
2069
Markus Armbruster129c7d12017-03-30 19:43:12 +02002070 /*
2071 * Caution: while qdict_get_try_str() is fine, getting non-string
2072 * types would require more care. When @options come from
2073 * -blockdev or blockdev_add, its members are typed according to
2074 * the QAPI schema, but when they come from -drive, they're all
2075 * QString.
2076 */
Max Reitz53a29512015-03-19 14:53:16 -04002077 drvname = qdict_get_try_str(*options, "driver");
Max Reitz053e1572015-08-26 19:47:51 +02002078 if (drvname) {
2079 drv = bdrv_find_format(drvname);
2080 if (!drv) {
2081 error_setg(errp, "Unknown driver '%s'", drvname);
2082 return -ENOENT;
2083 }
2084 /* If the user has explicitly specified the driver, this choice should
2085 * override the BDRV_O_PROTOCOL flag */
Paolo Bonzini41770f62022-11-24 16:21:18 +01002086 protocol = drv->protocol_name;
Max Reitz53a29512015-03-19 14:53:16 -04002087 }
2088
2089 if (protocol) {
2090 *flags |= BDRV_O_PROTOCOL;
2091 } else {
2092 *flags &= ~BDRV_O_PROTOCOL;
2093 }
2094
Kevin Wolf91a097e2015-05-08 17:49:53 +02002095 /* Translate cache options from flags into options */
2096 update_options_from_flags(*options, *flags);
2097
Kevin Wolff54120f2014-05-26 11:09:59 +02002098 /* Fetch the file name from the options QDict if necessary */
Kevin Wolf17b005f2014-05-27 10:50:29 +02002099 if (protocol && filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02002100 if (!qdict_haskey(*options, "filename")) {
Eric Blake46f5ac22017-04-27 16:58:17 -05002101 qdict_put_str(*options, "filename", filename);
Kevin Wolf7ead9462024-04-25 14:56:02 +02002102 parse_filename = allow_parse_filename;
Kevin Wolff54120f2014-05-26 11:09:59 +02002103 } else {
2104 error_setg(errp, "Can't specify 'file' and 'filename' options at "
2105 "the same time");
2106 return -EINVAL;
2107 }
2108 }
2109
2110 /* Find the right block driver */
Markus Armbruster129c7d12017-03-30 19:43:12 +02002111 /* See cautionary note on accessing @options above */
Kevin Wolff54120f2014-05-26 11:09:59 +02002112 filename = qdict_get_try_str(*options, "filename");
Kevin Wolff54120f2014-05-26 11:09:59 +02002113
Max Reitz053e1572015-08-26 19:47:51 +02002114 if (!drvname && protocol) {
2115 if (filename) {
2116 drv = bdrv_find_protocol(filename, parse_filename, errp);
2117 if (!drv) {
Kevin Wolff54120f2014-05-26 11:09:59 +02002118 return -EINVAL;
2119 }
Max Reitz053e1572015-08-26 19:47:51 +02002120
2121 drvname = drv->format_name;
Eric Blake46f5ac22017-04-27 16:58:17 -05002122 qdict_put_str(*options, "driver", drvname);
Max Reitz053e1572015-08-26 19:47:51 +02002123 } else {
2124 error_setg(errp, "Must specify either driver or file");
2125 return -EINVAL;
Kevin Wolff54120f2014-05-26 11:09:59 +02002126 }
2127 }
2128
Kevin Wolf17b005f2014-05-27 10:50:29 +02002129 assert(drv || !protocol);
Kevin Wolff54120f2014-05-26 11:09:59 +02002130
2131 /* Driver-specific filename parsing */
Kevin Wolf17b005f2014-05-27 10:50:29 +02002132 if (drv && drv->bdrv_parse_filename && parse_filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02002133 drv->bdrv_parse_filename(filename, *options, &local_err);
2134 if (local_err) {
2135 error_propagate(errp, local_err);
2136 return -EINVAL;
2137 }
2138
2139 if (!drv->bdrv_needs_filename) {
2140 qdict_del(*options, "filename");
2141 }
2142 }
2143
2144 return 0;
2145}
2146
Kevin Wolf148eb132017-09-14 14:32:04 +02002147typedef struct BlockReopenQueueEntry {
2148 bool prepared;
2149 BDRVReopenState state;
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03002150 QTAILQ_ENTRY(BlockReopenQueueEntry) entry;
Kevin Wolf148eb132017-09-14 14:32:04 +02002151} BlockReopenQueueEntry;
2152
2153/*
2154 * Return the flags that @bs will have after the reopens in @q have
2155 * successfully completed. If @q is NULL (or @bs is not contained in @q),
2156 * return the current flags.
2157 */
2158static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs)
2159{
2160 BlockReopenQueueEntry *entry;
2161
2162 if (q != NULL) {
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03002163 QTAILQ_FOREACH(entry, q, entry) {
Kevin Wolf148eb132017-09-14 14:32:04 +02002164 if (entry->state.bs == bs) {
2165 return entry->state.flags;
2166 }
2167 }
2168 }
2169
2170 return bs->open_flags;
2171}
2172
2173/* Returns whether the image file can be written to after the reopen queue @q
2174 * has been successfully applied, or right now if @q is NULL. */
Max Reitzcc022142018-06-06 21:37:00 +02002175static bool bdrv_is_writable_after_reopen(BlockDriverState *bs,
2176 BlockReopenQueue *q)
Kevin Wolf148eb132017-09-14 14:32:04 +02002177{
2178 int flags = bdrv_reopen_get_flags(q, bs);
2179
2180 return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR;
2181}
2182
Max Reitzcc022142018-06-06 21:37:00 +02002183/*
2184 * Return whether the BDS can be written to. This is not necessarily
2185 * the same as !bdrv_is_read_only(bs), as inactivated images may not
2186 * be written to but do not count as read-only images.
2187 */
2188bool bdrv_is_writable(BlockDriverState *bs)
2189{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05002190 IO_CODE();
Max Reitzcc022142018-06-06 21:37:00 +02002191 return bdrv_is_writable_after_reopen(bs, NULL);
2192}
2193
Vladimir Sementsov-Ogievskiy3bf416b2021-04-28 18:17:37 +03002194static char *bdrv_child_user_desc(BdrvChild *c)
2195{
Emanuele Giuseppe Espositof0c28322022-03-03 10:16:13 -05002196 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiyda261b62021-06-01 10:52:17 +03002197 return c->klass->get_parent_desc(c);
Vladimir Sementsov-Ogievskiy3bf416b2021-04-28 18:17:37 +03002198}
2199
Vladimir Sementsov-Ogievskiy30ebb9a2021-06-01 10:52:18 +03002200/*
2201 * Check that @a allows everything that @b needs. @a and @b must reference same
2202 * child node.
2203 */
Vladimir Sementsov-Ogievskiy3bf416b2021-04-28 18:17:37 +03002204static bool bdrv_a_allow_b(BdrvChild *a, BdrvChild *b, Error **errp)
2205{
Vladimir Sementsov-Ogievskiy30ebb9a2021-06-01 10:52:18 +03002206 const char *child_bs_name;
2207 g_autofree char *a_user = NULL;
2208 g_autofree char *b_user = NULL;
2209 g_autofree char *perms = NULL;
2210
2211 assert(a->bs);
2212 assert(a->bs == b->bs);
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002213 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy3bf416b2021-04-28 18:17:37 +03002214
2215 if ((b->perm & a->shared_perm) == b->perm) {
2216 return true;
2217 }
2218
Vladimir Sementsov-Ogievskiy30ebb9a2021-06-01 10:52:18 +03002219 child_bs_name = bdrv_get_node_name(b->bs);
2220 a_user = bdrv_child_user_desc(a);
2221 b_user = bdrv_child_user_desc(b);
2222 perms = bdrv_perm_names(b->perm & ~a->shared_perm);
2223
2224 error_setg(errp, "Permission conflict on node '%s': permissions '%s' are "
2225 "both required by %s (uses node '%s' as '%s' child) and "
2226 "unshared by %s (uses node '%s' as '%s' child).",
2227 child_bs_name, perms,
2228 b_user, child_bs_name, b->name,
2229 a_user, child_bs_name, a->name);
Vladimir Sementsov-Ogievskiy3bf416b2021-04-28 18:17:37 +03002230
2231 return false;
2232}
2233
Kevin Wolf3804e3c2023-09-11 11:46:12 +02002234static bool GRAPH_RDLOCK
2235bdrv_parent_perms_conflict(BlockDriverState *bs, Error **errp)
Vladimir Sementsov-Ogievskiy3bf416b2021-04-28 18:17:37 +03002236{
2237 BdrvChild *a, *b;
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002238 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy3bf416b2021-04-28 18:17:37 +03002239
2240 /*
2241 * During the loop we'll look at each pair twice. That's correct because
2242 * bdrv_a_allow_b() is asymmetric and we should check each pair in both
2243 * directions.
2244 */
2245 QLIST_FOREACH(a, &bs->parents, next_parent) {
2246 QLIST_FOREACH(b, &bs->parents, next_parent) {
Vladimir Sementsov-Ogievskiy9397c142021-04-28 18:17:53 +03002247 if (a == b) {
Vladimir Sementsov-Ogievskiy3bf416b2021-04-28 18:17:37 +03002248 continue;
2249 }
2250
2251 if (!bdrv_a_allow_b(a, b, errp)) {
2252 return true;
2253 }
2254 }
2255 }
2256
2257 return false;
2258}
2259
Kevin Wolfc629b6d2023-09-11 11:46:14 +02002260static void GRAPH_RDLOCK
2261bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
2262 BdrvChild *c, BdrvChildRole role,
2263 BlockReopenQueue *reopen_queue,
2264 uint64_t parent_perm, uint64_t parent_shared,
2265 uint64_t *nperm, uint64_t *nshared)
Fam Zhengffd1a5a2017-05-03 00:35:38 +08002266{
Alberto Garcia0b3ca762019-04-04 14:29:53 +03002267 assert(bs->drv && bs->drv->bdrv_child_perm);
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05002268 GLOBAL_STATE_CODE();
Max Reitze5d8a402020-05-13 13:05:44 +02002269 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
Alberto Garcia0b3ca762019-04-04 14:29:53 +03002270 parent_perm, parent_shared,
2271 nperm, nshared);
Kevin Wolfe0995dc2017-09-14 12:47:11 +02002272 /* TODO Take force_share from reopen_queue */
Fam Zhengffd1a5a2017-05-03 00:35:38 +08002273 if (child_bs && child_bs->force_share) {
2274 *nshared = BLK_PERM_ALL;
2275 }
2276}
2277
Vladimir Sementsov-Ogievskiybd57f8f2021-04-28 18:17:41 +03002278/*
2279 * Adds the whole subtree of @bs (including @bs itself) to the @list (except for
2280 * nodes that are already in the @list, of course) so that final list is
2281 * topologically sorted. Return the result (GSList @list object is updated, so
2282 * don't use old reference after function call).
2283 *
2284 * On function start @list must be already topologically sorted and for any node
2285 * in the @list the whole subtree of the node must be in the @list as well. The
2286 * simplest way to satisfy this criteria: use only result of
2287 * bdrv_topological_dfs() or NULL as @list parameter.
2288 */
Kevin Wolf3804e3c2023-09-11 11:46:12 +02002289static GSList * GRAPH_RDLOCK
2290bdrv_topological_dfs(GSList *list, GHashTable *found, BlockDriverState *bs)
Vladimir Sementsov-Ogievskiybd57f8f2021-04-28 18:17:41 +03002291{
2292 BdrvChild *child;
2293 g_autoptr(GHashTable) local_found = NULL;
2294
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05002295 GLOBAL_STATE_CODE();
2296
Vladimir Sementsov-Ogievskiybd57f8f2021-04-28 18:17:41 +03002297 if (!found) {
2298 assert(!list);
2299 found = local_found = g_hash_table_new(NULL, NULL);
2300 }
2301
2302 if (g_hash_table_contains(found, bs)) {
2303 return list;
2304 }
2305 g_hash_table_add(found, bs);
2306
2307 QLIST_FOREACH(child, &bs->children, next) {
2308 list = bdrv_topological_dfs(list, found, child->bs);
2309 }
2310
2311 return g_slist_prepend(list, bs);
2312}
2313
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002314typedef struct BdrvChildSetPermState {
2315 BdrvChild *child;
2316 uint64_t old_perm;
2317 uint64_t old_shared_perm;
2318} BdrvChildSetPermState;
Vladimir Sementsov-Ogievskiyb0defa82021-04-28 18:17:38 +03002319
2320static void bdrv_child_set_perm_abort(void *opaque)
2321{
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002322 BdrvChildSetPermState *s = opaque;
2323
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002324 GLOBAL_STATE_CODE();
2325
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002326 s->child->perm = s->old_perm;
2327 s->child->shared_perm = s->old_shared_perm;
Vladimir Sementsov-Ogievskiyb0defa82021-04-28 18:17:38 +03002328}
2329
2330static TransactionActionDrv bdrv_child_set_pem_drv = {
2331 .abort = bdrv_child_set_perm_abort,
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002332 .clean = g_free,
Vladimir Sementsov-Ogievskiyb0defa82021-04-28 18:17:38 +03002333};
2334
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002335static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm,
2336 uint64_t shared, Transaction *tran)
Vladimir Sementsov-Ogievskiyb0defa82021-04-28 18:17:38 +03002337{
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002338 BdrvChildSetPermState *s = g_new(BdrvChildSetPermState, 1);
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002339 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002340
2341 *s = (BdrvChildSetPermState) {
2342 .child = c,
2343 .old_perm = c->perm,
2344 .old_shared_perm = c->shared_perm,
2345 };
Vladimir Sementsov-Ogievskiyb0defa82021-04-28 18:17:38 +03002346
2347 c->perm = perm;
2348 c->shared_perm = shared;
2349
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002350 tran_add(tran, &bdrv_child_set_pem_drv, s);
Vladimir Sementsov-Ogievskiyb0defa82021-04-28 18:17:38 +03002351}
2352
Kevin Wolfbce73bc2023-09-11 11:46:13 +02002353static void GRAPH_RDLOCK bdrv_drv_set_perm_commit(void *opaque)
Vladimir Sementsov-Ogievskiy2513ef52021-04-28 18:17:42 +03002354{
2355 BlockDriverState *bs = opaque;
2356 uint64_t cumulative_perms, cumulative_shared_perms;
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05002357 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy2513ef52021-04-28 18:17:42 +03002358
2359 if (bs->drv->bdrv_set_perm) {
2360 bdrv_get_cumulative_perm(bs, &cumulative_perms,
2361 &cumulative_shared_perms);
2362 bs->drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);
2363 }
2364}
2365
Kevin Wolfbce73bc2023-09-11 11:46:13 +02002366static void GRAPH_RDLOCK bdrv_drv_set_perm_abort(void *opaque)
Vladimir Sementsov-Ogievskiy2513ef52021-04-28 18:17:42 +03002367{
2368 BlockDriverState *bs = opaque;
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05002369 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy2513ef52021-04-28 18:17:42 +03002370
2371 if (bs->drv->bdrv_abort_perm_update) {
2372 bs->drv->bdrv_abort_perm_update(bs);
2373 }
2374}
2375
2376TransactionActionDrv bdrv_drv_set_perm_drv = {
2377 .abort = bdrv_drv_set_perm_abort,
2378 .commit = bdrv_drv_set_perm_commit,
2379};
2380
Kevin Wolfbce73bc2023-09-11 11:46:13 +02002381/*
2382 * After calling this function, the transaction @tran may only be completed
2383 * while holding a reader lock for the graph.
2384 */
2385static int GRAPH_RDLOCK
2386bdrv_drv_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared_perm,
2387 Transaction *tran, Error **errp)
Vladimir Sementsov-Ogievskiy2513ef52021-04-28 18:17:42 +03002388{
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05002389 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy2513ef52021-04-28 18:17:42 +03002390 if (!bs->drv) {
2391 return 0;
2392 }
2393
2394 if (bs->drv->bdrv_check_perm) {
2395 int ret = bs->drv->bdrv_check_perm(bs, perm, shared_perm, errp);
2396 if (ret < 0) {
2397 return ret;
2398 }
2399 }
2400
2401 if (tran) {
2402 tran_add(tran, &bdrv_drv_set_perm_drv, bs);
2403 }
2404
2405 return 0;
2406}
2407
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002408typedef struct BdrvReplaceChildState {
2409 BdrvChild *child;
2410 BlockDriverState *old_bs;
2411} BdrvReplaceChildState;
2412
Kevin Wolf5661a002023-09-11 11:46:10 +02002413static void GRAPH_WRLOCK bdrv_replace_child_commit(void *opaque)
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002414{
2415 BdrvReplaceChildState *s = opaque;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05002416 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002417
Kevin Wolf5661a002023-09-11 11:46:10 +02002418 bdrv_schedule_unref(s->old_bs);
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002419}
2420
Kevin Wolf5661a002023-09-11 11:46:10 +02002421static void GRAPH_WRLOCK bdrv_replace_child_abort(void *opaque)
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002422{
2423 BdrvReplaceChildState *s = opaque;
2424 BlockDriverState *new_bs = s->child->bs;
2425
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05002426 GLOBAL_STATE_CODE();
Kevin Wolf5661a002023-09-11 11:46:10 +02002427 assert_bdrv_graph_writable();
Kevin Wolfad29eb32023-09-11 11:46:07 +02002428
Vladimir Sementsov-Ogievskiy0f0b1e22022-07-26 23:11:29 +03002429 /* old_bs reference is transparently moved from @s to @s->child */
Kevin Wolf23987472022-11-18 18:41:09 +01002430 if (!s->child->bs) {
2431 /*
2432 * The parents were undrained when removing old_bs from the child. New
2433 * requests can't have been made, though, because the child was empty.
2434 *
2435 * TODO Make bdrv_replace_child_noperm() transactionable to avoid
2436 * undraining the parent in the first place. Once this is done, having
2437 * new_bs drained when calling bdrv_replace_child_tran() is not a
2438 * requirement any more.
2439 */
Kevin Wolf606ed752022-11-18 18:41:10 +01002440 bdrv_parent_drained_begin_single(s->child);
Kevin Wolf23987472022-11-18 18:41:09 +01002441 assert(!bdrv_parent_drained_poll_single(s->child));
2442 }
2443 assert(s->child->quiesced_parent);
Vladimir Sementsov-Ogievskiy544acc72022-07-26 23:11:31 +03002444 bdrv_replace_child_noperm(s->child, s->old_bs);
Kevin Wolfad29eb32023-09-11 11:46:07 +02002445
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002446 bdrv_unref(new_bs);
2447}
2448
2449static TransactionActionDrv bdrv_replace_child_drv = {
2450 .commit = bdrv_replace_child_commit,
2451 .abort = bdrv_replace_child_abort,
2452 .clean = g_free,
2453};
2454
2455/*
Vladimir Sementsov-Ogievskiy4bf021d2021-06-10 14:25:44 +03002456 * bdrv_replace_child_tran
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002457 *
2458 * Note: real unref of old_bs is done only on commit.
Vladimir Sementsov-Ogievskiy4bf021d2021-06-10 14:25:44 +03002459 *
Kevin Wolf23987472022-11-18 18:41:09 +01002460 * Both @child->bs and @new_bs (if non-NULL) must be drained. @new_bs must be
2461 * kept drained until the transaction is completed.
2462 *
Kevin Wolf5661a002023-09-11 11:46:10 +02002463 * After calling this function, the transaction @tran may only be completed
2464 * while holding a writer lock for the graph.
2465 *
Vladimir Sementsov-Ogievskiy4bf021d2021-06-10 14:25:44 +03002466 * The function doesn't update permissions, caller is responsible for this.
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002467 */
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02002468static void GRAPH_WRLOCK
2469bdrv_replace_child_tran(BdrvChild *child, BlockDriverState *new_bs,
2470 Transaction *tran)
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002471{
2472 BdrvReplaceChildState *s = g_new(BdrvReplaceChildState, 1);
Kevin Wolf23987472022-11-18 18:41:09 +01002473
2474 assert(child->quiesced_parent);
2475 assert(!new_bs || new_bs->quiesce_counter);
2476
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002477 *s = (BdrvReplaceChildState) {
Vladimir Sementsov-Ogievskiy0f0b1e22022-07-26 23:11:29 +03002478 .child = child,
2479 .old_bs = child->bs,
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002480 };
2481 tran_add(tran, &bdrv_replace_child_drv, s);
2482
2483 if (new_bs) {
2484 bdrv_ref(new_bs);
2485 }
Kevin Wolfad29eb32023-09-11 11:46:07 +02002486
Vladimir Sementsov-Ogievskiy544acc72022-07-26 23:11:31 +03002487 bdrv_replace_child_noperm(child, new_bs);
Vladimir Sementsov-Ogievskiy0f0b1e22022-07-26 23:11:29 +03002488 /* old_bs reference is transparently moved from @child to @s */
Vladimir Sementsov-Ogievskiy09786232021-04-28 18:17:44 +03002489}
2490
Kevin Wolf33a610c2016-12-15 13:04:20 +01002491/*
Vladimir Sementsov-Ogievskiyc20555e2021-04-28 18:18:04 +03002492 * Refresh permissions in @bs subtree. The function is intended to be called
2493 * after some graph modification that was done without permission update.
Kevin Wolfbce73bc2023-09-11 11:46:13 +02002494 *
2495 * After calling this function, the transaction @tran may only be completed
2496 * while holding a reader lock for the graph.
Kevin Wolf33a610c2016-12-15 13:04:20 +01002497 */
Kevin Wolfbce73bc2023-09-11 11:46:13 +02002498static int GRAPH_RDLOCK
2499bdrv_node_refresh_perm(BlockDriverState *bs, BlockReopenQueue *q,
2500 Transaction *tran, Error **errp)
Kevin Wolf33a610c2016-12-15 13:04:20 +01002501{
2502 BlockDriver *drv = bs->drv;
2503 BdrvChild *c;
2504 int ret;
Vladimir Sementsov-Ogievskiyc20555e2021-04-28 18:18:04 +03002505 uint64_t cumulative_perms, cumulative_shared_perms;
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002506 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiyc20555e2021-04-28 18:18:04 +03002507
2508 bdrv_get_cumulative_perm(bs, &cumulative_perms, &cumulative_shared_perms);
Kevin Wolf33a610c2016-12-15 13:04:20 +01002509
2510 /* Write permissions never work with read-only images */
2511 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
Max Reitzcc022142018-06-06 21:37:00 +02002512 !bdrv_is_writable_after_reopen(bs, q))
Kevin Wolf33a610c2016-12-15 13:04:20 +01002513 {
Max Reitz481e0ee2019-05-15 22:15:00 +02002514 if (!bdrv_is_writable_after_reopen(bs, NULL)) {
2515 error_setg(errp, "Block node is read-only");
2516 } else {
Vladimir Sementsov-Ogievskiyc20555e2021-04-28 18:18:04 +03002517 error_setg(errp, "Read-only block node '%s' cannot support "
2518 "read-write users", bdrv_get_node_name(bs));
Max Reitz481e0ee2019-05-15 22:15:00 +02002519 }
2520
Kevin Wolf33a610c2016-12-15 13:04:20 +01002521 return -EPERM;
2522 }
2523
Kevin Wolf9c60a5d2020-07-16 16:26:00 +02002524 /*
2525 * Unaligned requests will automatically be aligned to bl.request_alignment
2526 * and without RESIZE we can't extend requests to write to space beyond the
2527 * end of the image, so it's required that the image size is aligned.
2528 */
2529 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
2530 !(cumulative_perms & BLK_PERM_RESIZE))
2531 {
2532 if ((bs->total_sectors * BDRV_SECTOR_SIZE) % bs->bl.request_alignment) {
2533 error_setg(errp, "Cannot get 'write' permission without 'resize': "
2534 "Image size is not a multiple of request "
2535 "alignment");
2536 return -EPERM;
2537 }
2538 }
2539
Kevin Wolf33a610c2016-12-15 13:04:20 +01002540 /* Check this node */
2541 if (!drv) {
2542 return 0;
2543 }
2544
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002545 ret = bdrv_drv_set_perm(bs, cumulative_perms, cumulative_shared_perms, tran,
Vladimir Sementsov-Ogievskiy2513ef52021-04-28 18:17:42 +03002546 errp);
2547 if (ret < 0) {
2548 return ret;
Kevin Wolf33a610c2016-12-15 13:04:20 +01002549 }
2550
Kevin Wolf78e421c2016-12-20 23:25:12 +01002551 /* Drivers that never have children can omit .bdrv_child_perm() */
Kevin Wolf33a610c2016-12-15 13:04:20 +01002552 if (!drv->bdrv_child_perm) {
Kevin Wolf78e421c2016-12-20 23:25:12 +01002553 assert(QLIST_EMPTY(&bs->children));
Kevin Wolf33a610c2016-12-15 13:04:20 +01002554 return 0;
2555 }
2556
2557 /* Check all children */
2558 QLIST_FOREACH(c, &bs->children, next) {
2559 uint64_t cur_perm, cur_shared;
Max Reitz9eab1542019-05-22 19:03:50 +02002560
Max Reitze5d8a402020-05-13 13:05:44 +02002561 bdrv_child_perm(bs, c->bs, c, c->role, q,
Fam Zhengffd1a5a2017-05-03 00:35:38 +08002562 cumulative_perms, cumulative_shared_perms,
2563 &cur_perm, &cur_shared);
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002564 bdrv_child_set_perm(c, cur_perm, cur_shared, tran);
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002565 }
2566
2567 return 0;
2568}
2569
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03002570/*
2571 * @list is a product of bdrv_topological_dfs() (may be called several times) -
2572 * a topologically sorted subgraph.
Kevin Wolfbce73bc2023-09-11 11:46:13 +02002573 *
2574 * After calling this function, the transaction @tran may only be completed
2575 * while holding a reader lock for the graph.
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03002576 */
Kevin Wolf3804e3c2023-09-11 11:46:12 +02002577static int GRAPH_RDLOCK
2578bdrv_do_refresh_perms(GSList *list, BlockReopenQueue *q, Transaction *tran,
2579 Error **errp)
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002580{
2581 int ret;
2582 BlockDriverState *bs;
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002583 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002584
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002585 for ( ; list; list = list->next) {
2586 bs = list->data;
2587
Vladimir Sementsov-Ogievskiy9397c142021-04-28 18:17:53 +03002588 if (bdrv_parent_perms_conflict(bs, errp)) {
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002589 return -EINVAL;
2590 }
2591
Vladimir Sementsov-Ogievskiyc20555e2021-04-28 18:18:04 +03002592 ret = bdrv_node_refresh_perm(bs, q, tran, errp);
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002593 if (ret < 0) {
2594 return ret;
2595 }
Vladimir Sementsov-Ogievskiybd57f8f2021-04-28 18:17:41 +03002596 }
Vladimir Sementsov-Ogievskiy3ef45e02021-04-28 18:17:40 +03002597
Vladimir Sementsov-Ogievskiybd57f8f2021-04-28 18:17:41 +03002598 return 0;
2599}
2600
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03002601/*
2602 * @list is any list of nodes. List is completed by all subtrees and
2603 * topologically sorted. It's not a problem if some node occurs in the @list
2604 * several times.
Kevin Wolfbce73bc2023-09-11 11:46:13 +02002605 *
2606 * After calling this function, the transaction @tran may only be completed
2607 * while holding a reader lock for the graph.
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03002608 */
Kevin Wolf3804e3c2023-09-11 11:46:12 +02002609static int GRAPH_RDLOCK
2610bdrv_list_refresh_perms(GSList *list, BlockReopenQueue *q, Transaction *tran,
2611 Error **errp)
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03002612{
2613 g_autoptr(GHashTable) found = g_hash_table_new(NULL, NULL);
2614 g_autoptr(GSList) refresh_list = NULL;
2615
2616 for ( ; list; list = list->next) {
2617 refresh_list = bdrv_topological_dfs(refresh_list, found, list->data);
2618 }
2619
2620 return bdrv_do_refresh_perms(refresh_list, q, tran, errp);
2621}
2622
Kevin Wolfc7a0f2b2020-03-10 12:38:25 +01002623void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
2624 uint64_t *shared_perm)
Kevin Wolf33a610c2016-12-15 13:04:20 +01002625{
2626 BdrvChild *c;
2627 uint64_t cumulative_perms = 0;
2628 uint64_t cumulative_shared_perms = BLK_PERM_ALL;
2629
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -05002630 GLOBAL_STATE_CODE();
2631
Kevin Wolf33a610c2016-12-15 13:04:20 +01002632 QLIST_FOREACH(c, &bs->parents, next_parent) {
2633 cumulative_perms |= c->perm;
2634 cumulative_shared_perms &= c->shared_perm;
2635 }
2636
2637 *perm = cumulative_perms;
2638 *shared_perm = cumulative_shared_perms;
2639}
2640
Fam Zheng51761962017-05-03 00:35:36 +08002641char *bdrv_perm_names(uint64_t perm)
Kevin Wolfd0833192017-01-16 18:26:20 +01002642{
2643 struct perm_name {
2644 uint64_t perm;
2645 const char *name;
2646 } permissions[] = {
2647 { BLK_PERM_CONSISTENT_READ, "consistent read" },
2648 { BLK_PERM_WRITE, "write" },
2649 { BLK_PERM_WRITE_UNCHANGED, "write unchanged" },
2650 { BLK_PERM_RESIZE, "resize" },
Kevin Wolfd0833192017-01-16 18:26:20 +01002651 { 0, NULL }
2652 };
2653
Alberto Garciae2a74232020-01-10 18:15:18 +01002654 GString *result = g_string_sized_new(30);
Kevin Wolfd0833192017-01-16 18:26:20 +01002655 struct perm_name *p;
2656
2657 for (p = permissions; p->name; p++) {
2658 if (perm & p->perm) {
Alberto Garciae2a74232020-01-10 18:15:18 +01002659 if (result->len > 0) {
2660 g_string_append(result, ", ");
2661 }
2662 g_string_append(result, p->name);
Kevin Wolfd0833192017-01-16 18:26:20 +01002663 }
2664 }
2665
Alberto Garciae2a74232020-01-10 18:15:18 +01002666 return g_string_free(result, FALSE);
Kevin Wolfd0833192017-01-16 18:26:20 +01002667}
2668
Kevin Wolf33a610c2016-12-15 13:04:20 +01002669
Kevin Wolfbce73bc2023-09-11 11:46:13 +02002670/*
2671 * @tran is allowed to be NULL. In this case no rollback is possible.
2672 *
2673 * After calling this function, the transaction @tran may only be completed
2674 * while holding a reader lock for the graph.
2675 */
Kevin Wolf3804e3c2023-09-11 11:46:12 +02002676static int GRAPH_RDLOCK
2677bdrv_refresh_perms(BlockDriverState *bs, Transaction *tran, Error **errp)
Vladimir Sementsov-Ogievskiybb87e4d2020-11-06 15:42:38 +03002678{
2679 int ret;
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03002680 Transaction *local_tran = NULL;
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002681 g_autoptr(GSList) list = bdrv_topological_dfs(NULL, NULL, bs);
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002682 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiybb87e4d2020-11-06 15:42:38 +03002683
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03002684 if (!tran) {
2685 tran = local_tran = tran_new();
2686 }
2687
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03002688 ret = bdrv_do_refresh_perms(list, NULL, tran, errp);
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03002689
2690 if (local_tran) {
2691 tran_finalize(local_tran, ret);
2692 }
Vladimir Sementsov-Ogievskiybb87e4d2020-11-06 15:42:38 +03002693
Vladimir Sementsov-Ogievskiyb1d2bbe2021-04-28 18:17:43 +03002694 return ret;
Vladimir Sementsov-Ogievskiybb87e4d2020-11-06 15:42:38 +03002695}
2696
Kevin Wolf33a610c2016-12-15 13:04:20 +01002697int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
2698 Error **errp)
2699{
Max Reitz10467792019-05-22 19:03:51 +02002700 Error *local_err = NULL;
Vladimir Sementsov-Ogievskiy83928dc2021-04-28 18:17:39 +03002701 Transaction *tran = tran_new();
Kevin Wolf33a610c2016-12-15 13:04:20 +01002702 int ret;
2703
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -05002704 GLOBAL_STATE_CODE();
2705
Vladimir Sementsov-Ogievskiyecb776b2021-04-28 18:18:02 +03002706 bdrv_child_set_perm(c, perm, shared, tran);
Vladimir Sementsov-Ogievskiy83928dc2021-04-28 18:17:39 +03002707
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03002708 ret = bdrv_refresh_perms(c->bs, tran, &local_err);
Vladimir Sementsov-Ogievskiy83928dc2021-04-28 18:17:39 +03002709
2710 tran_finalize(tran, ret);
2711
Kevin Wolf33a610c2016-12-15 13:04:20 +01002712 if (ret < 0) {
Vladimir Sementsov-Ogievskiy071b4742020-11-06 15:42:41 +03002713 if ((perm & ~c->perm) || (c->shared_perm & ~shared)) {
2714 /* tighten permissions */
Max Reitz10467792019-05-22 19:03:51 +02002715 error_propagate(errp, local_err);
2716 } else {
2717 /*
2718 * Our caller may intend to only loosen restrictions and
2719 * does not expect this function to fail. Errors are not
2720 * fatal in such a case, so we can just hide them from our
2721 * caller.
2722 */
2723 error_free(local_err);
2724 ret = 0;
2725 }
Kevin Wolf33a610c2016-12-15 13:04:20 +01002726 }
2727
Vladimir Sementsov-Ogievskiy83928dc2021-04-28 18:17:39 +03002728 return ret;
Kevin Wolfd5e6f432016-12-14 17:24:36 +01002729}
2730
Max Reitzc1087f12019-05-22 19:03:46 +02002731int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
2732{
2733 uint64_t parent_perms, parent_shared;
2734 uint64_t perms, shared;
2735
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -05002736 GLOBAL_STATE_CODE();
2737
Max Reitzc1087f12019-05-22 19:03:46 +02002738 bdrv_get_cumulative_perm(bs, &parent_perms, &parent_shared);
Max Reitze5d8a402020-05-13 13:05:44 +02002739 bdrv_child_perm(bs, c->bs, c, c->role, NULL,
Max Reitzbf8e9252020-05-13 13:05:16 +02002740 parent_perms, parent_shared, &perms, &shared);
Max Reitzc1087f12019-05-22 19:03:46 +02002741
2742 return bdrv_child_try_set_perm(c, perms, shared, errp);
2743}
2744
Max Reitz87278af2020-05-13 13:05:40 +02002745/*
2746 * Default implementation for .bdrv_child_perm() for block filters:
2747 * Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED, and RESIZE to the
2748 * filtered child.
2749 */
2750static void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
Max Reitz87278af2020-05-13 13:05:40 +02002751 BdrvChildRole role,
2752 BlockReopenQueue *reopen_queue,
2753 uint64_t perm, uint64_t shared,
2754 uint64_t *nperm, uint64_t *nshared)
Kevin Wolf6a1b9ee2016-12-15 11:27:32 +01002755{
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002756 GLOBAL_STATE_CODE();
Kevin Wolfe444fa82019-08-02 15:59:41 +02002757 *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
2758 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
Kevin Wolf6a1b9ee2016-12-15 11:27:32 +01002759}
2760
Max Reitz70082db2020-05-13 13:05:26 +02002761static void bdrv_default_perms_for_cow(BlockDriverState *bs, BdrvChild *c,
Max Reitz70082db2020-05-13 13:05:26 +02002762 BdrvChildRole role,
2763 BlockReopenQueue *reopen_queue,
2764 uint64_t perm, uint64_t shared,
2765 uint64_t *nperm, uint64_t *nshared)
2766{
Max Reitze5d8a402020-05-13 13:05:44 +02002767 assert(role & BDRV_CHILD_COW);
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002768 GLOBAL_STATE_CODE();
Max Reitz70082db2020-05-13 13:05:26 +02002769
2770 /*
2771 * We want consistent read from backing files if the parent needs it.
2772 * No other operations are performed on backing files.
2773 */
2774 perm &= BLK_PERM_CONSISTENT_READ;
2775
2776 /*
2777 * If the parent can deal with changing data, we're okay with a
2778 * writable and resizable backing file.
2779 * TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too?
2780 */
2781 if (shared & BLK_PERM_WRITE) {
2782 shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2783 } else {
2784 shared = 0;
2785 }
2786
Vladimir Sementsov-Ogievskiy64631f32021-09-02 12:37:54 +03002787 shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
Max Reitz70082db2020-05-13 13:05:26 +02002788
2789 if (bs->open_flags & BDRV_O_INACTIVE) {
2790 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2791 }
2792
2793 *nperm = perm;
2794 *nshared = shared;
2795}
2796
Max Reitz6f838a42020-05-13 13:05:27 +02002797static void bdrv_default_perms_for_storage(BlockDriverState *bs, BdrvChild *c,
Max Reitz6f838a42020-05-13 13:05:27 +02002798 BdrvChildRole role,
2799 BlockReopenQueue *reopen_queue,
2800 uint64_t perm, uint64_t shared,
2801 uint64_t *nperm, uint64_t *nshared)
2802{
2803 int flags;
2804
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05002805 GLOBAL_STATE_CODE();
Max Reitze5d8a402020-05-13 13:05:44 +02002806 assert(role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA));
Max Reitz6f838a42020-05-13 13:05:27 +02002807
2808 flags = bdrv_reopen_get_flags(reopen_queue, bs);
2809
2810 /*
2811 * Apart from the modifications below, the same permissions are
2812 * forwarded and left alone as for filters
2813 */
Max Reitze5d8a402020-05-13 13:05:44 +02002814 bdrv_filter_default_perms(bs, c, role, reopen_queue,
Max Reitz6f838a42020-05-13 13:05:27 +02002815 perm, shared, &perm, &shared);
2816
Max Reitzf8890542020-05-13 13:05:28 +02002817 if (role & BDRV_CHILD_METADATA) {
2818 /* Format drivers may touch metadata even if the guest doesn't write */
2819 if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
2820 perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2821 }
2822
2823 /*
2824 * bs->file always needs to be consistent because of the
2825 * metadata. We can never allow other users to resize or write
2826 * to it.
2827 */
2828 if (!(flags & BDRV_O_NO_IO)) {
2829 perm |= BLK_PERM_CONSISTENT_READ;
2830 }
2831 shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
Max Reitz6f838a42020-05-13 13:05:27 +02002832 }
2833
Max Reitzf8890542020-05-13 13:05:28 +02002834 if (role & BDRV_CHILD_DATA) {
2835 /*
2836 * Technically, everything in this block is a subset of the
2837 * BDRV_CHILD_METADATA path taken above, and so this could
2838 * be an "else if" branch. However, that is not obvious, and
2839 * this function is not performance critical, therefore we let
2840 * this be an independent "if".
2841 */
2842
2843 /*
2844 * We cannot allow other users to resize the file because the
2845 * format driver might have some assumptions about the size
2846 * (e.g. because it is stored in metadata, or because the file
2847 * is split into fixed-size data files).
2848 */
2849 shared &= ~BLK_PERM_RESIZE;
2850
2851 /*
2852 * WRITE_UNCHANGED often cannot be performed as such on the
2853 * data file. For example, the qcow2 driver may still need to
2854 * write copied clusters on copy-on-read.
2855 */
2856 if (perm & BLK_PERM_WRITE_UNCHANGED) {
2857 perm |= BLK_PERM_WRITE;
2858 }
2859
2860 /*
2861 * If the data file is written to, the format driver may
2862 * expect to be able to resize it by writing beyond the EOF.
2863 */
2864 if (perm & BLK_PERM_WRITE) {
2865 perm |= BLK_PERM_RESIZE;
2866 }
Max Reitz6f838a42020-05-13 13:05:27 +02002867 }
Max Reitz6f838a42020-05-13 13:05:27 +02002868
2869 if (bs->open_flags & BDRV_O_INACTIVE) {
2870 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2871 }
2872
2873 *nperm = perm;
2874 *nshared = shared;
2875}
2876
Max Reitz2519f542020-05-13 13:05:29 +02002877void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
Max Reitze5d8a402020-05-13 13:05:44 +02002878 BdrvChildRole role, BlockReopenQueue *reopen_queue,
Max Reitz2519f542020-05-13 13:05:29 +02002879 uint64_t perm, uint64_t shared,
2880 uint64_t *nperm, uint64_t *nshared)
2881{
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -05002882 GLOBAL_STATE_CODE();
Max Reitz2519f542020-05-13 13:05:29 +02002883 if (role & BDRV_CHILD_FILTERED) {
2884 assert(!(role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
2885 BDRV_CHILD_COW)));
Max Reitze5d8a402020-05-13 13:05:44 +02002886 bdrv_filter_default_perms(bs, c, role, reopen_queue,
Max Reitz2519f542020-05-13 13:05:29 +02002887 perm, shared, nperm, nshared);
2888 } else if (role & BDRV_CHILD_COW) {
2889 assert(!(role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA)));
Max Reitze5d8a402020-05-13 13:05:44 +02002890 bdrv_default_perms_for_cow(bs, c, role, reopen_queue,
Max Reitz2519f542020-05-13 13:05:29 +02002891 perm, shared, nperm, nshared);
2892 } else if (role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA)) {
Max Reitze5d8a402020-05-13 13:05:44 +02002893 bdrv_default_perms_for_storage(bs, c, role, reopen_queue,
Max Reitz2519f542020-05-13 13:05:29 +02002894 perm, shared, nperm, nshared);
2895 } else {
2896 g_assert_not_reached();
2897 }
2898}
2899
Max Reitz7b1d9c42019-11-08 13:34:51 +01002900uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)
2901{
2902 static const uint64_t permissions[] = {
2903 [BLOCK_PERMISSION_CONSISTENT_READ] = BLK_PERM_CONSISTENT_READ,
2904 [BLOCK_PERMISSION_WRITE] = BLK_PERM_WRITE,
2905 [BLOCK_PERMISSION_WRITE_UNCHANGED] = BLK_PERM_WRITE_UNCHANGED,
2906 [BLOCK_PERMISSION_RESIZE] = BLK_PERM_RESIZE,
Max Reitz7b1d9c42019-11-08 13:34:51 +01002907 };
2908
2909 QEMU_BUILD_BUG_ON(ARRAY_SIZE(permissions) != BLOCK_PERMISSION__MAX);
2910 QEMU_BUILD_BUG_ON(1UL << ARRAY_SIZE(permissions) != BLK_PERM_ALL + 1);
2911
2912 assert(qapi_perm < BLOCK_PERMISSION__MAX);
2913
2914 return permissions[qapi_perm];
2915}
2916
Kevin Wolf23987472022-11-18 18:41:09 +01002917/*
2918 * Replaces the node that a BdrvChild points to without updating permissions.
2919 *
2920 * If @new_bs is non-NULL, the parent of @child must already be drained through
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05002921 * @child.
Kevin Wolf23987472022-11-18 18:41:09 +01002922 */
Kevin Wolfad29eb32023-09-11 11:46:07 +02002923static void GRAPH_WRLOCK
2924bdrv_replace_child_noperm(BdrvChild *child, BlockDriverState *new_bs)
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002925{
2926 BlockDriverState *old_bs = child->bs;
Max Reitzdebc2922019-07-22 15:33:44 +02002927 int new_bs_quiesce_counter;
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002928
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02002929 assert(!child->frozen);
Kevin Wolf23987472022-11-18 18:41:09 +01002930
2931 /*
2932 * If we want to change the BdrvChild to point to a drained node as its new
2933 * child->bs, we need to make sure that its new parent is drained, too. In
2934 * other words, either child->quiesce_parent must already be true or we must
2935 * be able to set it and keep the parent's quiesce_counter consistent with
2936 * that, but without polling or starting new requests (this function
2937 * guarantees that it doesn't poll, and starting new requests would be
2938 * against the invariants of drain sections).
2939 *
2940 * To keep things simple, we pick the first option (child->quiesce_parent
2941 * must already be true). We also generalise the rule a bit to make it
2942 * easier to verify in callers and more likely to be covered in test cases:
2943 * The parent must be quiesced through this child even if new_bs isn't
2944 * currently drained.
2945 *
2946 * The only exception is for callers that always pass new_bs == NULL. In
2947 * this case, we obviously never need to consider the case of a drained
2948 * new_bs, so we can keep the callers simpler by allowing them not to drain
2949 * the parent.
2950 */
2951 assert(!new_bs || child->quiesced_parent);
Kevin Wolfbfb8aa62021-10-18 15:47:14 +02002952 assert(old_bs != new_bs);
Emanuele Giuseppe Espositof0c28322022-03-03 10:16:13 -05002953 GLOBAL_STATE_CODE();
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02002954
Fam Zhengbb2614e2017-04-07 14:54:10 +08002955 if (old_bs && new_bs) {
2956 assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
2957 }
Max Reitzdebc2922019-07-22 15:33:44 +02002958
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002959 if (old_bs) {
Max Reitzbd86fb92020-05-13 13:05:13 +02002960 if (child->klass->detach) {
2961 child->klass->detach(child);
Kevin Wolfd736f112017-12-18 16:05:48 +01002962 }
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002963 QLIST_REMOVE(child, next_parent);
2964 }
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002965
2966 child->bs = new_bs;
Kevin Wolf36fe1332016-05-17 14:51:55 +02002967
2968 if (new_bs) {
2969 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
Max Reitzbd86fb92020-05-13 13:05:13 +02002970 if (child->klass->attach) {
2971 child->klass->attach(child);
Kevin Wolfdb95dbb2017-02-08 11:28:52 +01002972 }
Kevin Wolf36fe1332016-05-17 14:51:55 +02002973 }
Max Reitzdebc2922019-07-22 15:33:44 +02002974
2975 /*
Kevin Wolf23987472022-11-18 18:41:09 +01002976 * If the parent was drained through this BdrvChild previously, but new_bs
2977 * is not drained, allow requests to come in only after the new node has
2978 * been attached.
Max Reitzdebc2922019-07-22 15:33:44 +02002979 */
Kevin Wolf57e05be2022-11-18 18:41:06 +01002980 new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0);
2981 if (!new_bs_quiesce_counter && child->quiesced_parent) {
Max Reitzdebc2922019-07-22 15:33:44 +02002982 bdrv_parent_drained_end_single(child);
Max Reitzdebc2922019-07-22 15:33:44 +02002983 }
Kevin Wolfe9740bc2016-05-23 15:52:26 +02002984}
2985
Hanna Reitz04c9c3a2021-11-15 15:53:59 +01002986/**
2987 * Free the given @child.
2988 *
2989 * The child must be empty (i.e. `child->bs == NULL`) and it must be
2990 * unused (i.e. not in a children list).
2991 */
2992static void bdrv_child_free(BdrvChild *child)
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03002993{
2994 assert(!child->bs);
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05002995 GLOBAL_STATE_CODE();
Kevin Wolf680e0cc2023-09-29 16:51:56 +02002996 GRAPH_RDLOCK_GUARD_MAINLOOP();
2997
Hanna Reitza2253692021-11-15 15:53:58 +01002998 assert(!child->next.le_prev); /* not in children list */
Hanna Reitz04c9c3a2021-11-15 15:53:59 +01002999
3000 g_free(child->name);
3001 g_free(child);
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003002}
3003
3004typedef struct BdrvAttachChildCommonState {
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003005 BdrvChild *child;
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003006 AioContext *old_parent_ctx;
3007 AioContext *old_child_ctx;
3008} BdrvAttachChildCommonState;
3009
Kevin Wolf5661a002023-09-11 11:46:10 +02003010static void GRAPH_WRLOCK bdrv_attach_child_common_abort(void *opaque)
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003011{
3012 BdrvAttachChildCommonState *s = opaque;
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003013 BlockDriverState *bs = s->child->bs;
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003014
Emanuele Giuseppe Espositof0c28322022-03-03 10:16:13 -05003015 GLOBAL_STATE_CODE();
Kevin Wolf5661a002023-09-11 11:46:10 +02003016 assert_bdrv_graph_writable();
Kevin Wolfad29eb32023-09-11 11:46:07 +02003017
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003018 bdrv_replace_child_noperm(s->child, NULL);
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003019
3020 if (bdrv_get_aio_context(bs) != s->old_child_ctx) {
Emanuele Giuseppe Esposito142e6902022-10-25 04:49:52 -04003021 bdrv_try_change_aio_context(bs, s->old_child_ctx, NULL, &error_abort);
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003022 }
3023
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003024 if (bdrv_child_get_parent_aio_context(s->child) != s->old_parent_ctx) {
Emanuele Giuseppe Espositof8be48a2022-10-25 04:49:49 -04003025 Transaction *tran;
3026 GHashTable *visited;
3027 bool ret;
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003028
Emanuele Giuseppe Espositof8be48a2022-10-25 04:49:49 -04003029 tran = tran_new();
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003030
Emanuele Giuseppe Espositof8be48a2022-10-25 04:49:49 -04003031 /* No need to visit `child`, because it has been detached already */
3032 visited = g_hash_table_new(NULL, NULL);
3033 ret = s->child->klass->change_aio_ctx(s->child, s->old_parent_ctx,
3034 visited, tran, &error_abort);
3035 g_hash_table_destroy(visited);
3036
3037 /* transaction is supposed to always succeed */
3038 assert(ret == true);
3039 tran_commit(tran);
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003040 }
3041
Kevin Wolf5661a002023-09-11 11:46:10 +02003042 bdrv_schedule_unref(bs);
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003043 bdrv_child_free(s->child);
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003044}
3045
3046static TransactionActionDrv bdrv_attach_child_common_drv = {
3047 .abort = bdrv_attach_child_common_abort,
3048 .clean = g_free,
3049};
3050
3051/*
3052 * Common part of attaching bdrv child to bs or to blk or to job
Vladimir Sementsov-Ogievskiyf8d2ad72021-06-01 10:52:13 +03003053 *
Vladimir Sementsov-Ogievskiy7ec390d2021-06-10 14:25:45 +03003054 * Function doesn't update permissions, caller is responsible for this.
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003055 *
Kevin Wolf5661a002023-09-11 11:46:10 +02003056 * After calling this function, the transaction @tran may only be completed
3057 * while holding a writer lock for the graph.
3058 *
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003059 * Returns new created child.
Kevin Wolfc066e802023-06-05 10:57:05 +02003060 *
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05003061 * Both @parent_bs and @child_bs can move to a different AioContext in this
3062 * function.
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003063 */
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003064static BdrvChild * GRAPH_WRLOCK
3065bdrv_attach_child_common(BlockDriverState *child_bs,
3066 const char *child_name,
3067 const BdrvChildClass *child_class,
3068 BdrvChildRole child_role,
3069 uint64_t perm, uint64_t shared_perm,
3070 void *opaque,
3071 Transaction *tran, Error **errp)
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003072{
3073 BdrvChild *new_child;
Stefan Hajnoczib49f4752023-12-05 13:20:03 -05003074 AioContext *parent_ctx;
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003075 AioContext *child_ctx = bdrv_get_aio_context(child_bs);
3076
Vladimir Sementsov-Ogievskiyda261b62021-06-01 10:52:17 +03003077 assert(child_class->get_parent_desc);
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05003078 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003079
3080 new_child = g_new(BdrvChild, 1);
3081 *new_child = (BdrvChild) {
3082 .bs = NULL,
3083 .name = g_strdup(child_name),
3084 .klass = child_class,
3085 .role = child_role,
3086 .perm = perm,
3087 .shared_perm = shared_perm,
3088 .opaque = opaque,
3089 };
3090
3091 /*
3092 * If the AioContexts don't match, first try to move the subtree of
3093 * child_bs into the AioContext of the new parent. If this doesn't work,
3094 * try moving the parent into the AioContext of child_bs instead.
3095 */
3096 parent_ctx = bdrv_child_get_parent_aio_context(new_child);
3097 if (child_ctx != parent_ctx) {
3098 Error *local_err = NULL;
Emanuele Giuseppe Esposito142e6902022-10-25 04:49:52 -04003099 int ret = bdrv_try_change_aio_context(child_bs, parent_ctx, NULL,
3100 &local_err);
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003101
Emanuele Giuseppe Espositof8be48a2022-10-25 04:49:49 -04003102 if (ret < 0 && child_class->change_aio_ctx) {
Markus Armbrusterfb2575f2023-09-21 14:13:11 +02003103 Transaction *aio_ctx_tran = tran_new();
Emanuele Giuseppe Espositof8be48a2022-10-25 04:49:49 -04003104 GHashTable *visited = g_hash_table_new(NULL, NULL);
3105 bool ret_child;
3106
3107 g_hash_table_add(visited, new_child);
3108 ret_child = child_class->change_aio_ctx(new_child, child_ctx,
Markus Armbrusterfb2575f2023-09-21 14:13:11 +02003109 visited, aio_ctx_tran,
3110 NULL);
Emanuele Giuseppe Espositof8be48a2022-10-25 04:49:49 -04003111 if (ret_child == true) {
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003112 error_free(local_err);
3113 ret = 0;
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003114 }
Markus Armbrusterfb2575f2023-09-21 14:13:11 +02003115 tran_finalize(aio_ctx_tran, ret_child == true ? 0 : -1);
Emanuele Giuseppe Espositof8be48a2022-10-25 04:49:49 -04003116 g_hash_table_destroy(visited);
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003117 }
3118
3119 if (ret < 0) {
3120 error_propagate(errp, local_err);
Hanna Reitz04c9c3a2021-11-15 15:53:59 +01003121 bdrv_child_free(new_child);
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003122 return NULL;
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003123 }
3124 }
3125
3126 bdrv_ref(child_bs);
Kevin Wolf23987472022-11-18 18:41:09 +01003127 /*
3128 * Let every new BdrvChild start with a drained parent. Inserting the child
3129 * in the graph with bdrv_replace_child_noperm() will undrain it if
3130 * @child_bs is not drained.
3131 *
3132 * The child was only just created and is not yet visible in global state
3133 * until bdrv_replace_child_noperm() inserts it into the graph, so nobody
3134 * could have sent requests and polling is not necessary.
3135 *
3136 * Note that this means that the parent isn't fully drained yet, we only
3137 * stop new requests from coming in. This is fine, we don't care about the
3138 * old requests here, they are not for this child. If another place enters a
3139 * drain section for the same parent, but wants it to be fully quiesced, it
3140 * will not run most of the the code in .drained_begin() again (which is not
3141 * a problem, we already did this), but it will still poll until the parent
3142 * is fully quiesced, so it will not be negatively affected either.
3143 */
Kevin Wolf606ed752022-11-18 18:41:10 +01003144 bdrv_parent_drained_begin_single(new_child);
Vladimir Sementsov-Ogievskiy544acc72022-07-26 23:11:31 +03003145 bdrv_replace_child_noperm(new_child, child_bs);
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003146
3147 BdrvAttachChildCommonState *s = g_new(BdrvAttachChildCommonState, 1);
3148 *s = (BdrvAttachChildCommonState) {
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003149 .child = new_child,
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003150 .old_parent_ctx = parent_ctx,
3151 .old_child_ctx = child_ctx,
3152 };
3153 tran_add(tran, &bdrv_attach_child_common_drv, s);
3154
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003155 return new_child;
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003156}
3157
Vladimir Sementsov-Ogievskiyf8d2ad72021-06-01 10:52:13 +03003158/*
Vladimir Sementsov-Ogievskiy7ec390d2021-06-10 14:25:45 +03003159 * Function doesn't update permissions, caller is responsible for this.
Kevin Wolfc066e802023-06-05 10:57:05 +02003160 *
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05003161 * Both @parent_bs and @child_bs can move to a different AioContext in this
3162 * function.
Kevin Wolf5661a002023-09-11 11:46:10 +02003163 *
3164 * After calling this function, the transaction @tran may only be completed
3165 * while holding a writer lock for the graph.
Vladimir Sementsov-Ogievskiyf8d2ad72021-06-01 10:52:13 +03003166 */
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003167static BdrvChild * GRAPH_WRLOCK
3168bdrv_attach_child_noperm(BlockDriverState *parent_bs,
3169 BlockDriverState *child_bs,
3170 const char *child_name,
3171 const BdrvChildClass *child_class,
3172 BdrvChildRole child_role,
3173 Transaction *tran,
3174 Error **errp)
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003175{
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003176 uint64_t perm, shared_perm;
3177
3178 assert(parent_bs->drv);
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05003179 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003180
Kevin Wolfbfb8aa62021-10-18 15:47:14 +02003181 if (bdrv_recurse_has_child(child_bs, parent_bs)) {
3182 error_setg(errp, "Making '%s' a %s child of '%s' would create a cycle",
3183 child_bs->node_name, child_name, parent_bs->node_name);
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003184 return NULL;
Kevin Wolfbfb8aa62021-10-18 15:47:14 +02003185 }
3186
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003187 bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
3188 bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
3189 perm, shared_perm, &perm, &shared_perm);
3190
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003191 return bdrv_attach_child_common(child_bs, child_name, child_class,
3192 child_role, perm, shared_perm, parent_bs,
3193 tran, errp);
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003194}
3195
Alberto Garciab441dc72019-05-13 16:46:18 +03003196/*
3197 * This function steals the reference to child_bs from the caller.
3198 * That reference is later dropped by bdrv_root_unref_child().
3199 *
3200 * On failure NULL is returned, errp is set and the reference to
3201 * child_bs is also dropped.
3202 */
Kevin Wolff21d96d2016-03-08 13:47:46 +01003203BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
3204 const char *child_name,
Max Reitzbd86fb92020-05-13 13:05:13 +02003205 const BdrvChildClass *child_class,
Max Reitz258b7762020-05-13 13:05:15 +02003206 BdrvChildRole child_role,
Kevin Wolfd5e6f432016-12-14 17:24:36 +01003207 uint64_t perm, uint64_t shared_perm,
3208 void *opaque, Error **errp)
Kevin Wolfdf581792015-06-15 11:53:47 +02003209{
Kevin Wolfd5e6f432016-12-14 17:24:36 +01003210 int ret;
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003211 BdrvChild *child;
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003212 Transaction *tran = tran_new();
Kevin Wolfd5e6f432016-12-14 17:24:36 +01003213
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -05003214 GLOBAL_STATE_CODE();
3215
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003216 child = bdrv_attach_child_common(child_bs, child_name, child_class,
Vladimir Sementsov-Ogievskiy548a74c2021-04-28 18:17:46 +03003217 child_role, perm, shared_perm, opaque,
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003218 tran, errp);
3219 if (!child) {
3220 ret = -EINVAL;
Kevin Wolfe878bb12021-05-03 13:05:54 +02003221 goto out;
Kevin Wolfd5e6f432016-12-14 17:24:36 +01003222 }
3223
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03003224 ret = bdrv_refresh_perms(child_bs, tran, errp);
Kevin Wolfdf581792015-06-15 11:53:47 +02003225
Kevin Wolfe878bb12021-05-03 13:05:54 +02003226out:
3227 tran_finalize(tran, ret);
Vladimir Sementsov-Ogievskiyf8d2ad72021-06-01 10:52:13 +03003228
Kevin Wolf03b9eac2023-10-27 17:53:13 +02003229 bdrv_schedule_unref(child_bs);
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003230
3231 return ret < 0 ? NULL : child;
Kevin Wolfdf581792015-06-15 11:53:47 +02003232}
3233
Alberto Garciab441dc72019-05-13 16:46:18 +03003234/*
3235 * This function transfers the reference to child_bs from the caller
3236 * to parent_bs. That reference is later dropped by parent_bs on
3237 * bdrv_close() or if someone calls bdrv_unref_child().
3238 *
3239 * On failure NULL is returned, errp is set and the reference to
3240 * child_bs is also dropped.
3241 */
Wen Congyang98292c62016-05-10 15:36:38 +08003242BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
3243 BlockDriverState *child_bs,
3244 const char *child_name,
Max Reitzbd86fb92020-05-13 13:05:13 +02003245 const BdrvChildClass *child_class,
Max Reitz258b7762020-05-13 13:05:15 +02003246 BdrvChildRole child_role,
Kevin Wolf8b2ff522016-12-20 22:21:17 +01003247 Error **errp)
Kevin Wolff21d96d2016-03-08 13:47:46 +01003248{
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003249 int ret;
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003250 BdrvChild *child;
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003251 Transaction *tran = tran_new();
Kevin Wolfd5e6f432016-12-14 17:24:36 +01003252
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05003253 GLOBAL_STATE_CODE();
3254
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003255 child = bdrv_attach_child_noperm(parent_bs, child_bs, child_name,
3256 child_class, child_role, tran, errp);
3257 if (!child) {
3258 ret = -EINVAL;
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003259 goto out;
Kevin Wolfd5e6f432016-12-14 17:24:36 +01003260 }
3261
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03003262 ret = bdrv_refresh_perms(parent_bs, tran, errp);
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003263 if (ret < 0) {
3264 goto out;
3265 }
3266
3267out:
3268 tran_finalize(tran, ret);
3269
Kevin Wolfafdaeb92023-09-11 11:46:11 +02003270 bdrv_schedule_unref(child_bs);
Vladimir Sementsov-Ogievskiyaa5a04c2021-04-28 18:17:47 +03003271
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003272 return ret < 0 ? NULL : child;
Kevin Wolff21d96d2016-03-08 13:47:46 +01003273}
3274
Max Reitz7b99a262019-06-12 16:07:11 +02003275/* Callers must ensure that child->frozen is false. */
Kevin Wolff21d96d2016-03-08 13:47:46 +01003276void bdrv_root_unref_child(BdrvChild *child)
Kevin Wolf33a60402015-06-15 13:51:04 +02003277{
Vladimir Sementsov-Ogievskiy00eb93b2022-11-07 19:35:55 +03003278 BlockDriverState *child_bs = child->bs;
Kevin Wolf779020c2015-10-13 14:09:44 +02003279
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05003280 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy00eb93b2022-11-07 19:35:55 +03003281 bdrv_replace_child_noperm(child, NULL);
3282 bdrv_child_free(child);
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05003283
Vladimir Sementsov-Ogievskiy00eb93b2022-11-07 19:35:55 +03003284 if (child_bs) {
3285 /*
3286 * Update permissions for old node. We're just taking a parent away, so
3287 * we're loosening restrictions. Errors of permission update are not
3288 * fatal in this case, ignore them.
3289 */
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03003290 bdrv_refresh_perms(child_bs, NULL, NULL);
Vladimir Sementsov-Ogievskiy00eb93b2022-11-07 19:35:55 +03003291
3292 /*
3293 * When the parent requiring a non-default AioContext is removed, the
3294 * node moves back to the main AioContext
3295 */
3296 bdrv_try_change_aio_context(child_bs, qemu_get_aio_context(), NULL,
3297 NULL);
3298 }
3299
Kevin Wolfede01e42023-09-11 11:46:18 +02003300 bdrv_schedule_unref(child_bs);
Kevin Wolff21d96d2016-03-08 13:47:46 +01003301}
3302
Vladimir Sementsov-Ogievskiy332b3a12021-04-28 18:17:54 +03003303typedef struct BdrvSetInheritsFrom {
3304 BlockDriverState *bs;
3305 BlockDriverState *old_inherits_from;
3306} BdrvSetInheritsFrom;
3307
3308static void bdrv_set_inherits_from_abort(void *opaque)
3309{
3310 BdrvSetInheritsFrom *s = opaque;
3311
3312 s->bs->inherits_from = s->old_inherits_from;
3313}
3314
3315static TransactionActionDrv bdrv_set_inherits_from_drv = {
3316 .abort = bdrv_set_inherits_from_abort,
3317 .clean = g_free,
3318};
3319
3320/* @tran is allowed to be NULL. In this case no rollback is possible */
3321static void bdrv_set_inherits_from(BlockDriverState *bs,
3322 BlockDriverState *new_inherits_from,
3323 Transaction *tran)
3324{
3325 if (tran) {
3326 BdrvSetInheritsFrom *s = g_new(BdrvSetInheritsFrom, 1);
3327
3328 *s = (BdrvSetInheritsFrom) {
3329 .bs = bs,
3330 .old_inherits_from = bs->inherits_from,
3331 };
3332
3333 tran_add(tran, &bdrv_set_inherits_from_drv, s);
3334 }
3335
3336 bs->inherits_from = new_inherits_from;
3337}
3338
Max Reitz3cf746b2019-07-03 19:28:07 +02003339/**
3340 * Clear all inherits_from pointers from children and grandchildren of
3341 * @root that point to @root, where necessary.
Vladimir Sementsov-Ogievskiy332b3a12021-04-28 18:17:54 +03003342 * @tran is allowed to be NULL. In this case no rollback is possible
Max Reitz3cf746b2019-07-03 19:28:07 +02003343 */
Kevin Wolf32a8aba2023-09-11 11:46:19 +02003344static void GRAPH_WRLOCK
3345bdrv_unset_inherits_from(BlockDriverState *root, BdrvChild *child,
3346 Transaction *tran)
Kevin Wolff21d96d2016-03-08 13:47:46 +01003347{
Max Reitz3cf746b2019-07-03 19:28:07 +02003348 BdrvChild *c;
Kevin Wolf33a60402015-06-15 13:51:04 +02003349
Max Reitz3cf746b2019-07-03 19:28:07 +02003350 if (child->bs->inherits_from == root) {
3351 /*
3352 * Remove inherits_from only when the last reference between root and
3353 * child->bs goes away.
3354 */
3355 QLIST_FOREACH(c, &root->children, next) {
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01003356 if (c != child && c->bs == child->bs) {
3357 break;
3358 }
3359 }
3360 if (c == NULL) {
Vladimir Sementsov-Ogievskiy332b3a12021-04-28 18:17:54 +03003361 bdrv_set_inherits_from(child->bs, NULL, tran);
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01003362 }
Kevin Wolf33a60402015-06-15 13:51:04 +02003363 }
3364
Max Reitz3cf746b2019-07-03 19:28:07 +02003365 QLIST_FOREACH(c, &child->bs->children, next) {
Vladimir Sementsov-Ogievskiy332b3a12021-04-28 18:17:54 +03003366 bdrv_unset_inherits_from(root, c, tran);
Max Reitz3cf746b2019-07-03 19:28:07 +02003367 }
3368}
3369
Max Reitz7b99a262019-06-12 16:07:11 +02003370/* Callers must ensure that child->frozen is false. */
Max Reitz3cf746b2019-07-03 19:28:07 +02003371void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
3372{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05003373 GLOBAL_STATE_CODE();
Max Reitz3cf746b2019-07-03 19:28:07 +02003374 if (child == NULL) {
3375 return;
3376 }
3377
Vladimir Sementsov-Ogievskiy332b3a12021-04-28 18:17:54 +03003378 bdrv_unset_inherits_from(parent, child, NULL);
Kevin Wolff21d96d2016-03-08 13:47:46 +01003379 bdrv_root_unref_child(child);
Kevin Wolf33a60402015-06-15 13:51:04 +02003380}
3381
Kevin Wolf5c8cab42016-02-24 15:13:35 +01003382
Kevin Wolf356f4ef2023-09-11 11:46:15 +02003383static void GRAPH_RDLOCK
3384bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
Kevin Wolf5c8cab42016-02-24 15:13:35 +01003385{
3386 BdrvChild *c;
Emanuele Giuseppe Espositof0c28322022-03-03 10:16:13 -05003387 GLOBAL_STATE_CODE();
Kevin Wolf5c8cab42016-02-24 15:13:35 +01003388 QLIST_FOREACH(c, &bs->parents, next_parent) {
Max Reitzbd86fb92020-05-13 13:05:13 +02003389 if (c->klass->change_media) {
3390 c->klass->change_media(c, load);
Kevin Wolf5c8cab42016-02-24 15:13:35 +01003391 }
3392 }
3393}
3394
Alberto Garcia0065c452018-10-31 18:16:37 +02003395/* Return true if you can reach parent going through child->inherits_from
3396 * recursively. If parent or child are NULL, return false */
3397static bool bdrv_inherits_from_recursive(BlockDriverState *child,
3398 BlockDriverState *parent)
3399{
3400 while (child && child != parent) {
3401 child = child->inherits_from;
3402 }
3403
3404 return child != NULL;
3405}
3406
Kevin Wolf5db15a52015-09-14 15:33:33 +02003407/*
Max Reitz25191e52020-05-13 13:05:33 +02003408 * Return the BdrvChildRole for @bs's backing child. bs->backing is
3409 * mostly used for COW backing children (role = COW), but also for
3410 * filtered children (role = FILTERED | PRIMARY).
3411 */
3412static BdrvChildRole bdrv_backing_role(BlockDriverState *bs)
3413{
3414 if (bs->drv && bs->drv->is_filter) {
3415 return BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
3416 } else {
3417 return BDRV_CHILD_COW;
3418 }
3419}
3420
3421/*
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003422 * Sets the bs->backing or bs->file link of a BDS. A new reference is created;
3423 * callers which don't need their own reference any more must call bdrv_unref().
Vladimir Sementsov-Ogievskiy7ec390d2021-06-10 14:25:45 +03003424 *
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003425 * If the respective child is already present (i.e. we're detaching a node),
3426 * that child node must be drained.
3427 *
Vladimir Sementsov-Ogievskiy7ec390d2021-06-10 14:25:45 +03003428 * Function doesn't update permissions, caller is responsible for this.
Kevin Wolf4b408662023-06-05 10:57:06 +02003429 *
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05003430 * Both @parent_bs and @child_bs can move to a different AioContext in this
3431 * function.
Kevin Wolf5661a002023-09-11 11:46:10 +02003432 *
3433 * After calling this function, the transaction @tran may only be completed
3434 * while holding a writer lock for the graph.
Kevin Wolf5db15a52015-09-14 15:33:33 +02003435 */
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003436static int GRAPH_WRLOCK
3437bdrv_set_file_or_backing_noperm(BlockDriverState *parent_bs,
3438 BlockDriverState *child_bs,
3439 bool is_backing,
3440 Transaction *tran, Error **errp)
Fam Zheng8d24cce2014-05-23 21:29:45 +08003441{
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003442 bool update_inherits_from =
3443 bdrv_inherits_from_recursive(child_bs, parent_bs);
3444 BdrvChild *child = is_backing ? parent_bs->backing : parent_bs->file;
3445 BdrvChildRole role;
Alberto Garcia0065c452018-10-31 18:16:37 +02003446
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05003447 GLOBAL_STATE_CODE();
3448
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003449 if (!parent_bs->drv) {
3450 /*
3451 * Node without drv is an object without a class :/. TODO: finally fix
3452 * qcow2 driver to never clear bs->drv and implement format corruption
3453 * handling in other way.
3454 */
3455 error_setg(errp, "Node corrupted");
3456 return -EINVAL;
3457 }
3458
3459 if (child && child->frozen) {
3460 error_setg(errp, "Cannot change frozen '%s' link from '%s' to '%s'",
3461 child->name, parent_bs->node_name, child->bs->node_name);
Vladimir Sementsov-Ogievskiya1e708f2021-02-02 15:49:43 +03003462 return -EPERM;
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02003463 }
3464
Vladimir Sementsov-Ogievskiy25f78d92021-06-10 15:05:34 +03003465 if (is_backing && !parent_bs->drv->is_filter &&
3466 !parent_bs->drv->supports_backing)
3467 {
3468 error_setg(errp, "Driver '%s' of node '%s' does not support backing "
3469 "files", parent_bs->drv->format_name, parent_bs->node_name);
3470 return -EINVAL;
3471 }
3472
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003473 if (parent_bs->drv->is_filter) {
3474 role = BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
3475 } else if (is_backing) {
3476 role = BDRV_CHILD_COW;
3477 } else {
3478 /*
3479 * We only can use same role as it is in existing child. We don't have
3480 * infrastructure to determine role of file child in generic way
3481 */
3482 if (!child) {
3483 error_setg(errp, "Cannot set file child to format node without "
3484 "file child");
3485 return -EINVAL;
3486 }
3487 role = child->role;
Fam Zheng826b6ca2014-05-23 21:29:47 +08003488 }
3489
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003490 if (child) {
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003491 assert(child->bs->quiesce_counter);
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003492 bdrv_unset_inherits_from(parent_bs, child, tran);
Vladimir Sementsov-Ogievskiy57f08942022-07-26 23:11:34 +03003493 bdrv_remove_child(child, tran);
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003494 }
3495
3496 if (!child_bs) {
Fam Zheng8d24cce2014-05-23 21:29:45 +08003497 goto out;
3498 }
Kevin Wolf12fa4af2017-02-17 20:42:32 +01003499
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003500 child = bdrv_attach_child_noperm(parent_bs, child_bs,
3501 is_backing ? "backing" : "file",
3502 &child_of_bds, role,
3503 tran, errp);
3504 if (!child) {
3505 return -EINVAL;
Vladimir Sementsov-Ogievskiya1e708f2021-02-02 15:49:43 +03003506 }
3507
Vladimir Sementsov-Ogievskiy160333e2021-04-28 18:17:56 +03003508
3509 /*
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003510 * If inherits_from pointed recursively to bs then let's update it to
Vladimir Sementsov-Ogievskiy160333e2021-04-28 18:17:56 +03003511 * point directly to bs (else it will become NULL).
3512 */
Vladimir Sementsov-Ogievskiya1e708f2021-02-02 15:49:43 +03003513 if (update_inherits_from) {
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003514 bdrv_set_inherits_from(child_bs, parent_bs, tran);
Alberto Garcia0065c452018-10-31 18:16:37 +02003515 }
Fam Zheng826b6ca2014-05-23 21:29:47 +08003516
Fam Zheng8d24cce2014-05-23 21:29:45 +08003517out:
Vladimir Sementsov-Ogievskiye9238272021-06-10 15:05:30 +03003518 bdrv_refresh_limits(parent_bs, tran, NULL);
Vladimir Sementsov-Ogievskiy160333e2021-04-28 18:17:56 +03003519
3520 return 0;
3521}
3522
Kevin Wolf4b408662023-06-05 10:57:06 +02003523/*
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05003524 * Both @bs and @backing_hd can move to a different AioContext in this
3525 * function.
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003526 *
3527 * If a backing child is already present (i.e. we're detaching a node), that
3528 * child node must be drained.
Kevin Wolf4b408662023-06-05 10:57:06 +02003529 */
Kevin Wolf92140b92022-11-18 18:41:04 +01003530int bdrv_set_backing_hd_drained(BlockDriverState *bs,
3531 BlockDriverState *backing_hd,
3532 Error **errp)
Vladimir Sementsov-Ogievskiy160333e2021-04-28 18:17:56 +03003533{
3534 int ret;
3535 Transaction *tran = tran_new();
3536
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05003537 GLOBAL_STATE_CODE();
Kevin Wolf92140b92022-11-18 18:41:04 +01003538 assert(bs->quiesce_counter > 0);
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003539 if (bs->backing) {
3540 assert(bs->backing->bs->quiesce_counter > 0);
3541 }
Vladimir Sementsov-Ogievskiyc0829cb2022-01-24 18:37:41 +01003542
Kevin Wolf3204c2e2023-10-27 17:53:23 +02003543 ret = bdrv_set_file_or_backing_noperm(bs, backing_hd, true, tran, errp);
Vladimir Sementsov-Ogievskiy160333e2021-04-28 18:17:56 +03003544 if (ret < 0) {
3545 goto out;
3546 }
3547
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03003548 ret = bdrv_refresh_perms(bs, tran, errp);
Vladimir Sementsov-Ogievskiy160333e2021-04-28 18:17:56 +03003549out:
3550 tran_finalize(tran, ret);
Kevin Wolf92140b92022-11-18 18:41:04 +01003551 return ret;
3552}
Vladimir Sementsov-Ogievskiya1e708f2021-02-02 15:49:43 +03003553
Kevin Wolf92140b92022-11-18 18:41:04 +01003554int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
3555 Error **errp)
3556{
Kevin Wolf004915a2023-10-27 17:53:26 +02003557 BlockDriverState *drain_bs;
Kevin Wolf92140b92022-11-18 18:41:04 +01003558 int ret;
3559 GLOBAL_STATE_CODE();
3560
Kevin Wolf004915a2023-10-27 17:53:26 +02003561 bdrv_graph_rdlock_main_loop();
3562 drain_bs = bs->backing ? bs->backing->bs : bs;
3563 bdrv_graph_rdunlock_main_loop();
3564
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003565 bdrv_ref(drain_bs);
3566 bdrv_drained_begin(drain_bs);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05003567 bdrv_graph_wrlock();
Kevin Wolf92140b92022-11-18 18:41:04 +01003568 ret = bdrv_set_backing_hd_drained(bs, backing_hd, errp);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05003569 bdrv_graph_wrunlock();
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02003570 bdrv_drained_end(drain_bs);
3571 bdrv_unref(drain_bs);
Vladimir Sementsov-Ogievskiyc0829cb2022-01-24 18:37:41 +01003572
Vladimir Sementsov-Ogievskiya1e708f2021-02-02 15:49:43 +03003573 return ret;
Fam Zheng8d24cce2014-05-23 21:29:45 +08003574}
3575
Kevin Wolf31ca6d02013-03-28 15:29:24 +01003576/*
3577 * Opens the backing file for a BlockDriverState if not yet open
3578 *
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003579 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
3580 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
3581 * itself, all options starting with "${bdref_key}." are considered part of the
3582 * BlockdevRef.
3583 *
3584 * TODO Can this be unified with bdrv_open_image()?
Kevin Wolf31ca6d02013-03-28 15:29:24 +01003585 */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003586int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
3587 const char *bdref_key, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02003588{
Zhao Liu7b22e052024-03-11 11:37:56 +08003589 ERRP_GUARD();
Max Reitz6b6833c2019-02-01 20:29:15 +01003590 char *backing_filename = NULL;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003591 char *bdref_key_dot;
3592 const char *reference = NULL;
Kevin Wolf317fc442014-04-25 13:27:34 +02003593 int ret = 0;
Max Reitz998c2012019-02-01 20:29:08 +01003594 bool implicit_backing = false;
Fam Zheng8d24cce2014-05-23 21:29:45 +08003595 BlockDriverState *backing_hd;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003596 QDict *options;
3597 QDict *tmp_parent_options = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +02003598 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02003599
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05003600 GLOBAL_STATE_CODE();
Kevin Wolf004915a2023-10-27 17:53:26 +02003601 GRAPH_RDLOCK_GUARD_MAINLOOP();
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05003602
Kevin Wolf760e0062015-06-17 14:55:21 +02003603 if (bs->backing != NULL) {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003604 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02003605 }
3606
Kevin Wolf31ca6d02013-03-28 15:29:24 +01003607 /* NULL means an empty set of options */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003608 if (parent_options == NULL) {
3609 tmp_parent_options = qdict_new();
3610 parent_options = tmp_parent_options;
Kevin Wolf31ca6d02013-03-28 15:29:24 +01003611 }
3612
Paolo Bonzini9156df12012-10-18 16:49:17 +02003613 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003614
3615 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
3616 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
3617 g_free(bdref_key_dot);
3618
Markus Armbruster129c7d12017-03-30 19:43:12 +02003619 /*
3620 * Caution: while qdict_get_try_str() is fine, getting non-string
3621 * types would require more care. When @parent_options come from
3622 * -blockdev or blockdev_add, its members are typed according to
3623 * the QAPI schema, but when they come from -drive, they're all
3624 * QString.
3625 */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003626 reference = qdict_get_try_str(parent_options, bdref_key);
3627 if (reference || qdict_haskey(options, "file.filename")) {
Max Reitz6b6833c2019-02-01 20:29:15 +01003628 /* keep backing_filename NULL */
Kevin Wolf1cb6f502013-04-12 20:27:07 +02003629 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003630 qobject_unref(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003631 goto free_exit;
Fam Zhengdbecebd2013-09-22 20:05:06 +08003632 } else {
Max Reitz998c2012019-02-01 20:29:08 +01003633 if (qdict_size(options) == 0) {
3634 /* If the user specifies options that do not modify the
3635 * backing file's behavior, we might still consider it the
3636 * implicit backing file. But it's easier this way, and
3637 * just specifying some of the backing BDS's options is
3638 * only possible with -drive anyway (otherwise the QAPI
3639 * schema forces the user to specify everything). */
3640 implicit_backing = !strcmp(bs->auto_backing_file, bs->backing_file);
3641 }
3642
Max Reitz6b6833c2019-02-01 20:29:15 +01003643 backing_filename = bdrv_get_full_backing_filename(bs, &local_err);
Max Reitz9f074292014-11-26 17:20:26 +01003644 if (local_err) {
3645 ret = -EINVAL;
3646 error_propagate(errp, local_err);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003647 qobject_unref(options);
Max Reitz9f074292014-11-26 17:20:26 +01003648 goto free_exit;
3649 }
Paolo Bonzini9156df12012-10-18 16:49:17 +02003650 }
3651
Kevin Wolf8ee79e72014-06-04 15:09:35 +02003652 if (!bs->drv || !bs->drv->supports_backing) {
3653 ret = -EINVAL;
3654 error_setg(errp, "Driver doesn't support backing files");
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003655 qobject_unref(options);
Kevin Wolf8ee79e72014-06-04 15:09:35 +02003656 goto free_exit;
3657 }
3658
Peter Krempa6bff5972017-10-12 16:14:10 +02003659 if (!reference &&
3660 bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
Eric Blake46f5ac22017-04-27 16:58:17 -05003661 qdict_put_str(options, "driver", bs->backing_format);
Paolo Bonzini9156df12012-10-18 16:49:17 +02003662 }
3663
Max Reitz6b6833c2019-02-01 20:29:15 +01003664 backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs,
Kevin Wolf7ead9462024-04-25 14:56:02 +02003665 &child_of_bds, bdrv_backing_role(bs), true,
3666 errp);
Max Reitz5b363932016-05-17 16:41:31 +02003667 if (!backing_hd) {
Paolo Bonzini9156df12012-10-18 16:49:17 +02003668 bs->open_flags |= BDRV_O_NO_BACKING;
Markus Armbrustere43bfd92015-12-18 16:35:15 +01003669 error_prepend(errp, "Could not open backing file: ");
Max Reitz5b363932016-05-17 16:41:31 +02003670 ret = -EINVAL;
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003671 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02003672 }
Kevin Wolfdf581792015-06-15 11:53:47 +02003673
Max Reitz998c2012019-02-01 20:29:08 +01003674 if (implicit_backing) {
3675 bdrv_refresh_filename(backing_hd);
3676 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
3677 backing_hd->filename);
3678 }
3679
Kevin Wolf5db15a52015-09-14 15:33:33 +02003680 /* Hook up the backing file link; drop our reference, bs owns the
3681 * backing_hd reference now */
Vladimir Sementsov-Ogievskiydc9c10a2021-02-02 15:49:47 +03003682 ret = bdrv_set_backing_hd(bs, backing_hd, errp);
Kevin Wolf5db15a52015-09-14 15:33:33 +02003683 bdrv_unref(backing_hd);
Kevin Wolf8aa04542023-06-05 10:57:08 +02003684
Vladimir Sementsov-Ogievskiydc9c10a2021-02-02 15:49:47 +03003685 if (ret < 0) {
Kevin Wolf12fa4af2017-02-17 20:42:32 +01003686 goto free_exit;
3687 }
Peter Feinerd80ac652014-01-08 19:43:25 +00003688
Kevin Wolfd9b7b052015-01-16 18:23:41 +01003689 qdict_del(parent_options, bdref_key);
3690
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003691free_exit:
3692 g_free(backing_filename);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003693 qobject_unref(tmp_parent_options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003694 return ret;
Paolo Bonzini9156df12012-10-18 16:49:17 +02003695}
3696
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01003697static BlockDriverState *
3698bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
Max Reitzbd86fb92020-05-13 13:05:13 +02003699 BlockDriverState *parent, const BdrvChildClass *child_class,
Kevin Wolf7ead9462024-04-25 14:56:02 +02003700 BdrvChildRole child_role, bool allow_none,
3701 bool parse_filename, Error **errp)
Max Reitzda557aa2013-12-20 19:28:11 +01003702{
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01003703 BlockDriverState *bs = NULL;
Max Reitzda557aa2013-12-20 19:28:11 +01003704 QDict *image_options;
Max Reitzda557aa2013-12-20 19:28:11 +01003705 char *bdref_key_dot;
3706 const char *reference;
3707
Max Reitzbd86fb92020-05-13 13:05:13 +02003708 assert(child_class != NULL);
Max Reitzf67503e2014-02-18 18:33:05 +01003709
Max Reitzda557aa2013-12-20 19:28:11 +01003710 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
3711 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
3712 g_free(bdref_key_dot);
3713
Markus Armbruster129c7d12017-03-30 19:43:12 +02003714 /*
3715 * Caution: while qdict_get_try_str() is fine, getting non-string
3716 * types would require more care. When @options come from
3717 * -blockdev or blockdev_add, its members are typed according to
3718 * the QAPI schema, but when they come from -drive, they're all
3719 * QString.
3720 */
Max Reitzda557aa2013-12-20 19:28:11 +01003721 reference = qdict_get_try_str(options, bdref_key);
3722 if (!filename && !reference && !qdict_size(image_options)) {
Kevin Wolfb4b059f2015-06-15 13:24:19 +02003723 if (!allow_none) {
Max Reitzda557aa2013-12-20 19:28:11 +01003724 error_setg(errp, "A block device must be specified for \"%s\"",
3725 bdref_key);
Max Reitzda557aa2013-12-20 19:28:11 +01003726 }
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003727 qobject_unref(image_options);
Max Reitzda557aa2013-12-20 19:28:11 +01003728 goto done;
3729 }
3730
Max Reitz5b363932016-05-17 16:41:31 +02003731 bs = bdrv_open_inherit(filename, reference, image_options, 0,
Kevin Wolf7ead9462024-04-25 14:56:02 +02003732 parent, child_class, child_role, parse_filename,
3733 errp);
Max Reitz5b363932016-05-17 16:41:31 +02003734 if (!bs) {
Kevin Wolfdf581792015-06-15 11:53:47 +02003735 goto done;
3736 }
3737
Max Reitzda557aa2013-12-20 19:28:11 +01003738done:
3739 qdict_del(options, bdref_key);
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01003740 return bs;
3741}
3742
Kevin Wolf7ead9462024-04-25 14:56:02 +02003743static BdrvChild *bdrv_open_child_common(const char *filename,
3744 QDict *options, const char *bdref_key,
3745 BlockDriverState *parent,
3746 const BdrvChildClass *child_class,
3747 BdrvChildRole child_role,
3748 bool allow_none, bool parse_filename,
3749 Error **errp)
3750{
3751 BlockDriverState *bs;
3752 BdrvChild *child;
3753
3754 GLOBAL_STATE_CODE();
3755
3756 bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_class,
3757 child_role, allow_none, parse_filename, errp);
3758 if (bs == NULL) {
3759 return NULL;
3760 }
3761
3762 bdrv_graph_wrlock();
3763 child = bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
3764 errp);
3765 bdrv_graph_wrunlock();
3766
3767 return child;
3768}
3769
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01003770/*
3771 * Opens a disk image whose options are given as BlockdevRef in another block
3772 * device's options.
3773 *
3774 * If allow_none is true, no image will be opened if filename is false and no
3775 * BlockdevRef is given. NULL will be returned, but errp remains unset.
3776 *
3777 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
3778 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
3779 * itself, all options starting with "${bdref_key}." are considered part of the
3780 * BlockdevRef.
3781 *
3782 * The BlockdevRef will be removed from the options QDict.
Kevin Wolfaa269ff2023-05-25 14:47:07 +02003783 *
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05003784 * @parent can move to a different AioContext in this function.
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01003785 */
3786BdrvChild *bdrv_open_child(const char *filename,
3787 QDict *options, const char *bdref_key,
3788 BlockDriverState *parent,
Max Reitzbd86fb92020-05-13 13:05:13 +02003789 const BdrvChildClass *child_class,
Max Reitz258b7762020-05-13 13:05:15 +02003790 BdrvChildRole child_role,
Kevin Wolf2d6b86a2017-02-17 17:43:59 +01003791 bool allow_none, Error **errp)
3792{
Kevin Wolf7ead9462024-04-25 14:56:02 +02003793 return bdrv_open_child_common(filename, options, bdref_key, parent,
3794 child_class, child_role, allow_none, false,
3795 errp);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02003796}
3797
Max Reitzbd86fb92020-05-13 13:05:13 +02003798/*
Kevin Wolf7ead9462024-04-25 14:56:02 +02003799 * This does mostly the same as bdrv_open_child(), but for opening the primary
3800 * child of a node. A notable difference from bdrv_open_child() is that it
3801 * enables filename parsing for protocol names (including json:).
Kevin Wolfaa269ff2023-05-25 14:47:07 +02003802 *
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05003803 * @parent can move to a different AioContext in this function.
Vladimir Sementsov-Ogievskiy83930782022-07-26 23:11:21 +03003804 */
3805int bdrv_open_file_child(const char *filename,
3806 QDict *options, const char *bdref_key,
3807 BlockDriverState *parent, Error **errp)
3808{
3809 BdrvChildRole role;
3810
3811 /* commit_top and mirror_top don't use this function */
3812 assert(!parent->drv->filtered_child_is_backing);
Vladimir Sementsov-Ogievskiy83930782022-07-26 23:11:21 +03003813 role = parent->drv->is_filter ?
3814 (BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY) : BDRV_CHILD_IMAGE;
3815
Kevin Wolf7ead9462024-04-25 14:56:02 +02003816 if (!bdrv_open_child_common(filename, options, bdref_key, parent,
3817 &child_of_bds, role, false, true, errp))
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003818 {
3819 return -EINVAL;
3820 }
Vladimir Sementsov-Ogievskiy83930782022-07-26 23:11:21 +03003821
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03003822 return 0;
Vladimir Sementsov-Ogievskiy83930782022-07-26 23:11:21 +03003823}
3824
3825/*
Max Reitzbd86fb92020-05-13 13:05:13 +02003826 * TODO Future callers may need to specify parent/child_class in order for
3827 * option inheritance to work. Existing callers use it for the root node.
3828 */
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01003829BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
3830{
3831 BlockDriverState *bs = NULL;
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01003832 QObject *obj = NULL;
3833 QDict *qdict = NULL;
3834 const char *reference = NULL;
3835 Visitor *v = NULL;
3836
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05003837 GLOBAL_STATE_CODE();
3838
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01003839 if (ref->type == QTYPE_QSTRING) {
3840 reference = ref->u.reference;
3841 } else {
3842 BlockdevOptions *options = &ref->u.definition;
3843 assert(ref->type == QTYPE_QDICT);
3844
3845 v = qobject_output_visitor_new(&obj);
Markus Armbruster1f584242020-04-24 10:43:35 +02003846 visit_type_BlockdevOptions(v, NULL, &options, &error_abort);
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01003847 visit_complete(v, &obj);
3848
Max Reitz7dc847e2018-02-24 16:40:29 +01003849 qdict = qobject_to(QDict, obj);
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01003850 qdict_flatten(qdict);
3851
3852 /* bdrv_open_inherit() defaults to the values in bdrv_flags (for
3853 * compatibility with other callers) rather than what we want as the
3854 * real defaults. Apply the defaults here instead. */
3855 qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
3856 qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
3857 qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off");
Kevin Wolfe35bdc12018-10-05 18:57:40 +02003858 qdict_set_default_str(qdict, BDRV_OPT_AUTO_READ_ONLY, "off");
3859
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01003860 }
3861
Kevin Wolf7ead9462024-04-25 14:56:02 +02003862 bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, 0, false,
3863 errp);
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01003864 obj = NULL;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003865 qobject_unref(obj);
Kevin Wolfe1d74bc2018-01-10 15:52:33 +01003866 visit_free(v);
3867 return bs;
3868}
3869
Max Reitz66836182016-05-17 16:41:27 +02003870static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
3871 int flags,
3872 QDict *snapshot_options,
3873 Error **errp)
Kevin Wolfb9988752014-04-03 12:09:34 +02003874{
Zhao Liu7b22e052024-03-11 11:37:56 +08003875 ERRP_GUARD();
Bin Meng69fbfff2022-10-10 12:04:31 +08003876 g_autofree char *tmp_filename = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02003877 int64_t total_size;
Chunyan Liu83d05212014-06-05 17:20:51 +08003878 QemuOpts *opts = NULL;
Eric Blakeff6ed712017-04-27 16:58:18 -05003879 BlockDriverState *bs_snapshot = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02003880 int ret;
3881
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05003882 GLOBAL_STATE_CODE();
3883
Kevin Wolfb9988752014-04-03 12:09:34 +02003884 /* if snapshot, we create a temporary backing file and open it
3885 instead of opening 'filename' directly */
3886
3887 /* Get the required size from the image */
Kevin Wolff1877432014-04-04 17:07:19 +02003888 total_size = bdrv_getlength(bs);
Kevin Wolff665f012023-06-05 10:57:07 +02003889
Kevin Wolff1877432014-04-04 17:07:19 +02003890 if (total_size < 0) {
3891 error_setg_errno(errp, -total_size, "Could not get image size");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003892 goto out;
Kevin Wolff1877432014-04-04 17:07:19 +02003893 }
Kevin Wolfb9988752014-04-03 12:09:34 +02003894
3895 /* Create the temporary image */
Bin Meng69fbfff2022-10-10 12:04:31 +08003896 tmp_filename = create_tmp_file(errp);
3897 if (!tmp_filename) {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003898 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02003899 }
3900
Max Reitzef810432014-12-02 18:32:42 +01003901 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003902 &error_abort);
Markus Armbruster39101f22015-02-12 16:46:36 +01003903 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
Markus Armbrustere43bfd92015-12-18 16:35:15 +01003904 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
Chunyan Liu83d05212014-06-05 17:20:51 +08003905 qemu_opts_del(opts);
Kevin Wolfb9988752014-04-03 12:09:34 +02003906 if (ret < 0) {
Markus Armbrustere43bfd92015-12-18 16:35:15 +01003907 error_prepend(errp, "Could not create temporary overlay '%s': ",
3908 tmp_filename);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003909 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02003910 }
3911
Kevin Wolf73176be2016-03-07 13:02:15 +01003912 /* Prepare options QDict for the temporary file */
Eric Blake46f5ac22017-04-27 16:58:17 -05003913 qdict_put_str(snapshot_options, "file.driver", "file");
3914 qdict_put_str(snapshot_options, "file.filename", tmp_filename);
3915 qdict_put_str(snapshot_options, "driver", "qcow2");
Kevin Wolfb9988752014-04-03 12:09:34 +02003916
Max Reitz5b363932016-05-17 16:41:31 +02003917 bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
Kevin Wolf73176be2016-03-07 13:02:15 +01003918 snapshot_options = NULL;
Max Reitz5b363932016-05-17 16:41:31 +02003919 if (!bs_snapshot) {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003920 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02003921 }
3922
Vladimir Sementsov-Ogievskiy934aee12021-02-02 15:49:44 +03003923 ret = bdrv_append(bs_snapshot, bs, errp);
3924 if (ret < 0) {
Eric Blakeff6ed712017-04-27 16:58:18 -05003925 bs_snapshot = NULL;
Kevin Wolfb2c28322017-02-20 12:46:42 +01003926 goto out;
3927 }
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02003928
3929out:
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003930 qobject_unref(snapshot_options);
Eric Blakeff6ed712017-04-27 16:58:18 -05003931 return bs_snapshot;
Kevin Wolfb9988752014-04-03 12:09:34 +02003932}
3933
Max Reitzda557aa2013-12-20 19:28:11 +01003934/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003935 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01003936 *
3937 * options is a QDict of options to pass to the block drivers, or NULL for an
3938 * empty set of options. The reference to the QDict belongs to the block layer
3939 * after the call (even on failure), so if the caller intends to reuse the
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003940 * dictionary, it needs to use qobject_ref() before calling bdrv_open.
Max Reitzf67503e2014-02-18 18:33:05 +01003941 *
3942 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
3943 * If it is not NULL, the referenced BDS will be reused.
Max Reitzddf56362014-02-18 18:33:06 +01003944 *
3945 * The reference parameter may be used to specify an existing block device which
3946 * should be opened. If specified, neither options nor a filename may be given,
3947 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003948 */
Kevin Wolf32192302023-01-26 18:24:32 +01003949static BlockDriverState * no_coroutine_fn
3950bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
3951 int flags, BlockDriverState *parent,
3952 const BdrvChildClass *child_class, BdrvChildRole child_role,
Kevin Wolf7ead9462024-04-25 14:56:02 +02003953 bool parse_filename, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00003954{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02003955 int ret;
Kevin Wolf5696c6e2017-02-17 18:39:24 +01003956 BlockBackend *file = NULL;
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003957 BlockDriverState *bs;
Max Reitzce343772015-08-26 19:47:50 +02003958 BlockDriver *drv = NULL;
Alberto Garcia2f624b82018-06-29 14:37:00 +03003959 BdrvChild *child;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02003960 const char *drvname;
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02003961 const char *backing;
Max Reitz34b5d2c2013-09-05 14:45:29 +02003962 Error *local_err = NULL;
Kevin Wolf73176be2016-03-07 13:02:15 +01003963 QDict *snapshot_options = NULL;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02003964 int snapshot_flags = 0;
bellard712e7872005-04-28 21:09:32 +00003965
Max Reitzbd86fb92020-05-13 13:05:13 +02003966 assert(!child_class || !flags);
3967 assert(!child_class == !parent);
Emanuele Giuseppe Espositof0c28322022-03-03 10:16:13 -05003968 GLOBAL_STATE_CODE();
Kevin Wolf32192302023-01-26 18:24:32 +01003969 assert(!qemu_in_coroutine());
Max Reitzf67503e2014-02-18 18:33:05 +01003970
Kevin Wolf356f4ef2023-09-11 11:46:15 +02003971 /* TODO We'll eventually have to take a writer lock in this function */
3972 GRAPH_RDLOCK_GUARD_MAINLOOP();
3973
Max Reitzddf56362014-02-18 18:33:06 +01003974 if (reference) {
3975 bool options_non_empty = options ? qdict_size(options) : false;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003976 qobject_unref(options);
Max Reitzddf56362014-02-18 18:33:06 +01003977
Max Reitzddf56362014-02-18 18:33:06 +01003978 if (filename || options_non_empty) {
3979 error_setg(errp, "Cannot reference an existing block device with "
3980 "additional options or a new filename");
Max Reitz5b363932016-05-17 16:41:31 +02003981 return NULL;
Max Reitzddf56362014-02-18 18:33:06 +01003982 }
3983
3984 bs = bdrv_lookup_bs(reference, reference, errp);
3985 if (!bs) {
Max Reitz5b363932016-05-17 16:41:31 +02003986 return NULL;
Max Reitzddf56362014-02-18 18:33:06 +01003987 }
Kevin Wolf76b22322016-04-04 17:11:13 +02003988
Max Reitzddf56362014-02-18 18:33:06 +01003989 bdrv_ref(bs);
Max Reitz5b363932016-05-17 16:41:31 +02003990 return bs;
Max Reitzddf56362014-02-18 18:33:06 +01003991 }
3992
Max Reitz5b363932016-05-17 16:41:31 +02003993 bs = bdrv_new();
Max Reitzf67503e2014-02-18 18:33:05 +01003994
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01003995 /* NULL means an empty set of options */
3996 if (options == NULL) {
3997 options = qdict_new();
3998 }
3999
Kevin Wolf145f5982015-05-08 16:15:03 +02004000 /* json: syntax counts as explicit options, as if in the QDict */
Kevin Wolf7ead9462024-04-25 14:56:02 +02004001 if (parse_filename) {
4002 parse_json_protocol(options, &filename, &local_err);
4003 if (local_err) {
4004 goto fail;
4005 }
Kevin Wolfde3b53f2015-10-29 15:24:41 +01004006 }
4007
Kevin Wolf145f5982015-05-08 16:15:03 +02004008 bs->explicit_options = qdict_clone_shallow(options);
4009
Max Reitzbd86fb92020-05-13 13:05:13 +02004010 if (child_class) {
Max Reitz3cdc69d2020-05-13 13:05:18 +02004011 bool parent_is_format;
4012
4013 if (parent->drv) {
4014 parent_is_format = parent->drv->is_format;
4015 } else {
4016 /*
4017 * parent->drv is not set yet because this node is opened for
4018 * (potential) format probing. That means that @parent is going
4019 * to be a format node.
4020 */
4021 parent_is_format = true;
4022 }
4023
Kevin Wolfbddcec32015-04-09 18:47:50 +02004024 bs->inherits_from = parent;
Max Reitz3cdc69d2020-05-13 13:05:18 +02004025 child_class->inherit_options(child_role, parent_is_format,
4026 &flags, options,
Max Reitzbd86fb92020-05-13 13:05:13 +02004027 parent->open_flags, parent->options);
Kevin Wolff3930ed2015-04-08 13:43:47 +02004028 }
4029
Kevin Wolf7ead9462024-04-25 14:56:02 +02004030 ret = bdrv_fill_options(&options, filename, &flags, parse_filename,
4031 &local_err);
Philippe Mathieu-Daudédfde4832020-04-22 15:31:44 +02004032 if (ret < 0) {
Kevin Wolf462f5bc2014-05-26 11:39:55 +02004033 goto fail;
4034 }
4035
Markus Armbruster129c7d12017-03-30 19:43:12 +02004036 /*
4037 * Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags.
4038 * Caution: getting a boolean member of @options requires care.
4039 * When @options come from -blockdev or blockdev_add, members are
4040 * typed according to the QAPI schema, but when they come from
4041 * -drive, they're all QString.
4042 */
Alberto Garciaf87a0e22016-09-15 17:53:02 +03004043 if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
4044 !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
4045 flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
4046 } else {
4047 flags &= ~BDRV_O_RDWR;
Alberto Garcia14499ea2016-09-15 17:53:00 +03004048 }
4049
4050 if (flags & BDRV_O_SNAPSHOT) {
4051 snapshot_options = qdict_new();
4052 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
4053 flags, options);
Alberto Garciaf87a0e22016-09-15 17:53:02 +03004054 /* Let bdrv_backing_options() override "read-only" */
4055 qdict_del(options, BDRV_OPT_READ_ONLY);
Max Reitz00ff7ff2020-05-13 13:05:21 +02004056 bdrv_inherited_options(BDRV_CHILD_COW, true,
4057 &flags, options, flags, options);
Alberto Garcia14499ea2016-09-15 17:53:00 +03004058 }
4059
Kevin Wolf62392eb2015-04-24 16:38:02 +02004060 bs->open_flags = flags;
4061 bs->options = options;
4062 options = qdict_clone_shallow(options);
4063
Kevin Wolf76c591b2014-06-04 14:19:44 +02004064 /* Find the right image format driver */
Markus Armbruster129c7d12017-03-30 19:43:12 +02004065 /* See cautionary note on accessing @options above */
Kevin Wolf76c591b2014-06-04 14:19:44 +02004066 drvname = qdict_get_try_str(options, "driver");
4067 if (drvname) {
4068 drv = bdrv_find_format(drvname);
Kevin Wolf76c591b2014-06-04 14:19:44 +02004069 if (!drv) {
4070 error_setg(errp, "Unknown driver: '%s'", drvname);
Kevin Wolf76c591b2014-06-04 14:19:44 +02004071 goto fail;
4072 }
4073 }
4074
4075 assert(drvname || !(flags & BDRV_O_PROTOCOL));
Kevin Wolf76c591b2014-06-04 14:19:44 +02004076
Markus Armbruster129c7d12017-03-30 19:43:12 +02004077 /* See cautionary note on accessing @options above */
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02004078 backing = qdict_get_try_str(options, "backing");
Max Reitze59a0cf2018-02-24 16:40:32 +01004079 if (qobject_to(QNull, qdict_get(options, "backing")) != NULL ||
4080 (backing && *backing == '\0'))
4081 {
Max Reitz4f7be282018-02-24 16:40:33 +01004082 if (backing) {
4083 warn_report("Use of \"backing\": \"\" is deprecated; "
4084 "use \"backing\": null instead");
4085 }
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02004086 flags |= BDRV_O_NO_BACKING;
Kevin Wolfae0f57f2019-11-08 09:36:35 +01004087 qdict_del(bs->explicit_options, "backing");
4088 qdict_del(bs->options, "backing");
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02004089 qdict_del(options, "backing");
4090 }
4091
Kevin Wolf5696c6e2017-02-17 18:39:24 +01004092 /* Open image file without format layer. This BlockBackend is only used for
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01004093 * probing, the block drivers will do their own bdrv_open_child() for the
4094 * same BDS, which is why we put the node name back into options. */
Kevin Wolff4788ad2014-06-03 16:44:19 +02004095 if ((flags & BDRV_O_PROTOCOL) == 0) {
Kevin Wolf5696c6e2017-02-17 18:39:24 +01004096 BlockDriverState *file_bs;
4097
4098 file_bs = bdrv_open_child_bs(filename, options, "file", bs,
Max Reitz58944402020-05-13 13:05:37 +02004099 &child_of_bds, BDRV_CHILD_IMAGE,
Kevin Wolf7ead9462024-04-25 14:56:02 +02004100 true, true, &local_err);
Kevin Wolf1fdd6932015-06-15 14:11:51 +02004101 if (local_err) {
Max Reitz5469a2a2014-02-18 18:33:10 +01004102 goto fail;
4103 }
Kevin Wolf5696c6e2017-02-17 18:39:24 +01004104 if (file_bs != NULL) {
Kevin Wolfdacaa162017-11-20 14:59:13 +01004105 /* Not requesting BLK_PERM_CONSISTENT_READ because we're only
4106 * looking at the header to guess the image format. This works even
4107 * in cases where a guest would not see a consistent state. */
Stefan Hajnoczib49f4752023-12-05 13:20:03 -05004108 AioContext *ctx = bdrv_get_aio_context(file_bs);
Kevin Wolff665f012023-06-05 10:57:07 +02004109 file = blk_new(ctx, 0, BLK_PERM_ALL);
Kevin Wolfd7086422017-01-13 19:02:32 +01004110 blk_insert_bs(file, file_bs, &local_err);
Kevin Wolf5696c6e2017-02-17 18:39:24 +01004111 bdrv_unref(file_bs);
Kevin Wolff665f012023-06-05 10:57:07 +02004112
Kevin Wolfd7086422017-01-13 19:02:32 +01004113 if (local_err) {
4114 goto fail;
4115 }
Kevin Wolf5696c6e2017-02-17 18:39:24 +01004116
Eric Blake46f5ac22017-04-27 16:58:17 -05004117 qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01004118 }
Max Reitz5469a2a2014-02-18 18:33:10 +01004119 }
4120
Kevin Wolf76c591b2014-06-04 14:19:44 +02004121 /* Image format probing */
Kevin Wolf38f3ef52014-11-20 16:27:12 +01004122 bs->probed = !drv;
Kevin Wolf76c591b2014-06-04 14:19:44 +02004123 if (!drv && file) {
Kevin Wolfcf2ab8f2016-06-20 18:24:02 +02004124 ret = find_image_format(file, filename, &drv, &local_err);
Kevin Wolf17b005f2014-05-27 10:50:29 +02004125 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02004126 goto fail;
Max Reitz2a05cbe2013-12-20 19:28:10 +01004127 }
Kevin Wolf62392eb2015-04-24 16:38:02 +02004128 /*
4129 * This option update would logically belong in bdrv_fill_options(),
4130 * but we first need to open bs->file for the probing to work, while
4131 * opening bs->file already requires the (mostly) final set of options
4132 * so that cache mode etc. can be inherited.
4133 *
4134 * Adding the driver later is somewhat ugly, but it's not an option
4135 * that would ever be inherited, so it's correct. We just need to make
4136 * sure to update both bs->options (which has the full effective
4137 * options for bs) and options (which has file.* already removed).
4138 */
Eric Blake46f5ac22017-04-27 16:58:17 -05004139 qdict_put_str(bs->options, "driver", drv->format_name);
4140 qdict_put_str(options, "driver", drv->format_name);
Kevin Wolf76c591b2014-06-04 14:19:44 +02004141 } else if (!drv) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02004142 error_setg(errp, "Must specify either driver or file");
Kevin Wolf8bfea152014-04-11 19:16:36 +02004143 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01004144 }
4145
Max Reitz53a29512015-03-19 14:53:16 -04004146 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
Paolo Bonzini41770f62022-11-24 16:21:18 +01004147 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->protocol_name);
Max Reitz53a29512015-03-19 14:53:16 -04004148 /* file must be NULL if a protocol BDS is about to be created
4149 * (the inverse results in an error message from bdrv_open_common()) */
4150 assert(!(flags & BDRV_O_PROTOCOL) || !file);
4151
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004152 /* Open the image */
Kevin Wolf82dc8b42016-01-11 19:07:50 +01004153 ret = bdrv_open_common(bs, file, options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004154 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02004155 goto fail;
Christoph Hellwig69873072010-01-20 18:13:25 +01004156 }
4157
Kevin Wolf4e4bf5c2016-12-16 18:52:37 +01004158 if (file) {
Kevin Wolf5696c6e2017-02-17 18:39:24 +01004159 blk_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01004160 file = NULL;
4161 }
4162
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004163 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02004164 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolfd9b7b052015-01-16 18:23:41 +01004165 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004166 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01004167 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004168 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004169 }
4170
Alberto Garcia50196d72018-09-06 12:37:03 +03004171 /* Remove all children options and references
4172 * from bs->options and bs->explicit_options */
Alberto Garcia2f624b82018-06-29 14:37:00 +03004173 QLIST_FOREACH(child, &bs->children, next) {
4174 char *child_key_dot;
4175 child_key_dot = g_strdup_printf("%s.", child->name);
4176 qdict_extract_subqdict(bs->explicit_options, NULL, child_key_dot);
4177 qdict_extract_subqdict(bs->options, NULL, child_key_dot);
Alberto Garcia50196d72018-09-06 12:37:03 +03004178 qdict_del(bs->explicit_options, child->name);
4179 qdict_del(bs->options, child->name);
Alberto Garcia2f624b82018-06-29 14:37:00 +03004180 g_free(child_key_dot);
4181 }
4182
Kevin Wolfb6ad4912013-03-15 10:35:04 +01004183 /* Check if any unknown options were used */
Paolo Bonzini7ad27572017-01-04 15:59:14 +01004184 if (qdict_size(options) != 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01004185 const QDictEntry *entry = qdict_first(options);
Max Reitz5acd9d82014-02-18 18:33:11 +01004186 if (flags & BDRV_O_PROTOCOL) {
4187 error_setg(errp, "Block protocol '%s' doesn't support the option "
4188 "'%s'", drv->format_name, entry->key);
4189 } else {
Max Reitzd0e46a52016-03-16 19:54:34 +01004190 error_setg(errp,
4191 "Block format '%s' does not support the option '%s'",
4192 drv->format_name, entry->key);
Max Reitz5acd9d82014-02-18 18:33:11 +01004193 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01004194
Kevin Wolfb6ad4912013-03-15 10:35:04 +01004195 goto close_and_fail;
4196 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01004197
Daniel P. Berrangec01c2142017-06-23 17:24:16 +01004198 bdrv_parent_cb_change_media(bs, true);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004199
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004200 qobject_unref(options);
Alberto Garcia8961be32018-09-06 17:25:41 +03004201 options = NULL;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004202
4203 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
4204 * temporary snapshot afterwards. */
4205 if (snapshot_flags) {
Max Reitz66836182016-05-17 16:41:27 +02004206 BlockDriverState *snapshot_bs;
4207 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
4208 snapshot_options, &local_err);
Kevin Wolf73176be2016-03-07 13:02:15 +01004209 snapshot_options = NULL;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02004210 if (local_err) {
4211 goto close_and_fail;
4212 }
Max Reitz5b363932016-05-17 16:41:31 +02004213 /* We are not going to return bs but the overlay on top of it
4214 * (snapshot_bs); thus, we have to drop the strong reference to bs
4215 * (which we obtained by calling bdrv_new()). bs will not be deleted,
4216 * though, because the overlay still has a reference to it. */
4217 bdrv_unref(bs);
4218 bs = snapshot_bs;
Max Reitz66836182016-05-17 16:41:27 +02004219 }
4220
Max Reitz5b363932016-05-17 16:41:31 +02004221 return bs;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004222
Kevin Wolf8bfea152014-04-11 19:16:36 +02004223fail:
Kevin Wolf5696c6e2017-02-17 18:39:24 +01004224 blk_unref(file);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004225 qobject_unref(snapshot_options);
4226 qobject_unref(bs->explicit_options);
4227 qobject_unref(bs->options);
4228 qobject_unref(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01004229 bs->options = NULL;
Manos Pitsidianakis998cbd62017-07-14 17:35:47 +03004230 bs->explicit_options = NULL;
Max Reitz5b363932016-05-17 16:41:31 +02004231 bdrv_unref(bs);
Eduardo Habkost621ff942016-06-13 18:57:56 -03004232 error_propagate(errp, local_err);
Max Reitz5b363932016-05-17 16:41:31 +02004233 return NULL;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01004234
Kevin Wolfb6ad4912013-03-15 10:35:04 +01004235close_and_fail:
Max Reitz5b363932016-05-17 16:41:31 +02004236 bdrv_unref(bs);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004237 qobject_unref(snapshot_options);
4238 qobject_unref(options);
Eduardo Habkost621ff942016-06-13 18:57:56 -03004239 error_propagate(errp, local_err);
Max Reitz5b363932016-05-17 16:41:31 +02004240 return NULL;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02004241}
4242
Max Reitz5b363932016-05-17 16:41:31 +02004243BlockDriverState *bdrv_open(const char *filename, const char *reference,
4244 QDict *options, int flags, Error **errp)
Kevin Wolff3930ed2015-04-08 13:43:47 +02004245{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05004246 GLOBAL_STATE_CODE();
4247
Max Reitz5b363932016-05-17 16:41:31 +02004248 return bdrv_open_inherit(filename, reference, options, flags, NULL,
Kevin Wolf7ead9462024-04-25 14:56:02 +02004249 NULL, 0, true, errp);
Kevin Wolff3930ed2015-04-08 13:43:47 +02004250}
4251
Alberto Garciafaf116b2019-03-12 18:48:49 +02004252/* Return true if the NULL-terminated @list contains @str */
4253static bool is_str_in_list(const char *str, const char *const *list)
4254{
4255 if (str && list) {
4256 int i;
4257 for (i = 0; list[i] != NULL; i++) {
4258 if (!strcmp(str, list[i])) {
4259 return true;
4260 }
4261 }
4262 }
4263 return false;
4264}
4265
4266/*
4267 * Check that every option set in @bs->options is also set in
4268 * @new_opts.
4269 *
4270 * Options listed in the common_options list and in
4271 * @bs->drv->mutable_opts are skipped.
4272 *
4273 * Return 0 on success, otherwise return -EINVAL and set @errp.
4274 */
4275static int bdrv_reset_options_allowed(BlockDriverState *bs,
4276 const QDict *new_opts, Error **errp)
4277{
4278 const QDictEntry *e;
4279 /* These options are common to all block drivers and are handled
4280 * in bdrv_reopen_prepare() so they can be left out of @new_opts */
4281 const char *const common_options[] = {
4282 "node-name", "discard", "cache.direct", "cache.no-flush",
4283 "read-only", "auto-read-only", "detect-zeroes", NULL
4284 };
4285
4286 for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {
4287 if (!qdict_haskey(new_opts, e->key) &&
4288 !is_str_in_list(e->key, common_options) &&
4289 !is_str_in_list(e->key, bs->drv->mutable_opts)) {
4290 error_setg(errp, "Option '%s' cannot be reset "
4291 "to its default value", e->key);
4292 return -EINVAL;
4293 }
4294 }
4295
4296 return 0;
4297}
4298
Jeff Codye971aa12012-09-20 15:13:19 -04004299/*
Alberto Garciacb828c32019-03-12 18:48:47 +02004300 * Returns true if @child can be reached recursively from @bs
4301 */
Kevin Wolfce433d22023-09-29 16:51:43 +02004302static bool GRAPH_RDLOCK
4303bdrv_recurse_has_child(BlockDriverState *bs, BlockDriverState *child)
Alberto Garciacb828c32019-03-12 18:48:47 +02004304{
4305 BdrvChild *c;
4306
4307 if (bs == child) {
4308 return true;
4309 }
4310
4311 QLIST_FOREACH(c, &bs->children, next) {
4312 if (bdrv_recurse_has_child(c->bs, child)) {
4313 return true;
4314 }
4315 }
4316
4317 return false;
4318}
4319
4320/*
Jeff Codye971aa12012-09-20 15:13:19 -04004321 * Adds a BlockDriverState to a simple queue for an atomic, transactional
4322 * reopen of multiple devices.
4323 *
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03004324 * bs_queue can either be an existing BlockReopenQueue that has had QTAILQ_INIT
Jeff Codye971aa12012-09-20 15:13:19 -04004325 * already performed, or alternatively may be NULL a new BlockReopenQueue will
4326 * be created and initialized. This newly created BlockReopenQueue should be
4327 * passed back in for subsequent calls that are intended to be of the same
4328 * atomic 'set'.
4329 *
4330 * bs is the BlockDriverState to add to the reopen queue.
4331 *
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004332 * options contains the changed options for the associated bs
4333 * (the BlockReopenQueue takes ownership)
4334 *
Jeff Codye971aa12012-09-20 15:13:19 -04004335 * flags contains the open flags for the associated bs
4336 *
4337 * returns a pointer to bs_queue, which is either the newly allocated
4338 * bs_queue, or the existing bs_queue being used.
4339 *
Kevin Wolfd22933a2022-11-18 18:41:02 +01004340 * bs is drained here and undrained by bdrv_reopen_queue_free().
Kevin Wolf2e117862022-11-18 18:41:01 +01004341 *
4342 * To be called with bs->aio_context locked.
Jeff Codye971aa12012-09-20 15:13:19 -04004343 */
Kevin Wolfce433d22023-09-29 16:51:43 +02004344static BlockReopenQueue * GRAPH_RDLOCK
4345bdrv_reopen_queue_child(BlockReopenQueue *bs_queue, BlockDriverState *bs,
4346 QDict *options, const BdrvChildClass *klass,
4347 BdrvChildRole role, bool parent_is_format,
4348 QDict *parent_options, int parent_flags,
4349 bool keep_old_opts)
Jeff Codye971aa12012-09-20 15:13:19 -04004350{
4351 assert(bs != NULL);
4352
4353 BlockReopenQueueEntry *bs_entry;
Kevin Wolf67251a32015-04-09 18:54:04 +02004354 BdrvChild *child;
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02004355 QDict *old_options, *explicit_options, *options_copy;
4356 int flags;
4357 QemuOpts *opts;
Kevin Wolf67251a32015-04-09 18:54:04 +02004358
Emanuele Giuseppe Espositof0c28322022-03-03 10:16:13 -05004359 GLOBAL_STATE_CODE();
Kevin Wolf1a63a902017-12-06 20:24:44 +01004360
Kevin Wolfce433d22023-09-29 16:51:43 +02004361 /*
4362 * Strictly speaking, draining is illegal under GRAPH_RDLOCK. We know that
4363 * we've been called with bdrv_graph_rdlock_main_loop(), though, so it's ok
4364 * in practice.
4365 */
Kevin Wolfd22933a2022-11-18 18:41:02 +01004366 bdrv_drained_begin(bs);
4367
Jeff Codye971aa12012-09-20 15:13:19 -04004368 if (bs_queue == NULL) {
4369 bs_queue = g_new0(BlockReopenQueue, 1);
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03004370 QTAILQ_INIT(bs_queue);
Jeff Codye971aa12012-09-20 15:13:19 -04004371 }
4372
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004373 if (!options) {
4374 options = qdict_new();
4375 }
4376
Alberto Garcia5b7ba052016-09-15 17:53:03 +03004377 /* Check if this BlockDriverState is already in the queue */
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03004378 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
Alberto Garcia5b7ba052016-09-15 17:53:03 +03004379 if (bs == bs_entry->state.bs) {
4380 break;
4381 }
4382 }
4383
Kevin Wolf28518102015-05-08 17:07:31 +02004384 /*
4385 * Precedence of options:
4386 * 1. Explicitly passed in options (highest)
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02004387 * 2. Retained from explicitly set options of bs
4388 * 3. Inherited from parent node
4389 * 4. Retained from effective options of bs
Kevin Wolf28518102015-05-08 17:07:31 +02004390 */
4391
Kevin Wolf145f5982015-05-08 16:15:03 +02004392 /* Old explicitly set values (don't overwrite by inherited value) */
Alberto Garcia077e8e22019-03-12 18:48:44 +02004393 if (bs_entry || keep_old_opts) {
4394 old_options = qdict_clone_shallow(bs_entry ?
4395 bs_entry->state.explicit_options :
4396 bs->explicit_options);
4397 bdrv_join_options(bs, options, old_options);
4398 qobject_unref(old_options);
Alberto Garcia5b7ba052016-09-15 17:53:03 +03004399 }
Kevin Wolf145f5982015-05-08 16:15:03 +02004400
4401 explicit_options = qdict_clone_shallow(options);
4402
Kevin Wolf28518102015-05-08 17:07:31 +02004403 /* Inherit from parent node */
4404 if (parent_options) {
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02004405 flags = 0;
Max Reitz3cdc69d2020-05-13 13:05:18 +02004406 klass->inherit_options(role, parent_is_format, &flags, options,
Max Reitz272c02e2020-05-13 13:05:17 +02004407 parent_flags, parent_options);
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02004408 } else {
4409 flags = bdrv_get_flags(bs);
Kevin Wolf28518102015-05-08 17:07:31 +02004410 }
4411
Alberto Garcia077e8e22019-03-12 18:48:44 +02004412 if (keep_old_opts) {
4413 /* Old values are used for options that aren't set yet */
4414 old_options = qdict_clone_shallow(bs->options);
4415 bdrv_join_options(bs, options, old_options);
4416 qobject_unref(old_options);
4417 }
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004418
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02004419 /* We have the final set of options so let's update the flags */
4420 options_copy = qdict_clone_shallow(options);
4421 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
4422 qemu_opts_absorb_qdict(opts, options_copy, NULL);
4423 update_flags_from_options(&flags, opts);
4424 qemu_opts_del(opts);
4425 qobject_unref(options_copy);
4426
Kevin Wolffd452022017-08-03 17:02:59 +02004427 /* bdrv_open_inherit() sets and clears some additional flags internally */
Kevin Wolff1f25a22014-04-25 19:04:55 +02004428 flags &= ~BDRV_O_PROTOCOL;
Kevin Wolffd452022017-08-03 17:02:59 +02004429 if (flags & BDRV_O_RDWR) {
4430 flags |= BDRV_O_ALLOW_RDWR;
4431 }
Kevin Wolff1f25a22014-04-25 19:04:55 +02004432
Kevin Wolf1857c972017-09-14 14:53:46 +02004433 if (!bs_entry) {
4434 bs_entry = g_new0(BlockReopenQueueEntry, 1);
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03004435 QTAILQ_INSERT_TAIL(bs_queue, bs_entry, entry);
Kevin Wolf1857c972017-09-14 14:53:46 +02004436 } else {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004437 qobject_unref(bs_entry->state.options);
4438 qobject_unref(bs_entry->state.explicit_options);
Kevin Wolf1857c972017-09-14 14:53:46 +02004439 }
4440
4441 bs_entry->state.bs = bs;
4442 bs_entry->state.options = options;
4443 bs_entry->state.explicit_options = explicit_options;
4444 bs_entry->state.flags = flags;
4445
Alberto Garcia85466322019-03-12 18:48:45 +02004446 /*
4447 * If keep_old_opts is false then it means that unspecified
4448 * options must be reset to their original value. We don't allow
4449 * resetting 'backing' but we need to know if the option is
4450 * missing in order to decide if we have to return an error.
4451 */
4452 if (!keep_old_opts) {
4453 bs_entry->state.backing_missing =
4454 !qdict_haskey(options, "backing") &&
4455 !qdict_haskey(options, "backing.driver");
4456 }
4457
Kevin Wolf67251a32015-04-09 18:54:04 +02004458 QLIST_FOREACH(child, &bs->children, next) {
Alberto Garcia85466322019-03-12 18:48:45 +02004459 QDict *new_child_options = NULL;
4460 bool child_keep_old = keep_old_opts;
Kevin Wolf67251a32015-04-09 18:54:04 +02004461
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02004462 /* reopen can only change the options of block devices that were
4463 * implicitly created and inherited options. For other (referenced)
4464 * block devices, a syntax like "backing.foo" results in an error. */
Kevin Wolf67251a32015-04-09 18:54:04 +02004465 if (child->bs->inherits_from != bs) {
4466 continue;
4467 }
4468
Alberto Garcia85466322019-03-12 18:48:45 +02004469 /* Check if the options contain a child reference */
4470 if (qdict_haskey(options, child->name)) {
4471 const char *childref = qdict_get_try_str(options, child->name);
4472 /*
4473 * The current child must not be reopened if the child
4474 * reference is null or points to a different node.
4475 */
4476 if (g_strcmp0(childref, child->bs->node_name)) {
4477 continue;
4478 }
4479 /*
4480 * If the child reference points to the current child then
4481 * reopen it with its existing set of options (note that
4482 * it can still inherit new options from the parent).
4483 */
4484 child_keep_old = true;
4485 } else {
4486 /* Extract child options ("child-name.*") */
4487 char *child_key_dot = g_strdup_printf("%s.", child->name);
4488 qdict_extract_subqdict(explicit_options, NULL, child_key_dot);
4489 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
4490 g_free(child_key_dot);
4491 }
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02004492
Alberto Garcia9aa09dd2018-11-12 16:00:45 +02004493 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options,
Max Reitz3cdc69d2020-05-13 13:05:18 +02004494 child->klass, child->role, bs->drv->is_format,
4495 options, flags, child_keep_old);
Jeff Codye971aa12012-09-20 15:13:19 -04004496 }
4497
Jeff Codye971aa12012-09-20 15:13:19 -04004498 return bs_queue;
4499}
4500
Kevin Wolf2e117862022-11-18 18:41:01 +01004501/* To be called with bs->aio_context locked */
Kevin Wolf28518102015-05-08 17:07:31 +02004502BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
4503 BlockDriverState *bs,
Alberto Garcia077e8e22019-03-12 18:48:44 +02004504 QDict *options, bool keep_old_opts)
Kevin Wolf28518102015-05-08 17:07:31 +02004505{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05004506 GLOBAL_STATE_CODE();
Kevin Wolfce433d22023-09-29 16:51:43 +02004507 GRAPH_RDLOCK_GUARD_MAINLOOP();
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05004508
Max Reitz3cdc69d2020-05-13 13:05:18 +02004509 return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, 0, false,
4510 NULL, 0, keep_old_opts);
Kevin Wolf28518102015-05-08 17:07:31 +02004511}
4512
Alberto Garciaab5b52282021-07-08 13:47:05 +02004513void bdrv_reopen_queue_free(BlockReopenQueue *bs_queue)
4514{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05004515 GLOBAL_STATE_CODE();
Alberto Garciaab5b52282021-07-08 13:47:05 +02004516 if (bs_queue) {
4517 BlockReopenQueueEntry *bs_entry, *next;
4518 QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
Kevin Wolfd22933a2022-11-18 18:41:02 +01004519 bdrv_drained_end(bs_entry->state.bs);
Alberto Garciaab5b52282021-07-08 13:47:05 +02004520 qobject_unref(bs_entry->state.explicit_options);
4521 qobject_unref(bs_entry->state.options);
4522 g_free(bs_entry);
4523 }
4524 g_free(bs_queue);
4525 }
4526}
4527
Jeff Codye971aa12012-09-20 15:13:19 -04004528/*
4529 * Reopen multiple BlockDriverStates atomically & transactionally.
4530 *
4531 * The queue passed in (bs_queue) must have been built up previous
4532 * via bdrv_reopen_queue().
4533 *
4534 * Reopens all BDS specified in the queue, with the appropriate
4535 * flags. All devices are prepared for reopen, and failure of any
Stefan Weil50d6a8a2018-07-12 21:51:20 +02004536 * device will cause all device changes to be abandoned, and intermediate
Jeff Codye971aa12012-09-20 15:13:19 -04004537 * data cleaned up.
4538 *
4539 * If all devices prepare successfully, then the changes are committed
4540 * to all devices.
4541 *
Kevin Wolf1a63a902017-12-06 20:24:44 +01004542 * All affected nodes must be drained between bdrv_reopen_queue() and
4543 * bdrv_reopen_multiple().
Kevin Wolf6cf42ca2021-07-08 13:47:06 +02004544 *
4545 * To be called from the main thread, with all other AioContexts unlocked.
Jeff Codye971aa12012-09-20 15:13:19 -04004546 */
Alberto Garcia5019aec2019-03-12 18:48:50 +02004547int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
Jeff Codye971aa12012-09-20 15:13:19 -04004548{
4549 int ret = -1;
4550 BlockReopenQueueEntry *bs_entry, *next;
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004551 Transaction *tran = tran_new();
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004552 g_autoptr(GSList) refresh_list = NULL;
Jeff Codye971aa12012-09-20 15:13:19 -04004553
Kevin Wolf6cf42ca2021-07-08 13:47:06 +02004554 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
Jeff Codye971aa12012-09-20 15:13:19 -04004555 assert(bs_queue != NULL);
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05004556 GLOBAL_STATE_CODE();
Jeff Codye971aa12012-09-20 15:13:19 -04004557
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03004558 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
Vladimir Sementsov-Ogievskiya2aabf82021-04-28 18:17:57 +03004559 ret = bdrv_flush(bs_entry->state.bs);
4560 if (ret < 0) {
4561 error_setg_errno(errp, -ret, "Error flushing drive");
Kevin Wolfe3fc91a2021-05-03 13:05:55 +02004562 goto abort;
Vladimir Sementsov-Ogievskiya2aabf82021-04-28 18:17:57 +03004563 }
4564 }
4565
4566 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
Kevin Wolf1a63a902017-12-06 20:24:44 +01004567 assert(bs_entry->state.bs->quiesce_counter > 0);
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004568 ret = bdrv_reopen_prepare(&bs_entry->state, bs_queue, tran, errp);
4569 if (ret < 0) {
4570 goto abort;
Jeff Codye971aa12012-09-20 15:13:19 -04004571 }
4572 bs_entry->prepared = true;
4573 }
4574
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03004575 QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
Kevin Wolf69b736e2019-03-05 17:18:22 +01004576 BDRVReopenState *state = &bs_entry->state;
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004577
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03004578 refresh_list = g_slist_prepend(refresh_list, state->bs);
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004579 if (state->old_backing_bs) {
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03004580 refresh_list = g_slist_prepend(refresh_list, state->old_backing_bs);
Kevin Wolf69b736e2019-03-05 17:18:22 +01004581 }
Alberto Garciaecd30d22021-06-10 15:05:36 +03004582 if (state->old_file_bs) {
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03004583 refresh_list = g_slist_prepend(refresh_list, state->old_file_bs);
Alberto Garciaecd30d22021-06-10 15:05:36 +03004584 }
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004585 }
4586
4587 /*
4588 * Note that file-posix driver rely on permission update done during reopen
4589 * (even if no permission changed), because it wants "new" permissions for
4590 * reconfiguring the fd and that's why it does it in raw_check_perm(), not
4591 * in raw_reopen_prepare() which is called with "old" permissions.
4592 */
Kevin Wolf3804e3c2023-09-11 11:46:12 +02004593 bdrv_graph_rdlock_main_loop();
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004594 ret = bdrv_list_refresh_perms(refresh_list, bs_queue, tran, errp);
Kevin Wolf3804e3c2023-09-11 11:46:12 +02004595 bdrv_graph_rdunlock_main_loop();
4596
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004597 if (ret < 0) {
4598 goto abort;
Kevin Wolf69b736e2019-03-05 17:18:22 +01004599 }
4600
Vladimir Sementsov-Ogievskiyfcd6a4f2019-09-27 15:23:48 +03004601 /*
4602 * If we reach this point, we have success and just need to apply the
4603 * changes.
4604 *
4605 * Reverse order is used to comfort qcow2 driver: on commit it need to write
4606 * IN_USE flag to the image, to mark bitmaps in the image as invalid. But
4607 * children are usually goes after parents in reopen-queue, so go from last
4608 * to first element.
Jeff Codye971aa12012-09-20 15:13:19 -04004609 */
Vladimir Sementsov-Ogievskiyfcd6a4f2019-09-27 15:23:48 +03004610 QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
Jeff Codye971aa12012-09-20 15:13:19 -04004611 bdrv_reopen_commit(&bs_entry->state);
4612 }
4613
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05004614 bdrv_graph_wrlock();
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004615 tran_commit(tran);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05004616 bdrv_graph_wrunlock();
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004617
4618 QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
4619 BlockDriverState *bs = bs_entry->state.bs;
4620
4621 if (bs->drv->bdrv_reopen_commit_post) {
4622 bs->drv->bdrv_reopen_commit_post(&bs_entry->state);
4623 }
4624 }
4625
Jeff Codye971aa12012-09-20 15:13:19 -04004626 ret = 0;
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004627 goto cleanup;
4628
4629abort:
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05004630 bdrv_graph_wrlock();
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004631 tran_abort(tran);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05004632 bdrv_graph_wrunlock();
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02004633
Vladimir Sementsov-Ogievskiy859443b2019-09-27 15:23:47 +03004634 QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
Vladimir Sementsov-Ogievskiy72373e42021-04-28 18:17:58 +03004635 if (bs_entry->prepared) {
4636 bdrv_reopen_abort(&bs_entry->state);
Kevin Wolf69b736e2019-03-05 17:18:22 +01004637 }
Kevin Wolf69b736e2019-03-05 17:18:22 +01004638 }
Peter Krempa17e1e2b2020-02-28 13:44:46 +01004639
Jeff Codye971aa12012-09-20 15:13:19 -04004640cleanup:
Alberto Garciaab5b52282021-07-08 13:47:05 +02004641 bdrv_reopen_queue_free(bs_queue);
Alberto Garcia40840e42016-10-28 10:08:03 +03004642
Jeff Codye971aa12012-09-20 15:13:19 -04004643 return ret;
4644}
4645
Kevin Wolf6cf42ca2021-07-08 13:47:06 +02004646int bdrv_reopen(BlockDriverState *bs, QDict *opts, bool keep_old_opts,
4647 Error **errp)
4648{
Kevin Wolf6cf42ca2021-07-08 13:47:06 +02004649 BlockReopenQueue *queue;
Kevin Wolf6cf42ca2021-07-08 13:47:06 +02004650
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05004651 GLOBAL_STATE_CODE();
4652
Kevin Wolf2e117862022-11-18 18:41:01 +01004653 queue = bdrv_reopen_queue(NULL, bs, opts, keep_old_opts);
4654
Stefan Hajnoczib49f4752023-12-05 13:20:03 -05004655 return bdrv_reopen_multiple(queue, errp);
Kevin Wolf6cf42ca2021-07-08 13:47:06 +02004656}
4657
Alberto Garcia6e1000a2018-11-12 16:00:33 +02004658int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
4659 Error **errp)
4660{
Alberto Garcia6e1000a2018-11-12 16:00:33 +02004661 QDict *opts = qdict_new();
4662
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05004663 GLOBAL_STATE_CODE();
4664
Alberto Garcia6e1000a2018-11-12 16:00:33 +02004665 qdict_put_bool(opts, BDRV_OPT_READ_ONLY, read_only);
4666
Kevin Wolf6cf42ca2021-07-08 13:47:06 +02004667 return bdrv_reopen(bs, opts, true, errp);
Alberto Garcia6e1000a2018-11-12 16:00:33 +02004668}
4669
Jeff Codye971aa12012-09-20 15:13:19 -04004670/*
Alberto Garciacb828c32019-03-12 18:48:47 +02004671 * Take a BDRVReopenState and check if the value of 'backing' in the
4672 * reopen_state->options QDict is valid or not.
4673 *
4674 * If 'backing' is missing from the QDict then return 0.
4675 *
4676 * If 'backing' contains the node name of the backing file of
4677 * reopen_state->bs then return 0.
4678 *
4679 * If 'backing' contains a different node name (or is null) then check
4680 * whether the current backing file can be replaced with the new one.
4681 * If that's the case then reopen_state->replace_backing_bs is set to
4682 * true and reopen_state->new_backing_bs contains a pointer to the new
4683 * backing BlockDriverState (or NULL).
4684 *
Kevin Wolf5661a002023-09-11 11:46:10 +02004685 * After calling this function, the transaction @tran may only be completed
4686 * while holding a writer lock for the graph.
4687 *
Alberto Garciacb828c32019-03-12 18:48:47 +02004688 * Return 0 on success, otherwise return < 0 and set @errp.
Kevin Wolf4b408662023-06-05 10:57:06 +02004689 *
Kevin Wolf4b408662023-06-05 10:57:06 +02004690 * @reopen_state->bs can move to a different AioContext in this function.
Alberto Garciacb828c32019-03-12 18:48:47 +02004691 */
Kevin Wolfce433d22023-09-29 16:51:43 +02004692static int GRAPH_UNLOCKED
4693bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
4694 bool is_backing, Transaction *tran,
4695 Error **errp)
Alberto Garciacb828c32019-03-12 18:48:47 +02004696{
4697 BlockDriverState *bs = reopen_state->bs;
Alberto Garciaecd30d22021-06-10 15:05:36 +03004698 BlockDriverState *new_child_bs;
Kevin Wolf004915a2023-10-27 17:53:26 +02004699 BlockDriverState *old_child_bs;
4700
Alberto Garciaecd30d22021-06-10 15:05:36 +03004701 const char *child_name = is_backing ? "backing" : "file";
Alberto Garciacb828c32019-03-12 18:48:47 +02004702 QObject *value;
4703 const char *str;
Kevin Wolfce433d22023-09-29 16:51:43 +02004704 bool has_child;
Kevin Wolf4b408662023-06-05 10:57:06 +02004705 int ret;
Alberto Garciacb828c32019-03-12 18:48:47 +02004706
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05004707 GLOBAL_STATE_CODE();
4708
Alberto Garciaecd30d22021-06-10 15:05:36 +03004709 value = qdict_get(reopen_state->options, child_name);
Alberto Garciacb828c32019-03-12 18:48:47 +02004710 if (value == NULL) {
4711 return 0;
4712 }
4713
Kevin Wolf430da832023-10-27 17:53:16 +02004714 bdrv_graph_rdlock_main_loop();
4715
Alberto Garciacb828c32019-03-12 18:48:47 +02004716 switch (qobject_type(value)) {
4717 case QTYPE_QNULL:
Alberto Garciaecd30d22021-06-10 15:05:36 +03004718 assert(is_backing); /* The 'file' option does not allow a null value */
4719 new_child_bs = NULL;
Alberto Garciacb828c32019-03-12 18:48:47 +02004720 break;
4721 case QTYPE_QSTRING:
Markus Armbruster410f44f2020-12-11 18:11:42 +01004722 str = qstring_get_str(qobject_to(QString, value));
Alberto Garciaecd30d22021-06-10 15:05:36 +03004723 new_child_bs = bdrv_lookup_bs(NULL, str, errp);
4724 if (new_child_bs == NULL) {
Kevin Wolf430da832023-10-27 17:53:16 +02004725 ret = -EINVAL;
4726 goto out_rdlock;
Kevin Wolfce433d22023-09-29 16:51:43 +02004727 }
4728
Kevin Wolfce433d22023-09-29 16:51:43 +02004729 has_child = bdrv_recurse_has_child(new_child_bs, bs);
Kevin Wolfce433d22023-09-29 16:51:43 +02004730 if (has_child) {
Alberto Garciaecd30d22021-06-10 15:05:36 +03004731 error_setg(errp, "Making '%s' a %s child of '%s' would create a "
4732 "cycle", str, child_name, bs->node_name);
Kevin Wolf430da832023-10-27 17:53:16 +02004733 ret = -EINVAL;
4734 goto out_rdlock;
Alberto Garciacb828c32019-03-12 18:48:47 +02004735 }
4736 break;
4737 default:
Alberto Garciaecd30d22021-06-10 15:05:36 +03004738 /*
4739 * The options QDict has been flattened, so 'backing' and 'file'
4740 * do not allow any other data type here.
4741 */
Alberto Garciacb828c32019-03-12 18:48:47 +02004742 g_assert_not_reached();
4743 }
4744
Kevin Wolf004915a2023-10-27 17:53:26 +02004745 old_child_bs = is_backing ? child_bs(bs->backing) : child_bs(bs->file);
Alberto Garciaecd30d22021-06-10 15:05:36 +03004746 if (old_child_bs == new_child_bs) {
Kevin Wolf430da832023-10-27 17:53:16 +02004747 ret = 0;
4748 goto out_rdlock;
Alberto Garciaecd30d22021-06-10 15:05:36 +03004749 }
4750
4751 if (old_child_bs) {
4752 if (bdrv_skip_implicit_filters(old_child_bs) == new_child_bs) {
Kevin Wolf430da832023-10-27 17:53:16 +02004753 ret = 0;
4754 goto out_rdlock;
Vladimir Sementsov-Ogievskiycbfdb982021-06-10 15:05:33 +03004755 }
4756
Alberto Garciaecd30d22021-06-10 15:05:36 +03004757 if (old_child_bs->implicit) {
4758 error_setg(errp, "Cannot replace implicit %s child of %s",
4759 child_name, bs->node_name);
Kevin Wolf430da832023-10-27 17:53:16 +02004760 ret = -EPERM;
4761 goto out_rdlock;
Vladimir Sementsov-Ogievskiycbfdb982021-06-10 15:05:33 +03004762 }
4763 }
4764
Alberto Garciaecd30d22021-06-10 15:05:36 +03004765 if (bs->drv->is_filter && !old_child_bs) {
Vladimir Sementsov-Ogievskiy25f78d92021-06-10 15:05:34 +03004766 /*
4767 * Filters always have a file or a backing child, so we are trying to
4768 * change wrong child
4769 */
4770 error_setg(errp, "'%s' is a %s filter node that does not support a "
Alberto Garciaecd30d22021-06-10 15:05:36 +03004771 "%s child", bs->node_name, bs->drv->format_name, child_name);
Kevin Wolf430da832023-10-27 17:53:16 +02004772 ret = -EINVAL;
4773 goto out_rdlock;
Max Reitz1d42f482019-06-12 17:24:39 +02004774 }
4775
Alberto Garciaecd30d22021-06-10 15:05:36 +03004776 if (is_backing) {
4777 reopen_state->old_backing_bs = old_child_bs;
4778 } else {
4779 reopen_state->old_file_bs = old_child_bs;
4780 }
4781
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02004782 if (old_child_bs) {
4783 bdrv_ref(old_child_bs);
4784 bdrv_drained_begin(old_child_bs);
4785 }
4786
Kevin Wolf430da832023-10-27 17:53:16 +02004787 bdrv_graph_rdunlock_main_loop();
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05004788 bdrv_graph_wrlock();
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02004789
Kevin Wolf4b408662023-06-05 10:57:06 +02004790 ret = bdrv_set_file_or_backing_noperm(bs, new_child_bs, is_backing,
4791 tran, errp);
4792
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05004793 bdrv_graph_wrunlock();
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02004794
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02004795 if (old_child_bs) {
4796 bdrv_drained_end(old_child_bs);
4797 bdrv_unref(old_child_bs);
4798 }
4799
Kevin Wolf4b408662023-06-05 10:57:06 +02004800 return ret;
Kevin Wolf430da832023-10-27 17:53:16 +02004801
4802out_rdlock:
4803 bdrv_graph_rdunlock_main_loop();
4804 return ret;
Alberto Garciacb828c32019-03-12 18:48:47 +02004805}
4806
4807/*
Jeff Codye971aa12012-09-20 15:13:19 -04004808 * Prepares a BlockDriverState for reopen. All changes are staged in the
4809 * 'opaque' field of the BDRVReopenState, which is used and allocated by
4810 * the block driver layer .bdrv_reopen_prepare()
4811 *
4812 * bs is the BlockDriverState to reopen
4813 * flags are the new open flags
4814 * queue is the reopen queue
4815 *
4816 * Returns 0 on success, non-zero on error. On error errp will be set
4817 * as well.
4818 *
4819 * On failure, bdrv_reopen_abort() will be called to clean up any data.
4820 * It is the responsibility of the caller to then call the abort() or
4821 * commit() for any other BDS that have been left in a prepare() state
4822 *
Kevin Wolf5661a002023-09-11 11:46:10 +02004823 * After calling this function, the transaction @change_child_tran may only be
4824 * completed while holding a writer lock for the graph.
Jeff Codye971aa12012-09-20 15:13:19 -04004825 */
Kevin Wolfce433d22023-09-29 16:51:43 +02004826static int GRAPH_UNLOCKED
4827bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
4828 Transaction *change_child_tran, Error **errp)
Jeff Codye971aa12012-09-20 15:13:19 -04004829{
4830 int ret = -1;
Alberto Garciae6d79c42018-11-12 16:00:47 +02004831 int old_flags;
Jeff Codye971aa12012-09-20 15:13:19 -04004832 Error *local_err = NULL;
4833 BlockDriver *drv;
Kevin Wolfccf9dc02015-05-08 17:24:56 +02004834 QemuOpts *opts;
Alberto Garcia4c8350f2018-06-29 14:37:02 +03004835 QDict *orig_reopen_opts;
Alberto Garcia593b3072018-09-06 12:37:08 +03004836 char *discard = NULL;
Jeff Cody3d8ce172017-04-07 16:55:30 -04004837 bool read_only;
Max Reitz9ad08c42018-11-16 17:45:24 +01004838 bool drv_prepared = false;
Jeff Codye971aa12012-09-20 15:13:19 -04004839
4840 assert(reopen_state != NULL);
4841 assert(reopen_state->bs->drv != NULL);
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05004842 GLOBAL_STATE_CODE();
Jeff Codye971aa12012-09-20 15:13:19 -04004843 drv = reopen_state->bs->drv;
4844
Alberto Garcia4c8350f2018-06-29 14:37:02 +03004845 /* This function and each driver's bdrv_reopen_prepare() remove
4846 * entries from reopen_state->options as they are processed, so
4847 * we need to make a copy of the original QDict. */
4848 orig_reopen_opts = qdict_clone_shallow(reopen_state->options);
4849
Kevin Wolfccf9dc02015-05-08 17:24:56 +02004850 /* Process generic block layer options */
4851 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
Markus Armbrusteraf175e82020-07-07 18:06:03 +02004852 if (!qemu_opts_absorb_qdict(opts, reopen_state->options, errp)) {
Kevin Wolfccf9dc02015-05-08 17:24:56 +02004853 ret = -EINVAL;
4854 goto error;
4855 }
4856
Alberto Garciae6d79c42018-11-12 16:00:47 +02004857 /* This was already called in bdrv_reopen_queue_child() so the flags
4858 * are up-to-date. This time we simply want to remove the options from
4859 * QemuOpts in order to indicate that they have been processed. */
4860 old_flags = reopen_state->flags;
Kevin Wolf91a097e2015-05-08 17:49:53 +02004861 update_flags_from_options(&reopen_state->flags, opts);
Alberto Garciae6d79c42018-11-12 16:00:47 +02004862 assert(old_flags == reopen_state->flags);
Kevin Wolf91a097e2015-05-08 17:49:53 +02004863
Alberto Garcia415bbca2018-10-03 13:23:13 +03004864 discard = qemu_opt_get_del(opts, BDRV_OPT_DISCARD);
Alberto Garcia593b3072018-09-06 12:37:08 +03004865 if (discard != NULL) {
4866 if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) {
4867 error_setg(errp, "Invalid discard option");
4868 ret = -EINVAL;
4869 goto error;
4870 }
4871 }
4872
Alberto Garcia543770b2018-09-06 12:37:09 +03004873 reopen_state->detect_zeroes =
4874 bdrv_parse_detect_zeroes(opts, reopen_state->flags, &local_err);
4875 if (local_err) {
4876 error_propagate(errp, local_err);
4877 ret = -EINVAL;
4878 goto error;
4879 }
4880
Alberto Garcia57f9db92018-09-06 12:37:06 +03004881 /* All other options (including node-name and driver) must be unchanged.
4882 * Put them back into the QDict, so that they are checked at the end
4883 * of this function. */
4884 qemu_opts_to_qdict(opts, reopen_state->options);
Kevin Wolfccf9dc02015-05-08 17:24:56 +02004885
Jeff Cody3d8ce172017-04-07 16:55:30 -04004886 /* If we are to stay read-only, do not allow permission change
4887 * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
4888 * not set, or if the BDS still has copy_on_read enabled */
4889 read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf4026f1c2023-09-29 16:51:47 +02004890
4891 bdrv_graph_rdlock_main_loop();
Kevin Wolf54a32bf2017-08-03 17:02:58 +02004892 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);
Kevin Wolf4026f1c2023-09-29 16:51:47 +02004893 bdrv_graph_rdunlock_main_loop();
Jeff Cody3d8ce172017-04-07 16:55:30 -04004894 if (local_err) {
4895 error_propagate(errp, local_err);
Jeff Codye971aa12012-09-20 15:13:19 -04004896 goto error;
4897 }
4898
Jeff Codye971aa12012-09-20 15:13:19 -04004899 if (drv->bdrv_reopen_prepare) {
Alberto Garciafaf116b2019-03-12 18:48:49 +02004900 /*
4901 * If a driver-specific option is missing, it means that we
4902 * should reset it to its default value.
4903 * But not all options allow that, so we need to check it first.
4904 */
4905 ret = bdrv_reset_options_allowed(reopen_state->bs,
4906 reopen_state->options, errp);
4907 if (ret) {
4908 goto error;
4909 }
4910
Jeff Codye971aa12012-09-20 15:13:19 -04004911 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
4912 if (ret) {
4913 if (local_err != NULL) {
4914 error_propagate(errp, local_err);
4915 } else {
Kevin Wolfb7cfc7d2023-09-29 16:51:45 +02004916 bdrv_graph_rdlock_main_loop();
Max Reitzf30c66b2019-02-01 20:29:05 +01004917 bdrv_refresh_filename(reopen_state->bs);
Kevin Wolfb7cfc7d2023-09-29 16:51:45 +02004918 bdrv_graph_rdunlock_main_loop();
Luiz Capitulinod8b68952013-06-10 11:29:27 -04004919 error_setg(errp, "failed while preparing to reopen image '%s'",
4920 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04004921 }
4922 goto error;
4923 }
4924 } else {
4925 /* It is currently mandatory to have a bdrv_reopen_prepare()
4926 * handler for each supported drv. */
Kevin Wolf4026f1c2023-09-29 16:51:47 +02004927 bdrv_graph_rdlock_main_loop();
Alberto Garcia81e5f782015-04-08 12:29:19 +03004928 error_setg(errp, "Block format '%s' used by node '%s' "
4929 "does not support reopening files", drv->format_name,
4930 bdrv_get_device_or_node_name(reopen_state->bs));
Kevin Wolf4026f1c2023-09-29 16:51:47 +02004931 bdrv_graph_rdunlock_main_loop();
Jeff Codye971aa12012-09-20 15:13:19 -04004932 ret = -1;
4933 goto error;
4934 }
4935
Max Reitz9ad08c42018-11-16 17:45:24 +01004936 drv_prepared = true;
4937
Alberto Garciabacd9b82019-03-12 18:48:46 +02004938 /*
4939 * We must provide the 'backing' option if the BDS has a backing
4940 * file or if the image file has a backing file name as part of
4941 * its metadata. Otherwise the 'backing' option can be omitted.
4942 */
Kevin Wolf004915a2023-10-27 17:53:26 +02004943 bdrv_graph_rdlock_main_loop();
Alberto Garciabacd9b82019-03-12 18:48:46 +02004944 if (drv->supports_backing && reopen_state->backing_missing &&
Max Reitz1d42f482019-06-12 17:24:39 +02004945 (reopen_state->bs->backing || reopen_state->bs->backing_file[0])) {
Alberto Garcia85466322019-03-12 18:48:45 +02004946 error_setg(errp, "backing is missing for '%s'",
4947 reopen_state->bs->node_name);
Kevin Wolf004915a2023-10-27 17:53:26 +02004948 bdrv_graph_rdunlock_main_loop();
Alberto Garcia85466322019-03-12 18:48:45 +02004949 ret = -EINVAL;
4950 goto error;
4951 }
Kevin Wolf004915a2023-10-27 17:53:26 +02004952 bdrv_graph_rdunlock_main_loop();
Alberto Garcia85466322019-03-12 18:48:45 +02004953
Alberto Garciacb828c32019-03-12 18:48:47 +02004954 /*
4955 * Allow changing the 'backing' option. The new value can be
4956 * either a reference to an existing node (using its node name)
4957 * or NULL to simply detach the current backing file.
4958 */
Alberto Garciaecd30d22021-06-10 15:05:36 +03004959 ret = bdrv_reopen_parse_file_or_backing(reopen_state, true,
4960 change_child_tran, errp);
Alberto Garciacb828c32019-03-12 18:48:47 +02004961 if (ret < 0) {
4962 goto error;
4963 }
4964 qdict_del(reopen_state->options, "backing");
4965
Alberto Garciaecd30d22021-06-10 15:05:36 +03004966 /* Allow changing the 'file' option. In this case NULL is not allowed */
4967 ret = bdrv_reopen_parse_file_or_backing(reopen_state, false,
4968 change_child_tran, errp);
4969 if (ret < 0) {
4970 goto error;
4971 }
4972 qdict_del(reopen_state->options, "file");
4973
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004974 /* Options that are not handled are only okay if they are unchanged
4975 * compared to the old state. It is expected that some options are only
4976 * used for the initial open, but not reopen (e.g. filename) */
4977 if (qdict_size(reopen_state->options)) {
4978 const QDictEntry *entry = qdict_first(reopen_state->options);
4979
Kevin Wolfce433d22023-09-29 16:51:43 +02004980 GRAPH_RDLOCK_GUARD_MAINLOOP();
4981
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004982 do {
Max Reitz54fd1b02017-11-14 19:01:26 +01004983 QObject *new = entry->value;
4984 QObject *old = qdict_get(reopen_state->bs->options, entry->key);
Kevin Wolf4d2cb092015-04-10 17:50:50 +02004985
Alberto Garciadb905282018-09-06 12:37:05 +03004986 /* Allow child references (child_name=node_name) as long as they
4987 * point to the current child (i.e. everything stays the same). */
4988 if (qobject_type(new) == QTYPE_QSTRING) {
4989 BdrvChild *child;
4990 QLIST_FOREACH(child, &reopen_state->bs->children, next) {
4991 if (!strcmp(child->name, entry->key)) {
4992 break;
4993 }
4994 }
4995
4996 if (child) {
Markus Armbruster410f44f2020-12-11 18:11:42 +01004997 if (!strcmp(child->bs->node_name,
4998 qstring_get_str(qobject_to(QString, new)))) {
Alberto Garciadb905282018-09-06 12:37:05 +03004999 continue; /* Found child with this name, skip option */
5000 }
5001 }
5002 }
5003
Max Reitz54fd1b02017-11-14 19:01:26 +01005004 /*
5005 * TODO: When using -drive to specify blockdev options, all values
5006 * will be strings; however, when using -blockdev, blockdev-add or
5007 * filenames using the json:{} pseudo-protocol, they will be
5008 * correctly typed.
5009 * In contrast, reopening options are (currently) always strings
5010 * (because you can only specify them through qemu-io; all other
5011 * callers do not specify any options).
5012 * Therefore, when using anything other than -drive to create a BDS,
5013 * this cannot detect non-string options as unchanged, because
5014 * qobject_is_equal() always returns false for objects of different
5015 * type. In the future, this should be remedied by correctly typing
5016 * all options. For now, this is not too big of an issue because
5017 * the user can simply omit options which cannot be changed anyway,
5018 * so they will stay unchanged.
5019 */
5020 if (!qobject_is_equal(new, old)) {
Kevin Wolf4d2cb092015-04-10 17:50:50 +02005021 error_setg(errp, "Cannot change the option '%s'", entry->key);
5022 ret = -EINVAL;
5023 goto error;
5024 }
5025 } while ((entry = qdict_next(reopen_state->options, entry)));
5026 }
5027
Jeff Codye971aa12012-09-20 15:13:19 -04005028 ret = 0;
5029
Alberto Garcia4c8350f2018-06-29 14:37:02 +03005030 /* Restore the original reopen_state->options QDict */
5031 qobject_unref(reopen_state->options);
5032 reopen_state->options = qobject_ref(orig_reopen_opts);
5033
Jeff Codye971aa12012-09-20 15:13:19 -04005034error:
Max Reitz9ad08c42018-11-16 17:45:24 +01005035 if (ret < 0 && drv_prepared) {
5036 /* drv->bdrv_reopen_prepare() has succeeded, so we need to
5037 * call drv->bdrv_reopen_abort() before signaling an error
5038 * (bdrv_reopen_multiple() will not call bdrv_reopen_abort()
5039 * when the respective bdrv_reopen_prepare() has failed) */
5040 if (drv->bdrv_reopen_abort) {
5041 drv->bdrv_reopen_abort(reopen_state);
5042 }
5043 }
Kevin Wolfccf9dc02015-05-08 17:24:56 +02005044 qemu_opts_del(opts);
Alberto Garcia4c8350f2018-06-29 14:37:02 +03005045 qobject_unref(orig_reopen_opts);
Alberto Garcia593b3072018-09-06 12:37:08 +03005046 g_free(discard);
Jeff Codye971aa12012-09-20 15:13:19 -04005047 return ret;
5048}
5049
5050/*
5051 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
5052 * makes them final by swapping the staging BlockDriverState contents into
5053 * the active BlockDriverState contents.
5054 */
Kevin Wolfce433d22023-09-29 16:51:43 +02005055static void GRAPH_UNLOCKED bdrv_reopen_commit(BDRVReopenState *reopen_state)
Jeff Codye971aa12012-09-20 15:13:19 -04005056{
5057 BlockDriver *drv;
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03005058 BlockDriverState *bs;
Alberto Garcia50196d72018-09-06 12:37:03 +03005059 BdrvChild *child;
Jeff Codye971aa12012-09-20 15:13:19 -04005060
5061 assert(reopen_state != NULL);
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03005062 bs = reopen_state->bs;
5063 drv = bs->drv;
Jeff Codye971aa12012-09-20 15:13:19 -04005064 assert(drv != NULL);
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05005065 GLOBAL_STATE_CODE();
Jeff Codye971aa12012-09-20 15:13:19 -04005066
5067 /* If there are any driver level actions to take */
5068 if (drv->bdrv_reopen_commit) {
5069 drv->bdrv_reopen_commit(reopen_state);
5070 }
5071
Kevin Wolfce433d22023-09-29 16:51:43 +02005072 GRAPH_RDLOCK_GUARD_MAINLOOP();
5073
Jeff Codye971aa12012-09-20 15:13:19 -04005074 /* set BDS specific flags now */
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02005075 qobject_unref(bs->explicit_options);
Alberto Garcia4c8350f2018-06-29 14:37:02 +03005076 qobject_unref(bs->options);
Alberto Garciaab5b52282021-07-08 13:47:05 +02005077 qobject_ref(reopen_state->explicit_options);
5078 qobject_ref(reopen_state->options);
Kevin Wolf145f5982015-05-08 16:15:03 +02005079
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03005080 bs->explicit_options = reopen_state->explicit_options;
Alberto Garcia4c8350f2018-06-29 14:37:02 +03005081 bs->options = reopen_state->options;
Vladimir Sementsov-Ogievskiy50bf65b2017-06-28 15:05:12 +03005082 bs->open_flags = reopen_state->flags;
Alberto Garcia543770b2018-09-06 12:37:09 +03005083 bs->detect_zeroes = reopen_state->detect_zeroes;
Kevin Wolf355ef4a2013-12-11 20:14:09 +01005084
Alberto Garcia50196d72018-09-06 12:37:03 +03005085 /* Remove child references from bs->options and bs->explicit_options.
5086 * Child options were already removed in bdrv_reopen_queue_child() */
5087 QLIST_FOREACH(child, &bs->children, next) {
5088 qdict_del(bs->explicit_options, child->name);
5089 qdict_del(bs->options, child->name);
5090 }
Vladimir Sementsov-Ogievskiy3d0e8742021-06-10 15:05:35 +03005091 /* backing is probably removed, so it's not handled by previous loop */
5092 qdict_del(bs->explicit_options, "backing");
5093 qdict_del(bs->options, "backing");
5094
Vladimir Sementsov-Ogievskiy1e4c7972021-04-28 18:17:55 +03005095 bdrv_refresh_limits(bs, NULL, NULL);
Paolo Bonzini439cc332023-04-07 17:32:58 +02005096 bdrv_refresh_total_sectors(bs, bs->total_sectors);
Jeff Codye971aa12012-09-20 15:13:19 -04005097}
5098
5099/*
5100 * Abort the reopen, and delete and free the staged changes in
5101 * reopen_state
5102 */
Kevin Wolfce433d22023-09-29 16:51:43 +02005103static void GRAPH_UNLOCKED bdrv_reopen_abort(BDRVReopenState *reopen_state)
Jeff Codye971aa12012-09-20 15:13:19 -04005104{
5105 BlockDriver *drv;
5106
5107 assert(reopen_state != NULL);
5108 drv = reopen_state->bs->drv;
5109 assert(drv != NULL);
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05005110 GLOBAL_STATE_CODE();
Jeff Codye971aa12012-09-20 15:13:19 -04005111
5112 if (drv->bdrv_reopen_abort) {
5113 drv->bdrv_reopen_abort(reopen_state);
5114 }
5115}
5116
5117
Max Reitz64dff522016-01-29 16:36:10 +01005118static void bdrv_close(BlockDriverState *bs)
bellardfc01f7e2003-06-30 10:03:06 +00005119{
Max Reitz33384422014-06-20 21:57:33 +02005120 BdrvAioNotifier *ban, *ban_next;
Alberto Garcia50a3efb2017-11-06 16:53:45 +02005121 BdrvChild *child, *next;
Max Reitz33384422014-06-20 21:57:33 +02005122
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005123 GLOBAL_STATE_CODE();
Max Reitz30f55fb2016-05-17 16:41:32 +02005124 assert(!bs->refcnt);
Alberto Garcia99b7e772015-09-25 16:41:44 +03005125
Paolo Bonzinifc272912015-12-23 11:48:24 +01005126 bdrv_drained_begin(bs); /* complete I/O */
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02005127 bdrv_flush(bs);
Fam Zheng53ec73e2015-05-29 18:53:14 +08005128 bdrv_drain(bs); /* in case flush left pending I/O */
Paolo Bonzinifc272912015-12-23 11:48:24 +01005129
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02005130 if (bs->drv) {
Vladimir Sementsov-Ogievskiy3c005292018-08-14 15:43:19 +03005131 if (bs->drv->bdrv_close) {
Max Reitz7b99a262019-06-12 16:07:11 +02005132 /* Must unfreeze all children, so bdrv_unref_child() works */
Vladimir Sementsov-Ogievskiy3c005292018-08-14 15:43:19 +03005133 bs->drv->bdrv_close(bs);
5134 }
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02005135 bs->drv = NULL;
bellardb3380822004-03-14 21:38:54 +00005136 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08005137
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005138 bdrv_graph_wrlock();
Alberto Garcia50a3efb2017-11-06 16:53:45 +02005139 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
Alberto Garciadd4118c2019-05-13 16:46:17 +03005140 bdrv_unref_child(bs, child);
Alberto Garcia50a3efb2017-11-06 16:53:45 +02005141 }
5142
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03005143 assert(!bs->backing);
5144 assert(!bs->file);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005145 bdrv_graph_wrunlock();
Kevin Wolf004915a2023-10-27 17:53:26 +02005146
Alberto Garcia50a3efb2017-11-06 16:53:45 +02005147 g_free(bs->opaque);
5148 bs->opaque = NULL;
Stefan Hajnoczid73415a2020-09-23 11:56:46 +01005149 qatomic_set(&bs->copy_on_read, 0);
Alberto Garcia50a3efb2017-11-06 16:53:45 +02005150 bs->backing_file[0] = '\0';
5151 bs->backing_format[0] = '\0';
5152 bs->total_sectors = 0;
5153 bs->encrypted = false;
5154 bs->sg = false;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02005155 qobject_unref(bs->options);
5156 qobject_unref(bs->explicit_options);
Alberto Garcia50a3efb2017-11-06 16:53:45 +02005157 bs->options = NULL;
5158 bs->explicit_options = NULL;
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02005159 qobject_unref(bs->full_open_options);
Alberto Garcia50a3efb2017-11-06 16:53:45 +02005160 bs->full_open_options = NULL;
Hanna Reitz0bc329f2021-08-12 10:41:44 +02005161 g_free(bs->block_status_cache);
5162 bs->block_status_cache = NULL;
Alberto Garcia50a3efb2017-11-06 16:53:45 +02005163
Vladimir Sementsov-Ogievskiycca43ae2017-06-28 15:05:16 +03005164 bdrv_release_named_dirty_bitmaps(bs);
5165 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
5166
Max Reitz33384422014-06-20 21:57:33 +02005167 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
5168 g_free(ban);
5169 }
5170 QLIST_INIT(&bs->aio_notifiers);
Paolo Bonzinifc272912015-12-23 11:48:24 +01005171 bdrv_drained_end(bs);
Greg Kurz1a6d3bd2020-10-23 17:01:10 +02005172
5173 /*
5174 * If we're still inside some bdrv_drain_all_begin()/end() sections, end
5175 * them now since this BDS won't exist anymore when bdrv_drain_all_end()
5176 * gets called.
5177 */
5178 if (bs->quiesce_counter) {
5179 bdrv_drain_all_end_quiesce(bs);
5180 }
bellardb3380822004-03-14 21:38:54 +00005181}
5182
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09005183void bdrv_close_all(void)
5184{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005185 GLOBAL_STATE_CODE();
Emanuele Giuseppe Esposito880eeec2022-09-26 05:32:04 -04005186 assert(job_next(NULL) == NULL);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09005187
Max Reitzca9bd242016-01-29 16:36:14 +01005188 /* Drop references from requests still in flight, such as canceled block
5189 * jobs whose AIO context has not been polled yet */
5190 bdrv_drain_all();
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02005191
Max Reitzca9bd242016-01-29 16:36:14 +01005192 blk_remove_all_bs();
5193 blockdev_close_all_bdrv_states();
5194
Kevin Wolfa1a2af02016-04-08 18:26:37 +02005195 assert(QTAILQ_EMPTY(&all_bdrv_states));
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09005196}
5197
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005198static bool GRAPH_RDLOCK should_update_child(BdrvChild *c, BlockDriverState *to)
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02005199{
Vladimir Sementsov-Ogievskiy2f30b7c2019-02-23 22:20:39 +03005200 GQueue *queue;
5201 GHashTable *found;
5202 bool ret;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02005203
Max Reitzbd86fb92020-05-13 13:05:13 +02005204 if (c->klass->stay_at_node) {
Kevin Wolfd0ac0382017-03-01 17:30:41 +01005205 return false;
5206 }
5207
Max Reitzec9f10f2018-06-13 20:18:15 +02005208 /* If the child @c belongs to the BDS @to, replacing the current
5209 * c->bs by @to would mean to create a loop.
5210 *
5211 * Such a case occurs when appending a BDS to a backing chain.
5212 * For instance, imagine the following chain:
5213 *
5214 * guest device -> node A -> further backing chain...
5215 *
5216 * Now we create a new BDS B which we want to put on top of this
5217 * chain, so we first attach A as its backing node:
5218 *
5219 * node B
5220 * |
5221 * v
5222 * guest device -> node A -> further backing chain...
5223 *
5224 * Finally we want to replace A by B. When doing that, we want to
5225 * replace all pointers to A by pointers to B -- except for the
5226 * pointer from B because (1) that would create a loop, and (2)
5227 * that pointer should simply stay intact:
5228 *
5229 * guest device -> node B
5230 * |
5231 * v
5232 * node A -> further backing chain...
5233 *
5234 * In general, when replacing a node A (c->bs) by a node B (@to),
5235 * if A is a child of B, that means we cannot replace A by B there
5236 * because that would create a loop. Silently detaching A from B
5237 * is also not really an option. So overall just leaving A in
Vladimir Sementsov-Ogievskiy2f30b7c2019-02-23 22:20:39 +03005238 * place there is the most sensible choice.
5239 *
5240 * We would also create a loop in any cases where @c is only
5241 * indirectly referenced by @to. Prevent this by returning false
5242 * if @c is found (by breadth-first search) anywhere in the whole
5243 * subtree of @to.
5244 */
5245
5246 ret = true;
5247 found = g_hash_table_new(NULL, NULL);
5248 g_hash_table_add(found, to);
5249 queue = g_queue_new();
5250 g_queue_push_tail(queue, to);
5251
5252 while (!g_queue_is_empty(queue)) {
5253 BlockDriverState *v = g_queue_pop_head(queue);
5254 BdrvChild *c2;
5255
5256 QLIST_FOREACH(c2, &v->children, next) {
5257 if (c2 == c) {
5258 ret = false;
5259 break;
5260 }
5261
5262 if (g_hash_table_contains(found, c2->bs)) {
5263 continue;
5264 }
5265
5266 g_queue_push_tail(queue, c2->bs);
5267 g_hash_table_add(found, c2->bs);
Kevin Wolfd0ac0382017-03-01 17:30:41 +01005268 }
5269 }
5270
Vladimir Sementsov-Ogievskiy2f30b7c2019-02-23 22:20:39 +03005271 g_queue_free(queue);
5272 g_hash_table_destroy(found);
5273
5274 return ret;
Kevin Wolfd0ac0382017-03-01 17:30:41 +01005275}
5276
Vladimir Sementsov-Ogievskiy57f08942022-07-26 23:11:34 +03005277static void bdrv_remove_child_commit(void *opaque)
Vladimir Sementsov-Ogievskiy46541ee2021-04-28 18:17:50 +03005278{
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05005279 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03005280 bdrv_child_free(opaque);
Vladimir Sementsov-Ogievskiy46541ee2021-04-28 18:17:50 +03005281}
5282
Vladimir Sementsov-Ogievskiy57f08942022-07-26 23:11:34 +03005283static TransactionActionDrv bdrv_remove_child_drv = {
5284 .commit = bdrv_remove_child_commit,
Vladimir Sementsov-Ogievskiy46541ee2021-04-28 18:17:50 +03005285};
5286
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005287/*
5288 * Function doesn't update permissions, caller is responsible for this.
5289 *
5290 * @child->bs (if non-NULL) must be drained.
Kevin Wolf5661a002023-09-11 11:46:10 +02005291 *
5292 * After calling this function, the transaction @tran may only be completed
5293 * while holding a writer lock for the graph.
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005294 */
5295static void GRAPH_WRLOCK bdrv_remove_child(BdrvChild *child, Transaction *tran)
Vladimir Sementsov-Ogievskiy46541ee2021-04-28 18:17:50 +03005296{
Vladimir Sementsov-Ogievskiy46541ee2021-04-28 18:17:50 +03005297 if (!child) {
5298 return;
5299 }
5300
5301 if (child->bs) {
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005302 assert(child->quiesced_parent);
Vladimir Sementsov-Ogievskiya2c37a32022-07-26 23:11:30 +03005303 bdrv_replace_child_tran(child, NULL, tran);
Vladimir Sementsov-Ogievskiy46541ee2021-04-28 18:17:50 +03005304 }
5305
Vladimir Sementsov-Ogievskiy57f08942022-07-26 23:11:34 +03005306 tran_add(tran, &bdrv_remove_child_drv, child);
Vladimir Sementsov-Ogievskiy46541ee2021-04-28 18:17:50 +03005307}
5308
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005309/*
5310 * Both @from and @to (if non-NULL) must be drained. @to must be kept drained
5311 * until the transaction is completed.
Kevin Wolf5661a002023-09-11 11:46:10 +02005312 *
5313 * After calling this function, the transaction @tran may only be completed
5314 * while holding a writer lock for the graph.
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005315 */
5316static int GRAPH_WRLOCK
5317bdrv_replace_node_noperm(BlockDriverState *from,
5318 BlockDriverState *to,
5319 bool auto_skip, Transaction *tran,
5320 Error **errp)
Vladimir Sementsov-Ogievskiy117caba2021-04-28 18:17:48 +03005321{
5322 BdrvChild *c, *next;
5323
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05005324 GLOBAL_STATE_CODE();
Hanna Reitz82b54cf2021-11-15 15:54:04 +01005325
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005326 assert(from->quiesce_counter);
5327 assert(to->quiesce_counter);
Kevin Wolf23987472022-11-18 18:41:09 +01005328
Vladimir Sementsov-Ogievskiy117caba2021-04-28 18:17:48 +03005329 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
5330 assert(c->bs == from);
5331 if (!should_update_child(c, to)) {
5332 if (auto_skip) {
5333 continue;
5334 }
5335 error_setg(errp, "Should not change '%s' link to '%s'",
5336 c->name, from->node_name);
5337 return -EINVAL;
5338 }
5339 if (c->frozen) {
5340 error_setg(errp, "Cannot change '%s' link to '%s'",
5341 c->name, from->node_name);
5342 return -EPERM;
5343 }
Vladimir Sementsov-Ogievskiy0f0b1e22022-07-26 23:11:29 +03005344 bdrv_replace_child_tran(c, to, tran);
Vladimir Sementsov-Ogievskiy117caba2021-04-28 18:17:48 +03005345 }
5346
5347 return 0;
5348}
5349
Vladimir Sementsov-Ogievskiy313274b2020-11-06 15:42:36 +03005350/*
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005351 * Switch all parents of @from to point to @to instead. @from and @to must be in
5352 * the same AioContext and both must be drained.
5353 *
Vladimir Sementsov-Ogievskiy313274b2020-11-06 15:42:36 +03005354 * With auto_skip=true bdrv_replace_node_common skips updating from parents
5355 * if it creates a parent-child relation loop or if parent is block-job.
5356 *
5357 * With auto_skip=false the error is returned if from has a parent which should
5358 * not be updated.
Vladimir Sementsov-Ogievskiy3108a152021-04-28 18:17:51 +03005359 *
5360 * With @detach_subchain=true @to must be in a backing chain of @from. In this
5361 * case backing link of the cow-parent of @to is removed.
Vladimir Sementsov-Ogievskiy313274b2020-11-06 15:42:36 +03005362 */
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005363static int GRAPH_WRLOCK
5364bdrv_replace_node_common(BlockDriverState *from, BlockDriverState *to,
5365 bool auto_skip, bool detach_subchain, Error **errp)
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02005366{
Vladimir Sementsov-Ogievskiy3bb0e292021-04-28 18:17:45 +03005367 Transaction *tran = tran_new();
Vladimir Sementsov-Ogievskiy3bb0e292021-04-28 18:17:45 +03005368 g_autoptr(GSList) refresh_list = NULL;
Miroslav Rezanina2d369d62021-05-05 03:59:03 -04005369 BlockDriverState *to_cow_parent = NULL;
Kevin Wolf234ac1a2017-03-02 18:43:00 +01005370 int ret;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02005371
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05005372 GLOBAL_STATE_CODE();
Hanna Reitz82b54cf2021-11-15 15:54:04 +01005373
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005374 assert(from->quiesce_counter);
5375 assert(to->quiesce_counter);
Kevin Wolf30dd65f2020-03-10 12:38:29 +01005376 assert(bdrv_get_aio_context(from) == bdrv_get_aio_context(to));
Kevin Wolff871abd2019-05-21 19:00:25 +02005377
Kevin Wolf372b69f2023-10-27 17:53:15 +02005378 if (detach_subchain) {
5379 assert(bdrv_chain_contains(from, to));
5380 assert(from != to);
5381 for (to_cow_parent = from;
5382 bdrv_filter_or_cow_bs(to_cow_parent) != to;
5383 to_cow_parent = bdrv_filter_or_cow_bs(to_cow_parent))
5384 {
5385 ;
5386 }
5387 }
5388
Vladimir Sementsov-Ogievskiy3bb0e292021-04-28 18:17:45 +03005389 /*
5390 * Do the replacement without permission update.
5391 * Replacement may influence the permissions, we should calculate new
5392 * permissions based on new graph. If we fail, we'll roll-back the
5393 * replacement.
5394 */
Vladimir Sementsov-Ogievskiy117caba2021-04-28 18:17:48 +03005395 ret = bdrv_replace_node_noperm(from, to, auto_skip, tran, errp);
5396 if (ret < 0) {
5397 goto out;
Kevin Wolf234ac1a2017-03-02 18:43:00 +01005398 }
5399
Vladimir Sementsov-Ogievskiy3108a152021-04-28 18:17:51 +03005400 if (detach_subchain) {
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005401 /* to_cow_parent is already drained because from is drained */
Vladimir Sementsov-Ogievskiyf38eaec2022-11-07 19:35:56 +03005402 bdrv_remove_child(bdrv_filter_or_cow_child(to_cow_parent), tran);
Vladimir Sementsov-Ogievskiy3108a152021-04-28 18:17:51 +03005403 }
5404
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03005405 refresh_list = g_slist_prepend(refresh_list, to);
5406 refresh_list = g_slist_prepend(refresh_list, from);
Vladimir Sementsov-Ogievskiy3bb0e292021-04-28 18:17:45 +03005407
5408 ret = bdrv_list_refresh_perms(refresh_list, NULL, tran, errp);
Kevin Wolf234ac1a2017-03-02 18:43:00 +01005409 if (ret < 0) {
Kevin Wolf234ac1a2017-03-02 18:43:00 +01005410 goto out;
5411 }
5412
Vladimir Sementsov-Ogievskiya1e708f2021-02-02 15:49:43 +03005413 ret = 0;
5414
Kevin Wolf234ac1a2017-03-02 18:43:00 +01005415out:
Vladimir Sementsov-Ogievskiy3bb0e292021-04-28 18:17:45 +03005416 tran_finalize(tran, ret);
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005417 return ret;
5418}
Vladimir Sementsov-Ogievskiy3bb0e292021-04-28 18:17:45 +03005419
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005420int bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
5421 Error **errp)
5422{
Kevin Wolfccd6a372023-10-27 17:53:25 +02005423 return bdrv_replace_node_common(from, to, true, false, errp);
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02005424}
5425
Vladimir Sementsov-Ogievskiy3108a152021-04-28 18:17:51 +03005426int bdrv_drop_filter(BlockDriverState *bs, Error **errp)
5427{
Kevin Wolf372b69f2023-10-27 17:53:15 +02005428 BlockDriverState *child_bs;
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005429 int ret;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005430
Kevin Wolf372b69f2023-10-27 17:53:15 +02005431 GLOBAL_STATE_CODE();
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005432
Kevin Wolf372b69f2023-10-27 17:53:15 +02005433 bdrv_graph_rdlock_main_loop();
5434 child_bs = bdrv_filter_or_cow_bs(bs);
5435 bdrv_graph_rdunlock_main_loop();
5436
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005437 bdrv_drained_begin(child_bs);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005438 bdrv_graph_wrlock();
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005439 ret = bdrv_replace_node_common(bs, child_bs, true, true, errp);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005440 bdrv_graph_wrunlock();
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005441 bdrv_drained_end(child_bs);
5442
5443 return ret;
Vladimir Sementsov-Ogievskiy313274b2020-11-06 15:42:36 +03005444}
5445
Jeff Cody8802d1f2012-02-28 15:54:06 -05005446/*
5447 * Add new bs contents at the top of an image chain while the chain is
5448 * live, while keeping required fields on the top layer.
5449 *
5450 * This will modify the BlockDriverState fields, and swap contents
5451 * between bs_new and bs_top. Both bs_new and bs_top are modified.
5452 *
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005453 * bs_new must not be attached to a BlockBackend and must not have backing
5454 * child.
Jeff Codyf6801b82012-03-27 16:30:19 -04005455 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05005456 * This function does not create any image files.
5457 */
Vladimir Sementsov-Ogievskiya1e708f2021-02-02 15:49:43 +03005458int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
5459 Error **errp)
Jeff Cody8802d1f2012-02-28 15:54:06 -05005460{
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005461 int ret;
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03005462 BdrvChild *child;
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005463 Transaction *tran = tran_new();
5464
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005465 GLOBAL_STATE_CODE();
5466
Kevin Wolf004915a2023-10-27 17:53:26 +02005467 bdrv_graph_rdlock_main_loop();
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005468 assert(!bs_new->backing);
Kevin Wolf004915a2023-10-27 17:53:26 +02005469 bdrv_graph_rdunlock_main_loop();
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005470
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02005471 bdrv_drained_begin(bs_top);
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02005472 bdrv_drained_begin(bs_new);
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02005473
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005474 bdrv_graph_wrlock();
Stefano Garzarella60d90bf2023-02-14 18:16:21 +01005475
Vladimir Sementsov-Ogievskiy5bb047472022-07-26 23:11:32 +03005476 child = bdrv_attach_child_noperm(bs_new, bs_top, "backing",
5477 &child_of_bds, bdrv_backing_role(bs_new),
5478 tran, errp);
5479 if (!child) {
5480 ret = -EINVAL;
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005481 goto out;
Kevin Wolfb2c28322017-02-20 12:46:42 +01005482 }
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02005483
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005484 ret = bdrv_replace_node_noperm(bs_top, bs_new, true, tran, errp);
Vladimir Sementsov-Ogievskiya1e708f2021-02-02 15:49:43 +03005485 if (ret < 0) {
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005486 goto out;
Kevin Wolf234ac1a2017-03-02 18:43:00 +01005487 }
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02005488
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03005489 ret = bdrv_refresh_perms(bs_new, tran, errp);
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005490out:
5491 tran_finalize(tran, ret);
5492
Vladimir Sementsov-Ogievskiy1e4c7972021-04-28 18:17:55 +03005493 bdrv_refresh_limits(bs_top, NULL, NULL);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005494 bdrv_graph_wrunlock();
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005495
Kevin Wolf7d4ca9d2023-09-11 11:46:09 +02005496 bdrv_drained_end(bs_top);
5497 bdrv_drained_end(bs_new);
Kevin Wolf2f64e1f2023-09-11 11:46:08 +02005498
Vladimir Sementsov-Ogievskiy2272edc2021-04-28 18:17:49 +03005499 return ret;
Jeff Cody8802d1f2012-02-28 15:54:06 -05005500}
5501
Vladimir Sementsov-Ogievskiybd8f4c42021-08-24 11:38:23 +03005502/* Not for empty child */
5503int bdrv_replace_child_bs(BdrvChild *child, BlockDriverState *new_bs,
5504 Error **errp)
5505{
5506 int ret;
5507 Transaction *tran = tran_new();
Vladimir Sementsov-Ogievskiybd8f4c42021-08-24 11:38:23 +03005508 g_autoptr(GSList) refresh_list = NULL;
5509 BlockDriverState *old_bs = child->bs;
5510
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005511 GLOBAL_STATE_CODE();
5512
Vladimir Sementsov-Ogievskiybd8f4c42021-08-24 11:38:23 +03005513 bdrv_ref(old_bs);
5514 bdrv_drained_begin(old_bs);
5515 bdrv_drained_begin(new_bs);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005516 bdrv_graph_wrlock();
Vladimir Sementsov-Ogievskiybd8f4c42021-08-24 11:38:23 +03005517
Vladimir Sementsov-Ogievskiy0f0b1e22022-07-26 23:11:29 +03005518 bdrv_replace_child_tran(child, new_bs, tran);
Vladimir Sementsov-Ogievskiybd8f4c42021-08-24 11:38:23 +03005519
Vladimir Sementsov-Ogievskiyfb0ff4d2022-11-07 19:35:58 +03005520 refresh_list = g_slist_prepend(refresh_list, old_bs);
5521 refresh_list = g_slist_prepend(refresh_list, new_bs);
Vladimir Sementsov-Ogievskiybd8f4c42021-08-24 11:38:23 +03005522
5523 ret = bdrv_list_refresh_perms(refresh_list, NULL, tran, errp);
5524
5525 tran_finalize(tran, ret);
5526
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005527 bdrv_graph_wrunlock();
Vladimir Sementsov-Ogievskiybd8f4c42021-08-24 11:38:23 +03005528 bdrv_drained_end(old_bs);
5529 bdrv_drained_end(new_bs);
5530 bdrv_unref(old_bs);
5531
5532 return ret;
5533}
5534
Fam Zheng4f6fd342013-08-23 09:14:47 +08005535static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00005536{
Fam Zheng3718d8a2014-05-23 21:29:43 +08005537 assert(bdrv_op_blocker_is_empty(bs));
Fam Zheng4f6fd342013-08-23 09:14:47 +08005538 assert(!bs->refcnt);
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005539 GLOBAL_STATE_CODE();
Markus Armbruster18846de2010-06-29 16:58:30 +02005540
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01005541 /* remove from list, if necessary */
Kevin Wolf63eaaae2016-03-18 10:46:57 +01005542 if (bs->node_name[0] != '\0') {
5543 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
5544 }
Max Reitz2c1d04e2016-01-29 16:36:11 +01005545 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
5546
Anton Kuchin30c321f2019-05-07 11:12:56 +03005547 bdrv_close(bs);
5548
Stefan Hajnoczifa9185f2023-08-08 11:58:52 -04005549 qemu_mutex_destroy(&bs->reqs_lock);
5550
Anthony Liguori7267c092011-08-20 22:09:37 -05005551 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00005552}
5553
Vladimir Sementsov-Ogievskiy96796fa2021-09-20 14:55:36 +03005554
5555/*
5556 * Replace @bs by newly created block node.
5557 *
5558 * @options is a QDict of options to pass to the block drivers, or NULL for an
5559 * empty set of options. The reference to the QDict belongs to the block layer
5560 * after the call (even on failure), so if the caller intends to reuse the
5561 * dictionary, it needs to use qobject_ref() before calling bdrv_open.
Kevin Wolf88234072023-05-25 14:47:11 +02005562 *
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05005563 * The caller must make sure that @bs stays in the same AioContext, i.e.
5564 * @options must not refer to nodes in a different AioContext.
Vladimir Sementsov-Ogievskiy96796fa2021-09-20 14:55:36 +03005565 */
5566BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *options,
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005567 int flags, Error **errp)
5568{
Vladimir Sementsov-Ogievskiyf053b7e2021-09-20 14:55:35 +03005569 ERRP_GUARD();
5570 int ret;
Kevin Wolf88234072023-05-25 14:47:11 +02005571 AioContext *ctx = bdrv_get_aio_context(bs);
Vladimir Sementsov-Ogievskiyb11c8732021-09-20 14:55:37 +03005572 BlockDriverState *new_node_bs = NULL;
5573 const char *drvname, *node_name;
5574 BlockDriver *drv;
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005575
Vladimir Sementsov-Ogievskiyb11c8732021-09-20 14:55:37 +03005576 drvname = qdict_get_try_str(options, "driver");
5577 if (!drvname) {
5578 error_setg(errp, "driver is not specified");
5579 goto fail;
5580 }
5581
5582 drv = bdrv_find_format(drvname);
5583 if (!drv) {
5584 error_setg(errp, "Unknown driver: '%s'", drvname);
5585 goto fail;
5586 }
5587
5588 node_name = qdict_get_try_str(options, "node-name");
5589
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005590 GLOBAL_STATE_CODE();
5591
Vladimir Sementsov-Ogievskiyb11c8732021-09-20 14:55:37 +03005592 new_node_bs = bdrv_new_open_driver_opts(drv, node_name, options, flags,
5593 errp);
Kevin Wolf88234072023-05-25 14:47:11 +02005594 assert(bdrv_get_aio_context(bs) == ctx);
5595
Vladimir Sementsov-Ogievskiyb11c8732021-09-20 14:55:37 +03005596 options = NULL; /* bdrv_new_open_driver() eats options */
5597 if (!new_node_bs) {
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005598 error_prepend(errp, "Could not create node: ");
Vladimir Sementsov-Ogievskiyb11c8732021-09-20 14:55:37 +03005599 goto fail;
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005600 }
5601
Kevin Wolfccd6a372023-10-27 17:53:25 +02005602 /*
5603 * Make sure that @bs doesn't go away until we have successfully attached
5604 * all of its parents to @new_node_bs and undrained it again.
5605 */
5606 bdrv_ref(bs);
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005607 bdrv_drained_begin(bs);
Kevin Wolfccd6a372023-10-27 17:53:25 +02005608 bdrv_drained_begin(new_node_bs);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005609 bdrv_graph_wrlock();
Vladimir Sementsov-Ogievskiyf053b7e2021-09-20 14:55:35 +03005610 ret = bdrv_replace_node(bs, new_node_bs, errp);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005611 bdrv_graph_wrunlock();
Kevin Wolfccd6a372023-10-27 17:53:25 +02005612 bdrv_drained_end(new_node_bs);
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005613 bdrv_drained_end(bs);
Kevin Wolfccd6a372023-10-27 17:53:25 +02005614 bdrv_unref(bs);
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005615
Vladimir Sementsov-Ogievskiyf053b7e2021-09-20 14:55:35 +03005616 if (ret < 0) {
5617 error_prepend(errp, "Could not replace node: ");
Vladimir Sementsov-Ogievskiyb11c8732021-09-20 14:55:37 +03005618 goto fail;
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005619 }
5620
5621 return new_node_bs;
Vladimir Sementsov-Ogievskiyb11c8732021-09-20 14:55:37 +03005622
5623fail:
5624 qobject_unref(options);
5625 bdrv_unref(new_node_bs);
5626 return NULL;
Andrey Shinkevich8872ef72020-12-16 09:16:52 +03005627}
5628
aliguorie97fc192009-04-21 23:11:50 +00005629/*
5630 * Run consistency checks on an image
5631 *
Kevin Wolfe076f332010-06-29 11:43:13 +02005632 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02005633 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02005634 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00005635 */
Vladimir Sementsov-Ogievskiy21c22832020-09-24 21:54:10 +03005636int coroutine_fn bdrv_co_check(BlockDriverState *bs,
5637 BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00005638{
Emanuele Giuseppe Esposito1581a702022-03-03 10:16:09 -05005639 IO_CODE();
Kevin Wolf1b3ff9f2022-12-07 14:18:38 +01005640 assert_bdrv_graph_readable();
Max Reitz908bcd52014-08-07 22:47:55 +02005641 if (bs->drv == NULL) {
5642 return -ENOMEDIUM;
5643 }
Paolo Bonzini2fd61632018-03-01 17:36:19 +01005644 if (bs->drv->bdrv_co_check == NULL) {
aliguorie97fc192009-04-21 23:11:50 +00005645 return -ENOTSUP;
5646 }
5647
Kevin Wolfe076f332010-06-29 11:43:13 +02005648 memset(res, 0, sizeof(*res));
Paolo Bonzini2fd61632018-03-01 17:36:19 +01005649 return bs->drv->bdrv_co_check(bs, res, fix);
5650}
5651
Kevin Wolf756e6732010-01-12 12:55:17 +01005652/*
5653 * Return values:
5654 * 0 - success
5655 * -EINVAL - backing format specified, but no file
5656 * -ENOSPC - can't update the backing file because no space is left in the
5657 * image file header
5658 * -ENOTSUP - format driver doesn't support changing the backing file
5659 */
Kevin Wolfe2dd2732023-10-27 17:53:28 +02005660int coroutine_fn
5661bdrv_co_change_backing_file(BlockDriverState *bs, const char *backing_file,
5662 const char *backing_fmt, bool require)
Kevin Wolf756e6732010-01-12 12:55:17 +01005663{
5664 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02005665 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01005666
Kevin Wolfe2dd2732023-10-27 17:53:28 +02005667 IO_CODE();
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005668
Max Reitzd470ad42017-11-10 21:31:09 +01005669 if (!drv) {
5670 return -ENOMEDIUM;
5671 }
5672
Paolo Bonzini5f377792012-04-12 14:01:01 +02005673 /* Backing file format doesn't make sense without a backing file */
5674 if (backing_fmt && !backing_file) {
5675 return -EINVAL;
5676 }
5677
Eric Blake497a30d2021-05-03 14:36:00 -07005678 if (require && backing_file && !backing_fmt) {
5679 return -EINVAL;
Eric Blakee54ee1b2020-07-06 15:39:53 -05005680 }
5681
Kevin Wolfe2dd2732023-10-27 17:53:28 +02005682 if (drv->bdrv_co_change_backing_file != NULL) {
5683 ret = drv->bdrv_co_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01005684 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02005685 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01005686 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02005687
5688 if (ret == 0) {
5689 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
5690 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
Max Reitz998c2012019-02-01 20:29:08 +01005691 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
5692 backing_file ?: "");
Paolo Bonzini469ef352012-04-12 14:01:02 +02005693 }
5694 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01005695}
5696
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005697/*
Max Reitzdcf3f9b2019-06-12 17:34:45 +02005698 * Finds the first non-filter node above bs in the chain between
5699 * active and bs. The returned node is either an immediate parent of
5700 * bs, or there are only filter nodes between the two.
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005701 *
5702 * Returns NULL if bs is not found in active's image chain,
5703 * or if active == bs.
Jeff Cody4caf0fc2014-06-25 15:35:26 -04005704 *
5705 * Returns the bottommost base image if bs == NULL.
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005706 */
5707BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
5708 BlockDriverState *bs)
5709{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005710
5711 GLOBAL_STATE_CODE();
5712
Max Reitzdcf3f9b2019-06-12 17:34:45 +02005713 bs = bdrv_skip_filters(bs);
5714 active = bdrv_skip_filters(active);
5715
5716 while (active) {
5717 BlockDriverState *next = bdrv_backing_chain_next(active);
5718 if (bs == next) {
5719 return active;
5720 }
5721 active = next;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005722 }
5723
Max Reitzdcf3f9b2019-06-12 17:34:45 +02005724 return NULL;
Jeff Cody4caf0fc2014-06-25 15:35:26 -04005725}
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005726
Jeff Cody4caf0fc2014-06-25 15:35:26 -04005727/* Given a BDS, searches for the base layer. */
5728BlockDriverState *bdrv_find_base(BlockDriverState *bs)
5729{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005730 GLOBAL_STATE_CODE();
5731
Jeff Cody4caf0fc2014-06-25 15:35:26 -04005732 return bdrv_find_overlay(bs, NULL);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005733}
5734
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005735/*
Max Reitz7b99a262019-06-12 16:07:11 +02005736 * Return true if at least one of the COW (backing) and filter links
5737 * between @bs and @base is frozen. @errp is set if that's the case.
Alberto Garcia0f0998f2019-03-28 18:25:09 +02005738 * @base must be reachable from @bs, or NULL.
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005739 */
Kevin Wolf9275fc72023-10-27 17:53:18 +02005740static bool GRAPH_RDLOCK
5741bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
5742 Error **errp)
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005743{
5744 BlockDriverState *i;
Max Reitz7b99a262019-06-12 16:07:11 +02005745 BdrvChild *child;
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005746
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005747 GLOBAL_STATE_CODE();
5748
Max Reitz7b99a262019-06-12 16:07:11 +02005749 for (i = bs; i != base; i = child_bs(child)) {
5750 child = bdrv_filter_or_cow_child(i);
5751
5752 if (child && child->frozen) {
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005753 error_setg(errp, "Cannot change '%s' link from '%s' to '%s'",
Max Reitz7b99a262019-06-12 16:07:11 +02005754 child->name, i->node_name, child->bs->node_name);
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005755 return true;
5756 }
5757 }
5758
5759 return false;
5760}
5761
5762/*
Max Reitz7b99a262019-06-12 16:07:11 +02005763 * Freeze all COW (backing) and filter links between @bs and @base.
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005764 * If any of the links is already frozen the operation is aborted and
5765 * none of the links are modified.
Alberto Garcia0f0998f2019-03-28 18:25:09 +02005766 * @base must be reachable from @bs, or NULL.
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005767 * Returns 0 on success. On failure returns < 0 and sets @errp.
5768 */
5769int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
5770 Error **errp)
5771{
5772 BlockDriverState *i;
Max Reitz7b99a262019-06-12 16:07:11 +02005773 BdrvChild *child;
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005774
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005775 GLOBAL_STATE_CODE();
5776
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005777 if (bdrv_is_backing_chain_frozen(bs, base, errp)) {
5778 return -EPERM;
5779 }
5780
Max Reitz7b99a262019-06-12 16:07:11 +02005781 for (i = bs; i != base; i = child_bs(child)) {
5782 child = bdrv_filter_or_cow_child(i);
5783 if (child && child->bs->never_freeze) {
Max Reitze5182c12019-07-03 19:28:02 +02005784 error_setg(errp, "Cannot freeze '%s' link to '%s'",
Max Reitz7b99a262019-06-12 16:07:11 +02005785 child->name, child->bs->node_name);
Max Reitze5182c12019-07-03 19:28:02 +02005786 return -EPERM;
5787 }
5788 }
5789
Max Reitz7b99a262019-06-12 16:07:11 +02005790 for (i = bs; i != base; i = child_bs(child)) {
5791 child = bdrv_filter_or_cow_child(i);
5792 if (child) {
5793 child->frozen = true;
Alberto Garcia0f0998f2019-03-28 18:25:09 +02005794 }
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005795 }
5796
5797 return 0;
5798}
5799
5800/*
Max Reitz7b99a262019-06-12 16:07:11 +02005801 * Unfreeze all COW (backing) and filter links between @bs and @base.
5802 * The caller must ensure that all links are frozen before using this
5803 * function.
Alberto Garcia0f0998f2019-03-28 18:25:09 +02005804 * @base must be reachable from @bs, or NULL.
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005805 */
5806void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base)
5807{
5808 BlockDriverState *i;
Max Reitz7b99a262019-06-12 16:07:11 +02005809 BdrvChild *child;
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005810
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005811 GLOBAL_STATE_CODE();
5812
Max Reitz7b99a262019-06-12 16:07:11 +02005813 for (i = bs; i != base; i = child_bs(child)) {
5814 child = bdrv_filter_or_cow_child(i);
5815 if (child) {
5816 assert(child->frozen);
5817 child->frozen = false;
Alberto Garcia0f0998f2019-03-28 18:25:09 +02005818 }
Alberto Garcia2cad1eb2019-03-12 18:48:40 +02005819 }
5820}
5821
5822/*
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005823 * Drops images above 'base' up to and including 'top', and sets the image
5824 * above 'top' to have base as its backing file.
5825 *
5826 * Requires that the overlay to 'top' is opened r/w, so that the backing file
5827 * information in 'bs' can be properly updated.
5828 *
5829 * E.g., this will convert the following chain:
5830 * bottom <- base <- intermediate <- top <- active
5831 *
5832 * to
5833 *
5834 * bottom <- base <- active
5835 *
5836 * It is allowed for bottom==base, in which case it converts:
5837 *
5838 * base <- intermediate <- top <- active
5839 *
5840 * to
5841 *
5842 * base <- active
5843 *
Jeff Cody54e26902014-06-25 15:40:10 -04005844 * If backing_file_str is non-NULL, it will be used when modifying top's
5845 * overlay image metadata.
5846 *
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005847 * Error conditions:
5848 * if active == top, that is considered an error
5849 *
5850 */
Kevin Wolfbde70712017-06-27 20:36:18 +02005851int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
Peter Krempa4b028cb2023-12-05 18:14:41 +01005852 const char *backing_file_str,
5853 bool backing_mask_protocol)
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005854{
Alberto Garcia6bd858b2018-10-31 18:16:38 +02005855 BlockDriverState *explicit_top = top;
5856 bool update_inherits_from;
Vladimir Sementsov-Ogievskiyd669ed62020-11-06 15:42:37 +03005857 BdrvChild *c;
Kevin Wolf12fa4af2017-02-17 20:42:32 +01005858 Error *local_err = NULL;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005859 int ret = -EIO;
Vladimir Sementsov-Ogievskiyd669ed62020-11-06 15:42:37 +03005860 g_autoptr(GSList) updated_children = NULL;
5861 GSList *p;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005862
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05005863 GLOBAL_STATE_CODE();
5864
Kevin Wolf6858eba2017-06-29 19:32:21 +02005865 bdrv_ref(top);
Kevin Wolf631086d2022-11-18 18:41:03 +01005866 bdrv_drained_begin(base);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005867 bdrv_graph_wrlock();
Kevin Wolf6858eba2017-06-29 19:32:21 +02005868
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005869 if (!top->drv || !base->drv) {
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005870 goto exit_wrlock;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005871 }
5872
Kevin Wolf5db15a52015-09-14 15:33:33 +02005873 /* Make sure that base is in the backing chain of top */
5874 if (!bdrv_chain_contains(top, base)) {
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005875 goto exit_wrlock;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005876 }
5877
Alberto Garcia6bd858b2018-10-31 18:16:38 +02005878 /* If 'base' recursively inherits from 'top' then we should set
5879 * base->inherits_from to top->inherits_from after 'top' and all
5880 * other intermediate nodes have been dropped.
5881 * If 'top' is an implicit node (e.g. "commit_top") we should skip
5882 * it because no one inherits from it. We use explicit_top for that. */
Max Reitzdcf3f9b2019-06-12 17:34:45 +02005883 explicit_top = bdrv_skip_implicit_filters(explicit_top);
Alberto Garcia6bd858b2018-10-31 18:16:38 +02005884 update_inherits_from = bdrv_inherits_from_recursive(base, explicit_top);
5885
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005886 /* success - we can delete the intermediate states, and link top->base */
Max Reitzf30c66b2019-02-01 20:29:05 +01005887 if (!backing_file_str) {
5888 bdrv_refresh_filename(base);
5889 backing_file_str = base->filename;
5890 }
Kevin Wolf61f09ce2017-09-19 16:22:54 +02005891
Vladimir Sementsov-Ogievskiyd669ed62020-11-06 15:42:37 +03005892 QLIST_FOREACH(c, &top->parents, next_parent) {
5893 updated_children = g_slist_prepend(updated_children, c);
5894 }
Kevin Wolf12fa4af2017-02-17 20:42:32 +01005895
Vladimir Sementsov-Ogievskiy3108a152021-04-28 18:17:51 +03005896 /*
5897 * It seems correct to pass detach_subchain=true here, but it triggers
5898 * one more yet not fixed bug, when due to nested aio_poll loop we switch to
5899 * another drained section, which modify the graph (for example, removing
5900 * the child, which we keep in updated_children list). So, it's a TODO.
5901 *
5902 * Note, bug triggered if pass detach_subchain=true here and run
5903 * test-bdrv-drain. test_drop_intermediate_poll() test-case will crash.
5904 * That's a FIXME.
5905 */
5906 bdrv_replace_node_common(top, base, false, false, &local_err);
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005907 bdrv_graph_wrunlock();
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005908
Vladimir Sementsov-Ogievskiyd669ed62020-11-06 15:42:37 +03005909 if (local_err) {
5910 error_report_err(local_err);
5911 goto exit;
5912 }
5913
5914 for (p = updated_children; p; p = p->next) {
5915 c = p->data;
5916
Max Reitzbd86fb92020-05-13 13:05:13 +02005917 if (c->klass->update_filename) {
5918 ret = c->klass->update_filename(c, base, backing_file_str,
Peter Krempa4b028cb2023-12-05 18:14:41 +01005919 backing_mask_protocol,
Max Reitzbd86fb92020-05-13 13:05:13 +02005920 &local_err);
Kevin Wolf61f09ce2017-09-19 16:22:54 +02005921 if (ret < 0) {
Vladimir Sementsov-Ogievskiyd669ed62020-11-06 15:42:37 +03005922 /*
5923 * TODO: Actually, we want to rollback all previous iterations
5924 * of this loop, and (which is almost impossible) previous
5925 * bdrv_replace_node()...
5926 *
5927 * Note, that c->klass->update_filename may lead to permission
5928 * update, so it's a bad idea to call it inside permission
5929 * update transaction of bdrv_replace_node.
5930 */
Kevin Wolf61f09ce2017-09-19 16:22:54 +02005931 error_report_err(local_err);
5932 goto exit;
5933 }
5934 }
Kevin Wolf12fa4af2017-02-17 20:42:32 +01005935 }
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005936
Alberto Garcia6bd858b2018-10-31 18:16:38 +02005937 if (update_inherits_from) {
5938 base->inherits_from = explicit_top->inherits_from;
5939 }
5940
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005941 ret = 0;
Kevin Wolf5c0ef492023-10-27 17:53:24 +02005942 goto exit;
5943
5944exit_wrlock:
Stefan Hajnoczi6bc30f12023-12-05 13:20:02 -05005945 bdrv_graph_wrunlock();
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005946exit:
Kevin Wolf631086d2022-11-18 18:41:03 +01005947 bdrv_drained_end(base);
Kevin Wolf6858eba2017-06-29 19:32:21 +02005948 bdrv_unref(top);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04005949 return ret;
5950}
5951
bellard83f64092006-08-01 16:21:11 +00005952/**
Emanuele Giuseppe Esposito82618d72023-01-13 21:42:07 +01005953 * Implementation of BlockDriver.bdrv_co_get_allocated_file_size() that
Max Reitz081e4652019-06-12 18:14:13 +02005954 * sums the size of all data-bearing children. (This excludes backing
5955 * children.)
5956 */
Emanuele Giuseppe Espositode335632023-05-04 13:57:43 +02005957static int64_t coroutine_fn GRAPH_RDLOCK
5958bdrv_sum_allocated_file_size(BlockDriverState *bs)
Max Reitz081e4652019-06-12 18:14:13 +02005959{
5960 BdrvChild *child;
5961 int64_t child_size, sum = 0;
5962
5963 QLIST_FOREACH(child, &bs->children, next) {
5964 if (child->role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
5965 BDRV_CHILD_FILTERED))
5966 {
Emanuele Giuseppe Esposito82618d72023-01-13 21:42:07 +01005967 child_size = bdrv_co_get_allocated_file_size(child->bs);
Max Reitz081e4652019-06-12 18:14:13 +02005968 if (child_size < 0) {
5969 return child_size;
5970 }
5971 sum += child_size;
5972 }
5973 }
5974
5975 return sum;
5976}
5977
5978/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08005979 * Length of a allocated file in bytes. Sparse files are counted by actual
5980 * allocated space. Return < 0 if error or unknown.
5981 */
Emanuele Giuseppe Esposito82618d72023-01-13 21:42:07 +01005982int64_t coroutine_fn bdrv_co_get_allocated_file_size(BlockDriverState *bs)
Fam Zheng4a1d5e12011-07-12 19:56:39 +08005983{
5984 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05005985 IO_CODE();
Emanuele Giuseppe Espositode335632023-05-04 13:57:43 +02005986 assert_bdrv_graph_readable();
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05005987
Fam Zheng4a1d5e12011-07-12 19:56:39 +08005988 if (!drv) {
5989 return -ENOMEDIUM;
5990 }
Emanuele Giuseppe Esposito82618d72023-01-13 21:42:07 +01005991 if (drv->bdrv_co_get_allocated_file_size) {
5992 return drv->bdrv_co_get_allocated_file_size(bs);
Fam Zheng4a1d5e12011-07-12 19:56:39 +08005993 }
Max Reitz081e4652019-06-12 18:14:13 +02005994
Paolo Bonzini41770f62022-11-24 16:21:18 +01005995 if (drv->protocol_name) {
Max Reitz081e4652019-06-12 18:14:13 +02005996 /*
5997 * Protocol drivers default to -ENOTSUP (most of their data is
5998 * not stored in any of their children (if they even have any),
5999 * so there is no generic way to figure it out).
6000 */
6001 return -ENOTSUP;
6002 } else if (drv->is_filter) {
6003 /* Filter drivers default to the size of their filtered child */
Emanuele Giuseppe Esposito82618d72023-01-13 21:42:07 +01006004 return bdrv_co_get_allocated_file_size(bdrv_filter_bs(bs));
Max Reitz081e4652019-06-12 18:14:13 +02006005 } else {
6006 /* Other drivers default to summing their children's sizes */
6007 return bdrv_sum_allocated_file_size(bs);
Fam Zheng4a1d5e12011-07-12 19:56:39 +08006008 }
Fam Zheng4a1d5e12011-07-12 19:56:39 +08006009}
6010
Stefan Hajnoczi90880ff2017-07-05 13:57:30 +01006011/*
6012 * bdrv_measure:
6013 * @drv: Format driver
6014 * @opts: Creation options for new image
6015 * @in_bs: Existing image containing data for new image (may be NULL)
6016 * @errp: Error object
6017 * Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo())
6018 * or NULL on error
6019 *
6020 * Calculate file size required to create a new image.
6021 *
6022 * If @in_bs is given then space for allocated clusters and zero clusters
6023 * from that image are included in the calculation. If @opts contains a
6024 * backing file that is shared by @in_bs then backing clusters may be omitted
6025 * from the calculation.
6026 *
6027 * If @in_bs is NULL then the calculation includes no allocated clusters
6028 * unless a preallocation option is given in @opts.
6029 *
6030 * Note that @in_bs may use a different BlockDriver from @drv.
6031 *
6032 * If an error occurs the @errp pointer is set.
6033 */
6034BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
6035 BlockDriverState *in_bs, Error **errp)
6036{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006037 IO_CODE();
Stefan Hajnoczi90880ff2017-07-05 13:57:30 +01006038 if (!drv->bdrv_measure) {
6039 error_setg(errp, "Block driver '%s' does not support size measurement",
6040 drv->format_name);
6041 return NULL;
6042 }
6043
6044 return drv->bdrv_measure(opts, in_bs, errp);
6045}
6046
Fam Zheng4a1d5e12011-07-12 19:56:39 +08006047/**
Markus Armbruster65a9bb22014-06-26 13:23:17 +02006048 * Return number of sectors on success, -errno on error.
bellard83f64092006-08-01 16:21:11 +00006049 */
Emanuele Giuseppe Espositoc86422c2023-01-13 21:42:04 +01006050int64_t coroutine_fn bdrv_co_nb_sectors(BlockDriverState *bs)
bellard83f64092006-08-01 16:21:11 +00006051{
6052 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006053 IO_CODE();
Kevin Wolf8ab81402023-02-03 16:22:02 +01006054 assert_bdrv_graph_readable();
Markus Armbruster65a9bb22014-06-26 13:23:17 +02006055
bellard83f64092006-08-01 16:21:11 +00006056 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00006057 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01006058
Paolo Bonzini160a29e2023-04-07 17:32:56 +02006059 if (bs->bl.has_variable_length) {
Emanuele Giuseppe Espositoc86422c2023-01-13 21:42:04 +01006060 int ret = bdrv_co_refresh_total_sectors(bs, bs->total_sectors);
Kevin Wolfb94a2612013-10-29 12:18:58 +01006061 if (ret < 0) {
6062 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01006063 }
bellard83f64092006-08-01 16:21:11 +00006064 }
Markus Armbruster65a9bb22014-06-26 13:23:17 +02006065 return bs->total_sectors;
6066}
6067
Paolo Bonzini81f730d2023-04-07 17:33:03 +02006068/*
6069 * This wrapper is written by hand because this function is in the hot I/O path,
6070 * via blk_get_geometry.
6071 */
6072int64_t coroutine_mixed_fn bdrv_nb_sectors(BlockDriverState *bs)
6073{
6074 BlockDriver *drv = bs->drv;
6075 IO_CODE();
6076
6077 if (!drv)
6078 return -ENOMEDIUM;
6079
6080 if (bs->bl.has_variable_length) {
6081 int ret = bdrv_refresh_total_sectors(bs, bs->total_sectors);
6082 if (ret < 0) {
6083 return ret;
6084 }
6085 }
6086
6087 return bs->total_sectors;
6088}
6089
Markus Armbruster65a9bb22014-06-26 13:23:17 +02006090/**
6091 * Return length in bytes on success, -errno on error.
6092 * The length is always a multiple of BDRV_SECTOR_SIZE.
6093 */
Emanuele Giuseppe Espositoc86422c2023-01-13 21:42:04 +01006094int64_t coroutine_fn bdrv_co_getlength(BlockDriverState *bs)
Markus Armbruster65a9bb22014-06-26 13:23:17 +02006095{
Emanuele Giuseppe Espositoc86422c2023-01-13 21:42:04 +01006096 int64_t ret;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006097 IO_CODE();
Kevin Wolf8ab81402023-02-03 16:22:02 +01006098 assert_bdrv_graph_readable();
Markus Armbruster65a9bb22014-06-26 13:23:17 +02006099
Emanuele Giuseppe Espositoc86422c2023-01-13 21:42:04 +01006100 ret = bdrv_co_nb_sectors(bs);
Eric Blake122860b2020-11-05 09:51:22 -06006101 if (ret < 0) {
6102 return ret;
6103 }
6104 if (ret > INT64_MAX / BDRV_SECTOR_SIZE) {
6105 return -EFBIG;
6106 }
6107 return ret * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00006108}
6109
Eric Blake54115412016-06-23 16:37:26 -06006110bool bdrv_is_sg(BlockDriverState *bs)
ths985a03b2007-12-24 16:10:43 +00006111{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006112 IO_CODE();
ths985a03b2007-12-24 16:10:43 +00006113 return bs->sg;
6114}
6115
Max Reitzae23f782019-06-12 22:57:15 +02006116/**
6117 * Return whether the given node supports compressed writes.
6118 */
6119bool bdrv_supports_compressed_writes(BlockDriverState *bs)
6120{
6121 BlockDriverState *filtered;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006122 IO_CODE();
Max Reitzae23f782019-06-12 22:57:15 +02006123
6124 if (!bs->drv || !block_driver_can_compress(bs->drv)) {
6125 return false;
6126 }
6127
6128 filtered = bdrv_filter_bs(bs);
6129 if (filtered) {
6130 /*
6131 * Filters can only forward compressed writes, so we have to
6132 * check the child.
6133 */
6134 return bdrv_supports_compressed_writes(filtered);
6135 }
6136
6137 return true;
6138}
6139
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02006140const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00006141{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006142 IO_CODE();
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02006143 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00006144}
6145
Stefan Hajnocziada42402014-08-27 12:08:55 +01006146static int qsort_strcmp(const void *a, const void *b)
6147{
Max Reitzceff5bd2016-10-12 22:49:05 +02006148 return strcmp(*(char *const *)a, *(char *const *)b);
Stefan Hajnocziada42402014-08-27 12:08:55 +01006149}
6150
ths5fafdf22007-09-16 21:08:06 +00006151void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +03006152 void *opaque, bool read_only)
bellardea2384d2004-08-01 21:59:26 +00006153{
6154 BlockDriver *drv;
Jeff Codye855e4f2014-04-28 18:29:54 -04006155 int count = 0;
Stefan Hajnocziada42402014-08-27 12:08:55 +01006156 int i;
Jeff Codye855e4f2014-04-28 18:29:54 -04006157 const char **formats = NULL;
bellardea2384d2004-08-01 21:59:26 +00006158
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006159 GLOBAL_STATE_CODE();
6160
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01006161 QLIST_FOREACH(drv, &bdrv_drivers, list) {
Jeff Codye855e4f2014-04-28 18:29:54 -04006162 if (drv->format_name) {
6163 bool found = false;
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +03006164
6165 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, read_only)) {
6166 continue;
6167 }
6168
Markus Armbrusterfb2575f2023-09-21 14:13:11 +02006169 i = count;
Jeff Codye855e4f2014-04-28 18:29:54 -04006170 while (formats && i && !found) {
6171 found = !strcmp(formats[--i], drv->format_name);
6172 }
6173
6174 if (!found) {
Markus Armbruster5839e532014-08-19 10:31:08 +02006175 formats = g_renew(const char *, formats, count + 1);
Jeff Codye855e4f2014-04-28 18:29:54 -04006176 formats[count++] = drv->format_name;
Jeff Codye855e4f2014-04-28 18:29:54 -04006177 }
6178 }
bellardea2384d2004-08-01 21:59:26 +00006179 }
Stefan Hajnocziada42402014-08-27 12:08:55 +01006180
Max Reitzeb0df692016-10-12 22:49:06 +02006181 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
6182 const char *format_name = block_driver_modules[i].format_name;
6183
6184 if (format_name) {
6185 bool found = false;
6186 int j = count;
6187
Andrey Shinkevich9ac404c2019-03-07 16:33:58 +03006188 if (use_bdrv_whitelist &&
6189 !bdrv_format_is_whitelisted(format_name, read_only)) {
6190 continue;
6191 }
6192
Max Reitzeb0df692016-10-12 22:49:06 +02006193 while (formats && j && !found) {
6194 found = !strcmp(formats[--j], format_name);
6195 }
6196
6197 if (!found) {
6198 formats = g_renew(const char *, formats, count + 1);
6199 formats[count++] = format_name;
6200 }
6201 }
6202 }
6203
Stefan Hajnocziada42402014-08-27 12:08:55 +01006204 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
6205
6206 for (i = 0; i < count; i++) {
6207 it(opaque, formats[i]);
6208 }
6209
Jeff Codye855e4f2014-04-28 18:29:54 -04006210 g_free(formats);
bellardea2384d2004-08-01 21:59:26 +00006211}
6212
Benoît Canetdc364f42014-01-23 21:31:32 +01006213/* This function is to find a node in the bs graph */
6214BlockDriverState *bdrv_find_node(const char *node_name)
6215{
6216 BlockDriverState *bs;
6217
6218 assert(node_name);
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006219 GLOBAL_STATE_CODE();
Benoît Canetdc364f42014-01-23 21:31:32 +01006220
6221 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
6222 if (!strcmp(node_name, bs->node_name)) {
6223 return bs;
6224 }
6225 }
6226 return NULL;
6227}
6228
Benoît Canetc13163f2014-01-23 21:31:34 +01006229/* Put this QMP function here so it can access the static graph_bdrv_states. */
Peter Krempafacda542020-01-20 09:50:49 +01006230BlockDeviceInfoList *bdrv_named_nodes_list(bool flat,
6231 Error **errp)
Benoît Canetc13163f2014-01-23 21:31:34 +01006232{
Eric Blake9812e712020-10-27 00:05:47 -05006233 BlockDeviceInfoList *list;
Benoît Canetc13163f2014-01-23 21:31:34 +01006234 BlockDriverState *bs;
6235
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006236 GLOBAL_STATE_CODE();
Kevin Wolfb7cfc7d2023-09-29 16:51:45 +02006237 GRAPH_RDLOCK_GUARD_MAINLOOP();
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006238
Benoît Canetc13163f2014-01-23 21:31:34 +01006239 list = NULL;
6240 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
Peter Krempafacda542020-01-20 09:50:49 +01006241 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, flat, errp);
Alberto Garciad5a8ee62015-04-17 14:52:43 +03006242 if (!info) {
6243 qapi_free_BlockDeviceInfoList(list);
6244 return NULL;
6245 }
Eric Blake9812e712020-10-27 00:05:47 -05006246 QAPI_LIST_PREPEND(list, info);
Benoît Canetc13163f2014-01-23 21:31:34 +01006247 }
6248
6249 return list;
6250}
6251
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006252typedef struct XDbgBlockGraphConstructor {
6253 XDbgBlockGraph *graph;
6254 GHashTable *graph_nodes;
6255} XDbgBlockGraphConstructor;
6256
6257static XDbgBlockGraphConstructor *xdbg_graph_new(void)
6258{
6259 XDbgBlockGraphConstructor *gr = g_new(XDbgBlockGraphConstructor, 1);
6260
6261 gr->graph = g_new0(XDbgBlockGraph, 1);
6262 gr->graph_nodes = g_hash_table_new(NULL, NULL);
6263
6264 return gr;
6265}
6266
6267static XDbgBlockGraph *xdbg_graph_finalize(XDbgBlockGraphConstructor *gr)
6268{
6269 XDbgBlockGraph *graph = gr->graph;
6270
6271 g_hash_table_destroy(gr->graph_nodes);
6272 g_free(gr);
6273
6274 return graph;
6275}
6276
6277static uintptr_t xdbg_graph_node_num(XDbgBlockGraphConstructor *gr, void *node)
6278{
6279 uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node);
6280
6281 if (ret != 0) {
6282 return ret;
6283 }
6284
6285 /*
6286 * Start counting from 1, not 0, because 0 interferes with not-found (NULL)
6287 * answer of g_hash_table_lookup.
6288 */
6289 ret = g_hash_table_size(gr->graph_nodes) + 1;
6290 g_hash_table_insert(gr->graph_nodes, node, (void *)ret);
6291
6292 return ret;
6293}
6294
6295static void xdbg_graph_add_node(XDbgBlockGraphConstructor *gr, void *node,
6296 XDbgBlockGraphNodeType type, const char *name)
6297{
6298 XDbgBlockGraphNode *n;
6299
6300 n = g_new0(XDbgBlockGraphNode, 1);
6301
6302 n->id = xdbg_graph_node_num(gr, node);
6303 n->type = type;
6304 n->name = g_strdup(name);
6305
Eric Blake9812e712020-10-27 00:05:47 -05006306 QAPI_LIST_PREPEND(gr->graph->nodes, n);
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006307}
6308
6309static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent,
6310 const BdrvChild *child)
6311{
Max Reitzcdb1cec2019-11-08 13:34:52 +01006312 BlockPermission qapi_perm;
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006313 XDbgBlockGraphEdge *edge;
Emanuele Giuseppe Esposito862fded2022-03-03 10:15:55 -05006314 GLOBAL_STATE_CODE();
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006315
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006316 edge = g_new0(XDbgBlockGraphEdge, 1);
6317
6318 edge->parent = xdbg_graph_node_num(gr, parent);
6319 edge->child = xdbg_graph_node_num(gr, child->bs);
6320 edge->name = g_strdup(child->name);
6321
Max Reitzcdb1cec2019-11-08 13:34:52 +01006322 for (qapi_perm = 0; qapi_perm < BLOCK_PERMISSION__MAX; qapi_perm++) {
6323 uint64_t flag = bdrv_qapi_perm_to_blk_perm(qapi_perm);
6324
6325 if (flag & child->perm) {
Eric Blake9812e712020-10-27 00:05:47 -05006326 QAPI_LIST_PREPEND(edge->perm, qapi_perm);
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006327 }
Max Reitzcdb1cec2019-11-08 13:34:52 +01006328 if (flag & child->shared_perm) {
Eric Blake9812e712020-10-27 00:05:47 -05006329 QAPI_LIST_PREPEND(edge->shared_perm, qapi_perm);
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006330 }
6331 }
6332
Eric Blake9812e712020-10-27 00:05:47 -05006333 QAPI_LIST_PREPEND(gr->graph->edges, edge);
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006334}
6335
6336
6337XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp)
6338{
6339 BlockBackend *blk;
6340 BlockJob *job;
6341 BlockDriverState *bs;
6342 BdrvChild *child;
6343 XDbgBlockGraphConstructor *gr = xdbg_graph_new();
6344
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006345 GLOBAL_STATE_CODE();
6346
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006347 for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {
6348 char *allocated_name = NULL;
6349 const char *name = blk_name(blk);
6350
6351 if (!*name) {
6352 name = allocated_name = blk_get_attached_dev_id(blk);
6353 }
Markus Armbrusterbcd63b52024-09-04 13:18:20 +02006354 xdbg_graph_add_node(gr, blk, XDBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_BACKEND,
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006355 name);
6356 g_free(allocated_name);
6357 if (blk_root(blk)) {
6358 xdbg_graph_add_edge(gr, blk, blk_root(blk));
6359 }
6360 }
6361
Emanuele Giuseppe Esposito880eeec2022-09-26 05:32:04 -04006362 WITH_JOB_LOCK_GUARD() {
6363 for (job = block_job_next_locked(NULL); job;
6364 job = block_job_next_locked(job)) {
6365 GSList *el;
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006366
Markus Armbrusterbcd63b52024-09-04 13:18:20 +02006367 xdbg_graph_add_node(gr, job, XDBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_JOB,
Emanuele Giuseppe Esposito880eeec2022-09-26 05:32:04 -04006368 job->job.id);
6369 for (el = job->nodes; el; el = el->next) {
6370 xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data);
6371 }
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006372 }
6373 }
6374
6375 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
Markus Armbrusterbcd63b52024-09-04 13:18:20 +02006376 xdbg_graph_add_node(gr, bs, XDBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_DRIVER,
Vladimir Sementsov-Ogievskiy5d3b4e92018-12-21 20:09:07 +03006377 bs->node_name);
6378 QLIST_FOREACH(child, &bs->children, next) {
6379 xdbg_graph_add_edge(gr, bs, child);
6380 }
6381 }
6382
6383 return xdbg_graph_finalize(gr);
6384}
6385
Benoît Canet12d3ba82014-01-23 21:31:35 +01006386BlockDriverState *bdrv_lookup_bs(const char *device,
6387 const char *node_name,
6388 Error **errp)
6389{
Markus Armbruster7f06d472014-10-07 13:59:12 +02006390 BlockBackend *blk;
6391 BlockDriverState *bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01006392
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006393 GLOBAL_STATE_CODE();
6394
Benoît Canet12d3ba82014-01-23 21:31:35 +01006395 if (device) {
Markus Armbruster7f06d472014-10-07 13:59:12 +02006396 blk = blk_by_name(device);
Benoît Canet12d3ba82014-01-23 21:31:35 +01006397
Markus Armbruster7f06d472014-10-07 13:59:12 +02006398 if (blk) {
Alberto Garcia9f4ed6f2015-10-26 16:46:49 +02006399 bs = blk_bs(blk);
6400 if (!bs) {
Max Reitz5433c242015-10-19 17:53:29 +02006401 error_setg(errp, "Device '%s' has no medium", device);
Max Reitz5433c242015-10-19 17:53:29 +02006402 }
6403
Alberto Garcia9f4ed6f2015-10-26 16:46:49 +02006404 return bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01006405 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01006406 }
6407
Benoît Canetdd67fa52014-02-12 17:15:06 +01006408 if (node_name) {
6409 bs = bdrv_find_node(node_name);
Benoît Canet12d3ba82014-01-23 21:31:35 +01006410
Benoît Canetdd67fa52014-02-12 17:15:06 +01006411 if (bs) {
6412 return bs;
6413 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01006414 }
6415
Connor Kuehl785ec4b2021-03-05 09:19:28 -06006416 error_setg(errp, "Cannot find device=\'%s\' nor node-name=\'%s\'",
Benoît Canetdd67fa52014-02-12 17:15:06 +01006417 device ? device : "",
6418 node_name ? node_name : "");
6419 return NULL;
Benoît Canet12d3ba82014-01-23 21:31:35 +01006420}
6421
Jeff Cody5a6684d2014-06-25 15:40:09 -04006422/* If 'base' is in the same chain as 'top', return true. Otherwise,
6423 * return false. If either argument is NULL, return false. */
6424bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
6425{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006426
6427 GLOBAL_STATE_CODE();
6428
Jeff Cody5a6684d2014-06-25 15:40:09 -04006429 while (top && top != base) {
Max Reitzdcf3f9b2019-06-12 17:34:45 +02006430 top = bdrv_filter_or_cow_bs(top);
Jeff Cody5a6684d2014-06-25 15:40:09 -04006431 }
6432
6433 return top != NULL;
6434}
6435
Fam Zheng04df7652014-10-31 11:32:54 +08006436BlockDriverState *bdrv_next_node(BlockDriverState *bs)
6437{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006438 GLOBAL_STATE_CODE();
Fam Zheng04df7652014-10-31 11:32:54 +08006439 if (!bs) {
6440 return QTAILQ_FIRST(&graph_bdrv_states);
6441 }
6442 return QTAILQ_NEXT(bs, node_list);
6443}
6444
Kevin Wolf0f122642018-03-28 18:29:18 +02006445BlockDriverState *bdrv_next_all_states(BlockDriverState *bs)
6446{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006447 GLOBAL_STATE_CODE();
Kevin Wolf0f122642018-03-28 18:29:18 +02006448 if (!bs) {
6449 return QTAILQ_FIRST(&all_bdrv_states);
6450 }
6451 return QTAILQ_NEXT(bs, bs_list);
6452}
6453
Fam Zheng20a9e772014-10-31 11:32:55 +08006454const char *bdrv_get_node_name(const BlockDriverState *bs)
6455{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006456 IO_CODE();
Fam Zheng20a9e772014-10-31 11:32:55 +08006457 return bs->node_name;
6458}
6459
Kevin Wolf1f0c4612016-03-22 18:38:44 +01006460const char *bdrv_get_parent_name(const BlockDriverState *bs)
Kevin Wolf4c265bf2016-02-26 10:22:16 +01006461{
6462 BdrvChild *c;
6463 const char *name;
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05006464 IO_CODE();
Kevin Wolf4c265bf2016-02-26 10:22:16 +01006465
6466 /* If multiple parents have a name, just pick the first one. */
6467 QLIST_FOREACH(c, &bs->parents, next_parent) {
Max Reitzbd86fb92020-05-13 13:05:13 +02006468 if (c->klass->get_name) {
6469 name = c->klass->get_name(c);
Kevin Wolf4c265bf2016-02-26 10:22:16 +01006470 if (name && *name) {
6471 return name;
6472 }
6473 }
6474 }
6475
6476 return NULL;
6477}
6478
Markus Armbruster7f06d472014-10-07 13:59:12 +02006479/* TODO check what callers really want: bs->node_name or blk_name() */
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02006480const char *bdrv_get_device_name(const BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00006481{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006482 IO_CODE();
Kevin Wolf4c265bf2016-02-26 10:22:16 +01006483 return bdrv_get_parent_name(bs) ?: "";
bellardea2384d2004-08-01 21:59:26 +00006484}
6485
Alberto Garcia9b2aa842015-04-08 12:29:18 +03006486/* This can be used to identify nodes that might not have a device
6487 * name associated. Since node and device names live in the same
6488 * namespace, the result is unambiguous. The exception is if both are
6489 * absent, then this returns an empty (non-null) string. */
6490const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
6491{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006492 IO_CODE();
Kevin Wolf4c265bf2016-02-26 10:22:16 +01006493 return bdrv_get_parent_name(bs) ?: bs->node_name;
Alberto Garcia9b2aa842015-04-08 12:29:18 +03006494}
6495
Markus Armbrusterc8433282012-06-05 16:49:24 +02006496int bdrv_get_flags(BlockDriverState *bs)
6497{
Hanna Reitz15aee7a2022-04-27 13:40:54 +02006498 IO_CODE();
Markus Armbrusterc8433282012-06-05 16:49:24 +02006499 return bs->open_flags;
6500}
6501
Peter Lieven3ac21622013-06-28 12:47:42 +02006502int bdrv_has_zero_init_1(BlockDriverState *bs)
6503{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006504 GLOBAL_STATE_CODE();
Peter Lieven3ac21622013-06-28 12:47:42 +02006505 return 1;
6506}
6507
Kevin Wolf06717982023-10-27 17:53:11 +02006508int coroutine_mixed_fn bdrv_has_zero_init(BlockDriverState *bs)
Kevin Wolff2feebb2010-04-14 17:30:35 +02006509{
Max Reitz93393e62019-06-12 17:03:38 +02006510 BlockDriverState *filtered;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006511 GLOBAL_STATE_CODE();
Max Reitz93393e62019-06-12 17:03:38 +02006512
Max Reitzd470ad42017-11-10 21:31:09 +01006513 if (!bs->drv) {
6514 return 0;
6515 }
Kevin Wolff2feebb2010-04-14 17:30:35 +02006516
Paolo Bonzini11212d82013-09-04 19:00:27 +02006517 /* If BS is a copy on write image, it is initialized to
6518 the contents of the base image, which may not be zeroes. */
Max Reitz34778172019-06-12 17:10:46 +02006519 if (bdrv_cow_child(bs)) {
Paolo Bonzini11212d82013-09-04 19:00:27 +02006520 return 0;
6521 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02006522 if (bs->drv->bdrv_has_zero_init) {
6523 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02006524 }
Max Reitz93393e62019-06-12 17:03:38 +02006525
6526 filtered = bdrv_filter_bs(bs);
6527 if (filtered) {
6528 return bdrv_has_zero_init(filtered);
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03006529 }
Kevin Wolff2feebb2010-04-14 17:30:35 +02006530
Peter Lieven3ac21622013-06-28 12:47:42 +02006531 /* safe default */
6532 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02006533}
6534
Peter Lieven4ce78692013-10-24 12:06:54 +02006535bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
6536{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006537 IO_CODE();
Denis V. Lunev2f0342e2016-07-14 16:33:26 +03006538 if (!(bs->open_flags & BDRV_O_UNMAP)) {
Peter Lieven4ce78692013-10-24 12:06:54 +02006539 return false;
6540 }
6541
Eric Blakee24d8132018-01-26 13:34:39 -06006542 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP;
Peter Lieven4ce78692013-10-24 12:06:54 +02006543}
6544
ths5fafdf22007-09-16 21:08:06 +00006545void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00006546 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00006547{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006548 IO_CODE();
Kevin Wolf3574c602011-10-26 11:02:11 +02006549 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00006550}
6551
Emanuele Giuseppe Esposito3d47eb02023-01-13 21:42:08 +01006552int coroutine_fn bdrv_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
bellardfaea38e2006-08-05 21:31:00 +00006553{
Vladimir Sementsov-Ogievskiy8b117002020-12-04 01:27:13 +03006554 int ret;
bellardfaea38e2006-08-05 21:31:00 +00006555 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006556 IO_CODE();
Emanuele Giuseppe Espositoa00e70c2023-05-04 13:57:44 +02006557 assert_bdrv_graph_readable();
6558
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03006559 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
6560 if (!drv) {
bellard19cb3732006-08-19 11:45:59 +00006561 return -ENOMEDIUM;
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03006562 }
Emanuele Giuseppe Esposito3d47eb02023-01-13 21:42:08 +01006563 if (!drv->bdrv_co_get_info) {
Max Reitz93393e62019-06-12 17:03:38 +02006564 BlockDriverState *filtered = bdrv_filter_bs(bs);
6565 if (filtered) {
Emanuele Giuseppe Esposito3d47eb02023-01-13 21:42:08 +01006566 return bdrv_co_get_info(filtered, bdi);
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03006567 }
bellardfaea38e2006-08-05 21:31:00 +00006568 return -ENOTSUP;
Manos Pitsidianakis5a612c02017-07-13 18:30:25 +03006569 }
bellardfaea38e2006-08-05 21:31:00 +00006570 memset(bdi, 0, sizeof(*bdi));
Emanuele Giuseppe Esposito3d47eb02023-01-13 21:42:08 +01006571 ret = drv->bdrv_co_get_info(bs, bdi);
Andrey Drobyshevc54483b2023-07-11 20:25:51 +03006572 if (bdi->subcluster_size == 0) {
6573 /*
6574 * If the driver left this unset, subclusters are not supported.
6575 * Then it is safe to treat each cluster as having only one subcluster.
6576 */
6577 bdi->subcluster_size = bdi->cluster_size;
6578 }
Vladimir Sementsov-Ogievskiy8b117002020-12-04 01:27:13 +03006579 if (ret < 0) {
6580 return ret;
6581 }
6582
6583 if (bdi->cluster_size > BDRV_MAX_ALIGNMENT) {
6584 return -EINVAL;
6585 }
6586
6587 return 0;
bellardfaea38e2006-08-05 21:31:00 +00006588}
6589
Andrey Shinkevich1bf6e9c2019-02-08 18:06:06 +03006590ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs,
6591 Error **errp)
Max Reitzeae041f2013-10-09 10:46:16 +02006592{
6593 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006594 IO_CODE();
Max Reitzeae041f2013-10-09 10:46:16 +02006595 if (drv && drv->bdrv_get_specific_info) {
Andrey Shinkevich1bf6e9c2019-02-08 18:06:06 +03006596 return drv->bdrv_get_specific_info(bs, errp);
Max Reitzeae041f2013-10-09 10:46:16 +02006597 }
6598 return NULL;
6599}
6600
Anton Nefedovd9245592019-09-23 15:17:37 +03006601BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs)
6602{
6603 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006604 IO_CODE();
Anton Nefedovd9245592019-09-23 15:17:37 +03006605 if (!drv || !drv->bdrv_get_specific_stats) {
6606 return NULL;
6607 }
6608 return drv->bdrv_get_specific_stats(bs);
6609}
6610
Emanuele Giuseppe Espositoc834dc02023-01-13 21:42:11 +01006611void coroutine_fn bdrv_co_debug_event(BlockDriverState *bs, BlkdebugEvent event)
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01006612{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05006613 IO_CODE();
Emanuele Giuseppe Espositocb2bfaa2023-05-04 13:57:45 +02006614 assert_bdrv_graph_readable();
6615
Emanuele Giuseppe Espositoc834dc02023-01-13 21:42:11 +01006616 if (!bs || !bs->drv || !bs->drv->bdrv_co_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01006617 return;
6618 }
6619
Emanuele Giuseppe Espositoc834dc02023-01-13 21:42:11 +01006620 bs->drv->bdrv_co_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01006621}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01006622
Kevin Wolfc0fc5122023-09-29 16:51:46 +02006623static BlockDriverState * GRAPH_RDLOCK
6624bdrv_find_debug_node(BlockDriverState *bs)
Kevin Wolf41c695c2012-12-06 14:32:58 +01006625{
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05006626 GLOBAL_STATE_CODE();
Kevin Wolf41c695c2012-12-06 14:32:58 +01006627 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
Max Reitzf706a922019-06-12 17:42:13 +02006628 bs = bdrv_primary_bs(bs);
Kevin Wolf41c695c2012-12-06 14:32:58 +01006629 }
6630
6631 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
Vladimir Sementsov-Ogievskiyd10529a2019-09-20 17:20:49 +03006632 assert(bs->drv->bdrv_debug_remove_breakpoint);
6633 return bs;
6634 }
6635
6636 return NULL;
6637}
6638
6639int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
6640 const char *tag)
6641{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006642 GLOBAL_STATE_CODE();
Kevin Wolfc0fc5122023-09-29 16:51:46 +02006643 GRAPH_RDLOCK_GUARD_MAINLOOP();
6644
Vladimir Sementsov-Ogievskiyd10529a2019-09-20 17:20:49 +03006645 bs = bdrv_find_debug_node(bs);
6646 if (bs) {
Kevin Wolf41c695c2012-12-06 14:32:58 +01006647 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
6648 }
6649
6650 return -ENOTSUP;
6651}
6652
Fam Zheng4cc70e92013-11-20 10:01:54 +08006653int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
6654{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006655 GLOBAL_STATE_CODE();
Kevin Wolfc0fc5122023-09-29 16:51:46 +02006656 GRAPH_RDLOCK_GUARD_MAINLOOP();
6657
Vladimir Sementsov-Ogievskiyd10529a2019-09-20 17:20:49 +03006658 bs = bdrv_find_debug_node(bs);
6659 if (bs) {
Fam Zheng4cc70e92013-11-20 10:01:54 +08006660 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
6661 }
6662
6663 return -ENOTSUP;
6664}
6665
Kevin Wolf41c695c2012-12-06 14:32:58 +01006666int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
6667{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006668 GLOBAL_STATE_CODE();
Kevin Wolfc0fc5122023-09-29 16:51:46 +02006669 GRAPH_RDLOCK_GUARD_MAINLOOP();
6670
Max Reitz938789e2014-03-10 23:44:08 +01006671 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
Max Reitzf706a922019-06-12 17:42:13 +02006672 bs = bdrv_primary_bs(bs);
Kevin Wolf41c695c2012-12-06 14:32:58 +01006673 }
6674
6675 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
6676 return bs->drv->bdrv_debug_resume(bs, tag);
6677 }
6678
6679 return -ENOTSUP;
6680}
6681
6682bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
6683{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006684 GLOBAL_STATE_CODE();
Kevin Wolfc0fc5122023-09-29 16:51:46 +02006685 GRAPH_RDLOCK_GUARD_MAINLOOP();
6686
Kevin Wolf41c695c2012-12-06 14:32:58 +01006687 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
Max Reitzf706a922019-06-12 17:42:13 +02006688 bs = bdrv_primary_bs(bs);
Kevin Wolf41c695c2012-12-06 14:32:58 +01006689 }
6690
6691 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
6692 return bs->drv->bdrv_debug_is_suspended(bs, tag);
6693 }
6694
6695 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01006696}
6697
Jeff Codyb1b1d782012-10-16 15:49:09 -04006698/* backing_file can either be relative, or absolute, or a protocol. If it is
6699 * relative, it must be relative to the chain. So, passing in bs->filename
6700 * from a BDS as backing_file should not be done, as that may be relative to
6701 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00006702BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
6703 const char *backing_file)
6704{
Jeff Codyb1b1d782012-10-16 15:49:09 -04006705 char *filename_full = NULL;
6706 char *backing_file_full = NULL;
6707 char *filename_tmp = NULL;
6708 int is_protocol = 0;
Max Reitz0b877d02018-08-01 20:34:11 +02006709 bool filenames_refreshed = false;
Jeff Codyb1b1d782012-10-16 15:49:09 -04006710 BlockDriverState *curr_bs = NULL;
6711 BlockDriverState *retval = NULL;
Max Reitzdcf3f9b2019-06-12 17:34:45 +02006712 BlockDriverState *bs_below;
Jeff Codyb1b1d782012-10-16 15:49:09 -04006713
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006714 GLOBAL_STATE_CODE();
Kevin Wolfb7cfc7d2023-09-29 16:51:45 +02006715 GRAPH_RDLOCK_GUARD_MAINLOOP();
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006716
Jeff Codyb1b1d782012-10-16 15:49:09 -04006717 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00006718 return NULL;
6719 }
6720
Jeff Codyb1b1d782012-10-16 15:49:09 -04006721 filename_full = g_malloc(PATH_MAX);
6722 backing_file_full = g_malloc(PATH_MAX);
Jeff Codyb1b1d782012-10-16 15:49:09 -04006723
6724 is_protocol = path_has_protocol(backing_file);
6725
Max Reitzdcf3f9b2019-06-12 17:34:45 +02006726 /*
6727 * Being largely a legacy function, skip any filters here
6728 * (because filters do not have normal filenames, so they cannot
6729 * match anyway; and allowing json:{} filenames is a bit out of
6730 * scope).
6731 */
6732 for (curr_bs = bdrv_skip_filters(bs);
6733 bdrv_cow_child(curr_bs) != NULL;
6734 curr_bs = bs_below)
6735 {
6736 bs_below = bdrv_backing_chain_next(curr_bs);
Jeff Codyb1b1d782012-10-16 15:49:09 -04006737
Max Reitz0b877d02018-08-01 20:34:11 +02006738 if (bdrv_backing_overridden(curr_bs)) {
6739 /*
6740 * If the backing file was overridden, we can only compare
6741 * directly against the backing node's filename.
6742 */
6743
6744 if (!filenames_refreshed) {
6745 /*
6746 * This will automatically refresh all of the
6747 * filenames in the rest of the backing chain, so we
6748 * only need to do this once.
6749 */
6750 bdrv_refresh_filename(bs_below);
6751 filenames_refreshed = true;
6752 }
6753
6754 if (strcmp(backing_file, bs_below->filename) == 0) {
6755 retval = bs_below;
6756 break;
6757 }
6758 } else if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
6759 /*
6760 * If either of the filename paths is actually a protocol, then
6761 * compare unmodified paths; otherwise make paths relative.
6762 */
Max Reitz6b6833c2019-02-01 20:29:15 +01006763 char *backing_file_full_ret;
6764
Jeff Codyb1b1d782012-10-16 15:49:09 -04006765 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
Max Reitzdcf3f9b2019-06-12 17:34:45 +02006766 retval = bs_below;
Jeff Codyb1b1d782012-10-16 15:49:09 -04006767 break;
6768 }
Jeff Cody418661e2017-01-25 20:08:20 -05006769 /* Also check against the full backing filename for the image */
Max Reitz6b6833c2019-02-01 20:29:15 +01006770 backing_file_full_ret = bdrv_get_full_backing_filename(curr_bs,
6771 NULL);
6772 if (backing_file_full_ret) {
6773 bool equal = strcmp(backing_file, backing_file_full_ret) == 0;
6774 g_free(backing_file_full_ret);
6775 if (equal) {
Max Reitzdcf3f9b2019-06-12 17:34:45 +02006776 retval = bs_below;
Jeff Cody418661e2017-01-25 20:08:20 -05006777 break;
6778 }
Jeff Cody418661e2017-01-25 20:08:20 -05006779 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00006780 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04006781 /* If not an absolute filename path, make it relative to the current
6782 * image's filename path */
Max Reitz2d9158c2019-02-01 20:29:17 +01006783 filename_tmp = bdrv_make_absolute_filename(curr_bs, backing_file,
6784 NULL);
6785 /* We are going to compare canonicalized absolute pathnames */
6786 if (!filename_tmp || !realpath(filename_tmp, filename_full)) {
6787 g_free(filename_tmp);
Jeff Codyb1b1d782012-10-16 15:49:09 -04006788 continue;
6789 }
Max Reitz2d9158c2019-02-01 20:29:17 +01006790 g_free(filename_tmp);
Jeff Codyb1b1d782012-10-16 15:49:09 -04006791
6792 /* We need to make sure the backing filename we are comparing against
6793 * is relative to the current image filename (or absolute) */
Max Reitz2d9158c2019-02-01 20:29:17 +01006794 filename_tmp = bdrv_get_full_backing_filename(curr_bs, NULL);
6795 if (!filename_tmp || !realpath(filename_tmp, backing_file_full)) {
6796 g_free(filename_tmp);
Jeff Codyb1b1d782012-10-16 15:49:09 -04006797 continue;
6798 }
Max Reitz2d9158c2019-02-01 20:29:17 +01006799 g_free(filename_tmp);
Jeff Codyb1b1d782012-10-16 15:49:09 -04006800
6801 if (strcmp(backing_file_full, filename_full) == 0) {
Max Reitzdcf3f9b2019-06-12 17:34:45 +02006802 retval = bs_below;
Jeff Codyb1b1d782012-10-16 15:49:09 -04006803 break;
6804 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00006805 }
6806 }
6807
Jeff Codyb1b1d782012-10-16 15:49:09 -04006808 g_free(filename_full);
6809 g_free(backing_file_full);
Jeff Codyb1b1d782012-10-16 15:49:09 -04006810 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00006811}
6812
bellardea2384d2004-08-01 21:59:26 +00006813void bdrv_init(void)
6814{
Kevin Wolfe5f05f82021-07-09 18:41:41 +02006815#ifdef CONFIG_BDRV_WHITELIST_TOOLS
6816 use_bdrv_whitelist = 1;
6817#endif
Anthony Liguori5efa9d52009-05-09 17:03:42 -05006818 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00006819}
pbrookce1a14d2006-08-07 02:38:06 +00006820
Markus Armbrustereb852012009-10-27 18:41:44 +01006821void bdrv_init_with_whitelist(void)
6822{
6823 use_bdrv_whitelist = 1;
6824 bdrv_init();
6825}
6826
Emanuele Giuseppe Espositoa94750d2022-02-09 05:54:50 -05006827int bdrv_activate(BlockDriverState *bs, Error **errp)
6828{
Kevin Wolf4417ab72017-05-04 18:52:37 +02006829 BdrvChild *child, *parent;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01006830 Error *local_err = NULL;
6831 int ret;
Vladimir Sementsov-Ogievskiy9c98f142018-10-29 16:23:17 -04006832 BdrvDirtyBitmap *bm;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01006833
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006834 GLOBAL_STATE_CODE();
Kevin Wolf3804e3c2023-09-11 11:46:12 +02006835 GRAPH_RDLOCK_GUARD_MAINLOOP();
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006836
Kevin Wolf3456a8d2014-03-11 10:58:39 +01006837 if (!bs->drv) {
Vladimir Sementsov-Ogievskiy54166452020-09-24 21:54:08 +03006838 return -ENOMEDIUM;
Anthony Liguori0f154232011-11-14 15:09:45 -06006839 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01006840
Vladimir Sementsov-Ogievskiy16e977d2017-01-31 14:23:08 +03006841 QLIST_FOREACH(child, &bs->children, next) {
Emanuele Giuseppe Esposito11d0c9b2022-02-09 05:54:52 -05006842 bdrv_activate(child->bs, &local_err);
Fam Zheng0d1c5c92016-05-11 10:45:33 +08006843 if (local_err) {
Fam Zheng0d1c5c92016-05-11 10:45:33 +08006844 error_propagate(errp, local_err);
Vladimir Sementsov-Ogievskiy54166452020-09-24 21:54:08 +03006845 return -EINVAL;
Fam Zheng0d1c5c92016-05-11 10:45:33 +08006846 }
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01006847 }
Fam Zheng0d1c5c92016-05-11 10:45:33 +08006848
Kevin Wolfdafe0962017-11-16 13:00:01 +01006849 /*
6850 * Update permissions, they may differ for inactive nodes.
6851 *
6852 * Note that the required permissions of inactive images are always a
6853 * subset of the permissions required after activating the image. This
6854 * allows us to just get the permissions upfront without restricting
Emanuele Giuseppe Esposito11d0c9b2022-02-09 05:54:52 -05006855 * bdrv_co_invalidate_cache().
Kevin Wolfdafe0962017-11-16 13:00:01 +01006856 *
6857 * It also means that in error cases, we don't have to try and revert to
6858 * the old permissions (which is an operation that could fail, too). We can
6859 * just keep the extended permissions for the next time that an activation
6860 * of the image is tried.
6861 */
Kevin Wolf7bb49412019-12-17 15:06:38 +01006862 if (bs->open_flags & BDRV_O_INACTIVE) {
6863 bs->open_flags &= ~BDRV_O_INACTIVE;
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03006864 ret = bdrv_refresh_perms(bs, NULL, errp);
Kevin Wolf7bb49412019-12-17 15:06:38 +01006865 if (ret < 0) {
Fam Zheng0d1c5c92016-05-11 10:45:33 +08006866 bs->open_flags |= BDRV_O_INACTIVE;
Vladimir Sementsov-Ogievskiy54166452020-09-24 21:54:08 +03006867 return ret;
Fam Zheng0d1c5c92016-05-11 10:45:33 +08006868 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01006869
Emanuele Giuseppe Esposito11d0c9b2022-02-09 05:54:52 -05006870 ret = bdrv_invalidate_cache(bs, errp);
6871 if (ret < 0) {
6872 bs->open_flags |= BDRV_O_INACTIVE;
6873 return ret;
Kevin Wolf7bb49412019-12-17 15:06:38 +01006874 }
Vladimir Sementsov-Ogievskiy9c98f142018-10-29 16:23:17 -04006875
Kevin Wolf7bb49412019-12-17 15:06:38 +01006876 FOR_EACH_DIRTY_BITMAP(bs, bm) {
6877 bdrv_dirty_bitmap_skip_store(bm, false);
6878 }
6879
Emanuele Giuseppe Espositoc0579602023-01-13 21:42:03 +01006880 ret = bdrv_refresh_total_sectors(bs, bs->total_sectors);
Kevin Wolf7bb49412019-12-17 15:06:38 +01006881 if (ret < 0) {
6882 bs->open_flags |= BDRV_O_INACTIVE;
6883 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Vladimir Sementsov-Ogievskiy54166452020-09-24 21:54:08 +03006884 return ret;
Kevin Wolf7bb49412019-12-17 15:06:38 +01006885 }
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01006886 }
Kevin Wolf4417ab72017-05-04 18:52:37 +02006887
6888 QLIST_FOREACH(parent, &bs->parents, next_parent) {
Max Reitzbd86fb92020-05-13 13:05:13 +02006889 if (parent->klass->activate) {
6890 parent->klass->activate(parent, &local_err);
Kevin Wolf4417ab72017-05-04 18:52:37 +02006891 if (local_err) {
Kevin Wolf78fc3b32019-01-31 15:16:10 +01006892 bs->open_flags |= BDRV_O_INACTIVE;
Kevin Wolf4417ab72017-05-04 18:52:37 +02006893 error_propagate(errp, local_err);
Vladimir Sementsov-Ogievskiy54166452020-09-24 21:54:08 +03006894 return -EINVAL;
Kevin Wolf4417ab72017-05-04 18:52:37 +02006895 }
6896 }
6897 }
Vladimir Sementsov-Ogievskiy54166452020-09-24 21:54:08 +03006898
6899 return 0;
Anthony Liguori0f154232011-11-14 15:09:45 -06006900}
6901
Emanuele Giuseppe Esposito11d0c9b2022-02-09 05:54:52 -05006902int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp)
6903{
6904 Error *local_err = NULL;
Emanuele Giuseppe Esposito1581a702022-03-03 10:16:09 -05006905 IO_CODE();
Emanuele Giuseppe Esposito11d0c9b2022-02-09 05:54:52 -05006906
6907 assert(!(bs->open_flags & BDRV_O_INACTIVE));
Kevin Wolf1b3ff9f2022-12-07 14:18:38 +01006908 assert_bdrv_graph_readable();
Emanuele Giuseppe Esposito11d0c9b2022-02-09 05:54:52 -05006909
6910 if (bs->drv->bdrv_co_invalidate_cache) {
6911 bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
6912 if (local_err) {
6913 error_propagate(errp, local_err);
6914 return -EINVAL;
6915 }
6916 }
6917
6918 return 0;
6919}
6920
Emanuele Giuseppe Esposito3b717192022-02-09 05:54:51 -05006921void bdrv_activate_all(Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06006922{
Kevin Wolf7c8eece2016-03-22 18:58:50 +01006923 BlockDriverState *bs;
Kevin Wolf88be7b42016-05-20 18:49:07 +02006924 BdrvNextIterator it;
Anthony Liguori0f154232011-11-14 15:09:45 -06006925
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006926 GLOBAL_STATE_CODE();
Kevin Wolf2b3912f2023-09-29 16:51:39 +02006927 GRAPH_RDLOCK_GUARD_MAINLOOP();
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05006928
Kevin Wolf88be7b42016-05-20 18:49:07 +02006929 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Vladimir Sementsov-Ogievskiy54166452020-09-24 21:54:08 +03006930 int ret;
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02006931
Emanuele Giuseppe Espositoa94750d2022-02-09 05:54:50 -05006932 ret = bdrv_activate(bs, errp);
Vladimir Sementsov-Ogievskiy54166452020-09-24 21:54:08 +03006933 if (ret < 0) {
Max Reitz5e003f12017-11-10 18:25:45 +01006934 bdrv_next_cleanup(&it);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01006935 return;
6936 }
Anthony Liguori0f154232011-11-14 15:09:45 -06006937 }
6938}
6939
Kevin Wolf0e6bad12023-09-29 16:51:38 +02006940static bool GRAPH_RDLOCK
6941bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
Kevin Wolf9e372712018-11-23 15:11:14 +01006942{
6943 BdrvChild *parent;
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05006944 GLOBAL_STATE_CODE();
Kevin Wolf9e372712018-11-23 15:11:14 +01006945
6946 QLIST_FOREACH(parent, &bs->parents, next_parent) {
Max Reitzbd86fb92020-05-13 13:05:13 +02006947 if (parent->klass->parent_is_bds) {
Kevin Wolf9e372712018-11-23 15:11:14 +01006948 BlockDriverState *parent_bs = parent->opaque;
6949 if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) {
6950 return true;
6951 }
6952 }
6953 }
6954
6955 return false;
6956}
6957
Kevin Wolf0e6bad12023-09-29 16:51:38 +02006958static int GRAPH_RDLOCK bdrv_inactivate_recurse(BlockDriverState *bs)
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01006959{
Kevin Wolfcfa1a572017-05-04 18:52:38 +02006960 BdrvChild *child, *parent;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01006961 int ret;
Vladimir Sementsov-Ogievskiya13de402021-09-11 15:00:27 +03006962 uint64_t cumulative_perms, cumulative_shared_perms;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01006963
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05006964 GLOBAL_STATE_CODE();
6965
Max Reitzd470ad42017-11-10 21:31:09 +01006966 if (!bs->drv) {
6967 return -ENOMEDIUM;
6968 }
6969
Kevin Wolf9e372712018-11-23 15:11:14 +01006970 /* Make sure that we don't inactivate a child before its parent.
6971 * It will be covered by recursion from the yet active parent. */
6972 if (bdrv_has_bds_parent(bs, true)) {
6973 return 0;
6974 }
6975
6976 assert(!(bs->open_flags & BDRV_O_INACTIVE));
6977
6978 /* Inactivate this node */
6979 if (bs->drv->bdrv_inactivate) {
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01006980 ret = bs->drv->bdrv_inactivate(bs);
6981 if (ret < 0) {
6982 return ret;
6983 }
6984 }
6985
Kevin Wolf9e372712018-11-23 15:11:14 +01006986 QLIST_FOREACH(parent, &bs->parents, next_parent) {
Max Reitzbd86fb92020-05-13 13:05:13 +02006987 if (parent->klass->inactivate) {
6988 ret = parent->klass->inactivate(parent);
Kevin Wolf9e372712018-11-23 15:11:14 +01006989 if (ret < 0) {
6990 return ret;
Kevin Wolfcfa1a572017-05-04 18:52:38 +02006991 }
6992 }
Fam Zhengaad0b7a2016-05-11 10:45:35 +08006993 }
Kevin Wolf38701b62017-05-04 18:52:39 +02006994
Vladimir Sementsov-Ogievskiya13de402021-09-11 15:00:27 +03006995 bdrv_get_cumulative_perm(bs, &cumulative_perms,
6996 &cumulative_shared_perms);
6997 if (cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) {
6998 /* Our inactive parents still need write access. Inactivation failed. */
6999 return -EPERM;
7000 }
7001
Kevin Wolf9e372712018-11-23 15:11:14 +01007002 bs->open_flags |= BDRV_O_INACTIVE;
7003
Vladimir Sementsov-Ogievskiybb87e4d2020-11-06 15:42:38 +03007004 /*
7005 * Update permissions, they may differ for inactive nodes.
7006 * We only tried to loosen restrictions, so errors are not fatal, ignore
7007 * them.
7008 */
Vladimir Sementsov-Ogievskiyf1316ed2022-11-07 19:35:57 +03007009 bdrv_refresh_perms(bs, NULL, NULL);
Kevin Wolf9e372712018-11-23 15:11:14 +01007010
7011 /* Recursively inactivate children */
Kevin Wolf38701b62017-05-04 18:52:39 +02007012 QLIST_FOREACH(child, &bs->children, next) {
Kevin Wolf9e372712018-11-23 15:11:14 +01007013 ret = bdrv_inactivate_recurse(child->bs);
Kevin Wolf38701b62017-05-04 18:52:39 +02007014 if (ret < 0) {
7015 return ret;
7016 }
7017 }
7018
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01007019 return 0;
7020}
7021
7022int bdrv_inactivate_all(void)
7023{
Max Reitz79720af2016-03-16 19:54:44 +01007024 BlockDriverState *bs = NULL;
Kevin Wolf88be7b42016-05-20 18:49:07 +02007025 BdrvNextIterator it;
Fam Zhengaad0b7a2016-05-11 10:45:35 +08007026 int ret = 0;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01007027
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007028 GLOBAL_STATE_CODE();
Kevin Wolf0e6bad12023-09-29 16:51:38 +02007029 GRAPH_RDLOCK_GUARD_MAINLOOP();
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007030
Kevin Wolf88be7b42016-05-20 18:49:07 +02007031 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Kevin Wolf9e372712018-11-23 15:11:14 +01007032 /* Nodes with BDS parents are covered by recursion from the last
7033 * parent that gets inactivated. Don't inactivate them a second
7034 * time if that has already happened. */
7035 if (bdrv_has_bds_parent(bs, false)) {
7036 continue;
7037 }
7038 ret = bdrv_inactivate_recurse(bs);
7039 if (ret < 0) {
7040 bdrv_next_cleanup(&it);
Stefan Hajnoczib49f4752023-12-05 13:20:03 -05007041 break;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01007042 }
7043 }
7044
Fam Zhengaad0b7a2016-05-11 10:45:35 +08007045 return ret;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01007046}
7047
Kevin Wolff9f05dc2011-07-15 13:50:26 +02007048/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00007049/* removable device support */
7050
7051/**
7052 * Return TRUE if the media is present
7053 */
Emanuele Giuseppe Esposito1e97be92023-01-13 21:42:02 +01007054bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs)
bellard19cb3732006-08-19 11:45:59 +00007055{
7056 BlockDriver *drv = bs->drv;
Max Reitz28d7a782015-10-19 17:53:13 +02007057 BdrvChild *child;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05007058 IO_CODE();
Emanuele Giuseppe Espositoc73ff922023-02-03 16:21:57 +01007059 assert_bdrv_graph_readable();
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02007060
Max Reitze031f752015-10-19 17:53:11 +02007061 if (!drv) {
7062 return false;
7063 }
Emanuele Giuseppe Esposito1e97be92023-01-13 21:42:02 +01007064 if (drv->bdrv_co_is_inserted) {
7065 return drv->bdrv_co_is_inserted(bs);
Max Reitze031f752015-10-19 17:53:11 +02007066 }
Max Reitz28d7a782015-10-19 17:53:13 +02007067 QLIST_FOREACH(child, &bs->children, next) {
Emanuele Giuseppe Esposito1e97be92023-01-13 21:42:02 +01007068 if (!bdrv_co_is_inserted(child->bs)) {
Max Reitz28d7a782015-10-19 17:53:13 +02007069 return false;
7070 }
7071 }
7072 return true;
bellard19cb3732006-08-19 11:45:59 +00007073}
7074
7075/**
bellard19cb3732006-08-19 11:45:59 +00007076 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
7077 */
Emanuele Giuseppe Esposito2531b392023-01-13 21:42:09 +01007078void coroutine_fn bdrv_co_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00007079{
7080 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05007081 IO_CODE();
Kevin Wolf79a292e2023-02-03 16:21:58 +01007082 assert_bdrv_graph_readable();
bellard19cb3732006-08-19 11:45:59 +00007083
Emanuele Giuseppe Esposito2531b392023-01-13 21:42:09 +01007084 if (drv && drv->bdrv_co_eject) {
7085 drv->bdrv_co_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00007086 }
bellard19cb3732006-08-19 11:45:59 +00007087}
7088
bellard19cb3732006-08-19 11:45:59 +00007089/**
7090 * Lock or unlock the media (if it is locked, the user won't be able
7091 * to eject it manually).
7092 */
Emanuele Giuseppe Esposito2c752612023-01-13 21:42:10 +01007093void coroutine_fn bdrv_co_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00007094{
7095 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05007096 IO_CODE();
Kevin Wolf79a292e2023-02-03 16:21:58 +01007097 assert_bdrv_graph_readable();
Markus Armbruster025e8492011-09-06 18:58:47 +02007098 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01007099
Emanuele Giuseppe Esposito2c752612023-01-13 21:42:10 +01007100 if (drv && drv->bdrv_co_lock_medium) {
7101 drv->bdrv_co_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00007102 }
7103}
ths985a03b2007-12-24 16:10:43 +00007104
Fam Zheng9fcb0252013-08-23 09:14:46 +08007105/* Get a reference to bs */
7106void bdrv_ref(BlockDriverState *bs)
7107{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007108 GLOBAL_STATE_CODE();
Fam Zheng9fcb0252013-08-23 09:14:46 +08007109 bs->refcnt++;
7110}
7111
7112/* Release a previously grabbed reference to bs.
7113 * If after releasing, reference count is zero, the BlockDriverState is
7114 * deleted. */
7115void bdrv_unref(BlockDriverState *bs)
7116{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007117 GLOBAL_STATE_CODE();
Jeff Cody9a4d5ca2014-07-23 17:22:57 -04007118 if (!bs) {
7119 return;
7120 }
Fam Zheng9fcb0252013-08-23 09:14:46 +08007121 assert(bs->refcnt > 0);
7122 if (--bs->refcnt == 0) {
7123 bdrv_delete(bs);
7124 }
7125}
7126
Kevin Wolf6bc0bcc2023-11-15 18:20:10 +01007127static void bdrv_schedule_unref_bh(void *opaque)
7128{
7129 BlockDriverState *bs = opaque;
Kevin Wolf6bc0bcc2023-11-15 18:20:10 +01007130
Kevin Wolf6bc0bcc2023-11-15 18:20:10 +01007131 bdrv_unref(bs);
Kevin Wolf6bc0bcc2023-11-15 18:20:10 +01007132}
7133
Kevin Wolfac2ae232023-09-11 11:46:04 +02007134/*
7135 * Release a BlockDriverState reference while holding the graph write lock.
7136 *
7137 * Calling bdrv_unref() directly is forbidden while holding the graph lock
7138 * because bdrv_close() both involves polling and taking the graph lock
7139 * internally. bdrv_schedule_unref() instead delays decreasing the refcount and
7140 * possibly closing @bs until the graph lock is released.
7141 */
7142void bdrv_schedule_unref(BlockDriverState *bs)
7143{
7144 if (!bs) {
7145 return;
7146 }
Kevin Wolf6bc0bcc2023-11-15 18:20:10 +01007147 aio_bh_schedule_oneshot(qemu_get_aio_context(), bdrv_schedule_unref_bh, bs);
Kevin Wolfac2ae232023-09-11 11:46:04 +02007148}
7149
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007150struct BdrvOpBlocker {
7151 Error *reason;
7152 QLIST_ENTRY(BdrvOpBlocker) list;
7153};
7154
7155bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
7156{
7157 BdrvOpBlocker *blocker;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007158 GLOBAL_STATE_CODE();
Kevin Wolf0bb79c92023-09-29 16:51:49 +02007159
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007160 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
7161 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
7162 blocker = QLIST_FIRST(&bs->op_blockers[op]);
Markus Armbruster4b576642018-10-17 10:26:25 +02007163 error_propagate_prepend(errp, error_copy(blocker->reason),
7164 "Node '%s' is busy: ",
7165 bdrv_get_device_or_node_name(bs));
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007166 return true;
7167 }
7168 return false;
7169}
7170
7171void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
7172{
7173 BdrvOpBlocker *blocker;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007174 GLOBAL_STATE_CODE();
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007175 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
7176
Markus Armbruster5839e532014-08-19 10:31:08 +02007177 blocker = g_new0(BdrvOpBlocker, 1);
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007178 blocker->reason = reason;
7179 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
7180}
7181
7182void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
7183{
7184 BdrvOpBlocker *blocker, *next;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007185 GLOBAL_STATE_CODE();
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007186 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
7187 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
7188 if (blocker->reason == reason) {
7189 QLIST_REMOVE(blocker, list);
7190 g_free(blocker);
7191 }
7192 }
7193}
7194
7195void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
7196{
7197 int i;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007198 GLOBAL_STATE_CODE();
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007199 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
7200 bdrv_op_block(bs, i, reason);
7201 }
7202}
7203
7204void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
7205{
7206 int i;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007207 GLOBAL_STATE_CODE();
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007208 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
7209 bdrv_op_unblock(bs, i, reason);
7210 }
7211}
7212
7213bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
7214{
7215 int i;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007216 GLOBAL_STATE_CODE();
Fam Zhengfbe40ff2014-05-23 21:29:42 +08007217 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
7218 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
7219 return false;
7220 }
7221 }
7222 return true;
7223}
7224
Kevin Wolfe1355052022-12-07 14:18:30 +01007225/*
7226 * Must not be called while holding the lock of an AioContext other than the
7227 * current one.
7228 */
Luiz Capitulinod92ada22012-11-30 10:52:09 -02007229void bdrv_img_create(const char *filename, const char *fmt,
7230 const char *base_filename, const char *base_fmt,
Fam Zheng92172832017-04-21 20:27:01 +08007231 char *options, uint64_t img_size, int flags, bool quiet,
7232 Error **errp)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007233{
Chunyan Liu83d05212014-06-05 17:20:51 +08007234 QemuOptsList *create_opts = NULL;
7235 QemuOpts *opts = NULL;
7236 const char *backing_fmt, *backing_file;
7237 int64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007238 BlockDriver *drv, *proto_drv;
Max Reitzcc84d902013-09-06 17:14:26 +02007239 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007240 int ret = 0;
7241
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007242 GLOBAL_STATE_CODE();
7243
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007244 /* Find driver and parse its options */
7245 drv = bdrv_find_format(fmt);
7246 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02007247 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02007248 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007249 }
7250
Max Reitzb65a5e12015-02-05 13:58:12 -05007251 proto_drv = bdrv_find_protocol(filename, true, errp);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007252 if (!proto_drv) {
Luiz Capitulinod92ada22012-11-30 10:52:09 -02007253 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007254 }
7255
Max Reitzc6149722014-12-02 18:32:45 +01007256 if (!drv->create_opts) {
7257 error_setg(errp, "Format driver '%s' does not support image creation",
7258 drv->format_name);
7259 return;
7260 }
7261
Maxim Levitsky5a5e7f82020-03-26 03:12:18 +02007262 if (!proto_drv->create_opts) {
7263 error_setg(errp, "Protocol driver '%s' does not support image creation",
7264 proto_drv->format_name);
7265 return;
7266 }
7267
Kevin Wolff6dc1c32019-11-26 16:45:49 +01007268 /* Create parameter list */
Chunyan Liuc282e1f2014-06-05 17:21:11 +08007269 create_opts = qemu_opts_append(create_opts, drv->create_opts);
Maxim Levitsky5a5e7f82020-03-26 03:12:18 +02007270 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007271
Chunyan Liu83d05212014-06-05 17:20:51 +08007272 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007273
7274 /* Parse -o options */
7275 if (options) {
Markus Armbrustera5f9b9d2020-07-07 18:06:05 +02007276 if (!qemu_opts_do_parse(opts, options, NULL, errp)) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007277 goto out;
7278 }
7279 }
7280
Kevin Wolff6dc1c32019-11-26 16:45:49 +01007281 if (!qemu_opt_get(opts, BLOCK_OPT_SIZE)) {
7282 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
7283 } else if (img_size != UINT64_C(-1)) {
7284 error_setg(errp, "The image size must be specified only once");
7285 goto out;
7286 }
7287
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007288 if (base_filename) {
Markus Armbruster235e59c2020-07-07 18:05:42 +02007289 if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename,
Markus Armbruster38825782020-07-07 18:05:43 +02007290 NULL)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02007291 error_setg(errp, "Backing file not supported for file format '%s'",
7292 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007293 goto out;
7294 }
7295 }
7296
7297 if (base_fmt) {
Markus Armbruster38825782020-07-07 18:05:43 +02007298 if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, NULL)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02007299 error_setg(errp, "Backing file format not supported for file "
7300 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007301 goto out;
7302 }
7303 }
7304
Chunyan Liu83d05212014-06-05 17:20:51 +08007305 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
7306 if (backing_file) {
7307 if (!strcmp(filename, backing_file)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02007308 error_setg(errp, "Error: Trying to create an image with the "
7309 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01007310 goto out;
7311 }
Connor Kuehl975a7bd2020-08-13 08:47:22 -05007312 if (backing_file[0] == '\0') {
7313 error_setg(errp, "Expected backing file name, got empty string");
7314 goto out;
7315 }
Jes Sorensen792da932010-12-16 13:52:17 +01007316 }
7317
Chunyan Liu83d05212014-06-05 17:20:51 +08007318 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007319
John Snow6e6e55f2017-07-17 20:34:22 -04007320 /* The size for the image must always be specified, unless we have a backing
7321 * file and we have not been forbidden from opening it. */
Eric Blakea8b42a12017-09-25 09:55:07 -05007322 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
John Snow6e6e55f2017-07-17 20:34:22 -04007323 if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
7324 BlockDriverState *bs;
Max Reitz645ae7d2019-02-01 20:29:14 +01007325 char *full_backing;
John Snow6e6e55f2017-07-17 20:34:22 -04007326 int back_flags;
7327 QDict *backing_options = NULL;
Paolo Bonzini63090da2012-04-12 14:01:03 +02007328
Max Reitz645ae7d2019-02-01 20:29:14 +01007329 full_backing =
7330 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
7331 &local_err);
John Snow6e6e55f2017-07-17 20:34:22 -04007332 if (local_err) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007333 goto out;
7334 }
Max Reitz645ae7d2019-02-01 20:29:14 +01007335 assert(full_backing);
John Snow6e6e55f2017-07-17 20:34:22 -04007336
Max Reitzd5b23992021-06-22 16:00:30 +02007337 /*
7338 * No need to do I/O here, which allows us to open encrypted
7339 * backing images without needing the secret
7340 */
John Snow6e6e55f2017-07-17 20:34:22 -04007341 back_flags = flags;
7342 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Max Reitzd5b23992021-06-22 16:00:30 +02007343 back_flags |= BDRV_O_NO_IO;
John Snow6e6e55f2017-07-17 20:34:22 -04007344
Fam Zhengcc954f02017-12-15 16:04:45 +08007345 backing_options = qdict_new();
John Snow6e6e55f2017-07-17 20:34:22 -04007346 if (backing_fmt) {
John Snow6e6e55f2017-07-17 20:34:22 -04007347 qdict_put_str(backing_options, "driver", backing_fmt);
7348 }
Fam Zhengcc954f02017-12-15 16:04:45 +08007349 qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
John Snow6e6e55f2017-07-17 20:34:22 -04007350
7351 bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
7352 &local_err);
7353 g_free(full_backing);
Eric Blakeadd82002020-07-06 15:39:50 -05007354 if (!bs) {
7355 error_append_hint(&local_err, "Could not open backing image.\n");
John Snow6e6e55f2017-07-17 20:34:22 -04007356 goto out;
7357 } else {
Eric Blaked9f059a2020-07-06 15:39:54 -05007358 if (!backing_fmt) {
Eric Blake497a30d2021-05-03 14:36:00 -07007359 error_setg(&local_err,
7360 "Backing file specified without backing format");
Michael Tokarevfbdffb02023-04-05 16:34:04 +03007361 error_append_hint(&local_err, "Detected format of %s.\n",
Eric Blake497a30d2021-05-03 14:36:00 -07007362 bs->drv->format_name);
7363 goto out;
Eric Blaked9f059a2020-07-06 15:39:54 -05007364 }
John Snow6e6e55f2017-07-17 20:34:22 -04007365 if (size == -1) {
7366 /* Opened BS, have no size */
7367 size = bdrv_getlength(bs);
7368 if (size < 0) {
7369 error_setg_errno(errp, -size, "Could not get size of '%s'",
7370 backing_file);
7371 bdrv_unref(bs);
7372 goto out;
7373 }
7374 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
7375 }
7376 bdrv_unref(bs);
7377 }
Eric Blaked9f059a2020-07-06 15:39:54 -05007378 /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */
7379 } else if (backing_file && !backing_fmt) {
Eric Blake497a30d2021-05-03 14:36:00 -07007380 error_setg(&local_err,
7381 "Backing file specified without backing format");
7382 goto out;
Eric Blaked9f059a2020-07-06 15:39:54 -05007383 }
John Snow6e6e55f2017-07-17 20:34:22 -04007384
Hyman Huang35286da2024-01-30 13:37:23 +08007385 /* Parameter 'size' is not needed for detached LUKS header */
7386 if (size == -1 &&
7387 !(!strcmp(fmt, "luks") &&
7388 qemu_opt_get_bool(opts, "detached-header", false))) {
John Snow6e6e55f2017-07-17 20:34:22 -04007389 error_setg(errp, "Image creation needs a size parameter");
7390 goto out;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007391 }
7392
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01007393 if (!quiet) {
Kővágó, Zoltánfe646692015-07-07 16:42:10 +02007394 printf("Formatting '%s', fmt=%s ", filename, fmt);
Fam Zheng43c5d8f2014-12-09 15:38:04 +08007395 qemu_opts_print(opts, " ");
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01007396 puts("");
Eric Blake4e2f4412020-07-06 15:39:45 -05007397 fflush(stdout);
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01007398 }
Chunyan Liu83d05212014-06-05 17:20:51 +08007399
Chunyan Liuc282e1f2014-06-05 17:21:11 +08007400 ret = bdrv_create(drv, filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08007401
Max Reitzcc84d902013-09-06 17:14:26 +02007402 if (ret == -EFBIG) {
7403 /* This is generally a better message than whatever the driver would
7404 * deliver (especially because of the cluster_size_hint), since that
7405 * is most probably not much different from "image too large". */
7406 const char *cluster_size_hint = "";
Chunyan Liu83d05212014-06-05 17:20:51 +08007407 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
Max Reitzcc84d902013-09-06 17:14:26 +02007408 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007409 }
Max Reitzcc84d902013-09-06 17:14:26 +02007410 error_setg(errp, "The image size is too large for file format '%s'"
7411 "%s", fmt, cluster_size_hint);
7412 error_free(local_err);
7413 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007414 }
7415
7416out:
Chunyan Liu83d05212014-06-05 17:20:51 +08007417 qemu_opts_del(opts);
7418 qemu_opts_free(create_opts);
Eduardo Habkost621ff942016-06-13 18:57:56 -03007419 error_propagate(errp, local_err);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01007420}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01007421
7422AioContext *bdrv_get_aio_context(BlockDriverState *bs)
7423{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05007424 IO_CODE();
Stefan Hajnoczi33f2a752018-02-16 16:50:13 +00007425 return bs ? bs->aio_context : qemu_get_aio_context();
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02007426}
7427
Kevin Wolfe336fd42020-10-05 17:58:53 +02007428AioContext *coroutine_fn bdrv_co_enter(BlockDriverState *bs)
7429{
7430 Coroutine *self = qemu_coroutine_self();
7431 AioContext *old_ctx = qemu_coroutine_get_aio_context(self);
7432 AioContext *new_ctx;
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05007433 IO_CODE();
Kevin Wolfe336fd42020-10-05 17:58:53 +02007434
7435 /*
7436 * Increase bs->in_flight to ensure that this operation is completed before
7437 * moving the node to a different AioContext. Read new_ctx only afterwards.
7438 */
7439 bdrv_inc_in_flight(bs);
7440
7441 new_ctx = bdrv_get_aio_context(bs);
7442 aio_co_reschedule_self(new_ctx);
7443 return old_ctx;
7444}
7445
7446void coroutine_fn bdrv_co_leave(BlockDriverState *bs, AioContext *old_ctx)
7447{
Emanuele Giuseppe Esposito384a48f2022-03-03 10:15:50 -05007448 IO_CODE();
Kevin Wolfe336fd42020-10-05 17:58:53 +02007449 aio_co_reschedule_self(old_ctx);
7450 bdrv_dec_in_flight(bs);
7451}
7452
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007453static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
7454{
Emanuele Giuseppe Espositobdb73472022-03-03 10:16:02 -05007455 GLOBAL_STATE_CODE();
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007456 QLIST_REMOVE(ban, list);
7457 g_free(ban);
7458}
7459
Kevin Wolfa3a683c2019-05-06 19:17:57 +02007460static void bdrv_detach_aio_context(BlockDriverState *bs)
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02007461{
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007462 BdrvAioNotifier *baf, *baf_tmp;
Max Reitz33384422014-06-20 21:57:33 +02007463
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007464 assert(!bs->walking_aio_notifiers);
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05007465 GLOBAL_STATE_CODE();
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007466 bs->walking_aio_notifiers = true;
7467 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
7468 if (baf->deleted) {
7469 bdrv_do_remove_aio_context_notifier(baf);
7470 } else {
7471 baf->detach_aio_context(baf->opaque);
7472 }
Max Reitz33384422014-06-20 21:57:33 +02007473 }
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007474 /* Never mind iterating again to check for ->deleted. bdrv_close() will
7475 * remove remaining aio notifiers if we aren't called again.
7476 */
7477 bs->walking_aio_notifiers = false;
Max Reitz33384422014-06-20 21:57:33 +02007478
Kevin Wolf1bffe1a2019-04-17 17:15:25 +02007479 if (bs->drv && bs->drv->bdrv_detach_aio_context) {
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02007480 bs->drv->bdrv_detach_aio_context(bs);
7481 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02007482
7483 bs->aio_context = NULL;
7484}
7485
Kevin Wolfa3a683c2019-05-06 19:17:57 +02007486static void bdrv_attach_aio_context(BlockDriverState *bs,
7487 AioContext *new_context)
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02007488{
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007489 BdrvAioNotifier *ban, *ban_tmp;
Emanuele Giuseppe Espositoda359902022-03-03 10:16:11 -05007490 GLOBAL_STATE_CODE();
Max Reitz33384422014-06-20 21:57:33 +02007491
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02007492 bs->aio_context = new_context;
7493
Kevin Wolf1bffe1a2019-04-17 17:15:25 +02007494 if (bs->drv && bs->drv->bdrv_attach_aio_context) {
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02007495 bs->drv->bdrv_attach_aio_context(bs, new_context);
7496 }
Max Reitz33384422014-06-20 21:57:33 +02007497
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007498 assert(!bs->walking_aio_notifiers);
7499 bs->walking_aio_notifiers = true;
7500 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
7501 if (ban->deleted) {
7502 bdrv_do_remove_aio_context_notifier(ban);
7503 } else {
7504 ban->attached_aio_context(new_context, ban->opaque);
7505 }
Max Reitz33384422014-06-20 21:57:33 +02007506 }
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007507 bs->walking_aio_notifiers = false;
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02007508}
7509
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007510typedef struct BdrvStateSetAioContext {
7511 AioContext *new_ctx;
7512 BlockDriverState *bs;
7513} BdrvStateSetAioContext;
7514
7515static bool bdrv_parent_change_aio_context(BdrvChild *c, AioContext *ctx,
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007516 GHashTable *visited,
7517 Transaction *tran,
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007518 Error **errp)
7519{
7520 GLOBAL_STATE_CODE();
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007521 if (g_hash_table_contains(visited, c)) {
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007522 return true;
7523 }
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007524 g_hash_table_add(visited, c);
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007525
7526 /*
7527 * A BdrvChildClass that doesn't handle AioContext changes cannot
7528 * tolerate any AioContext changes
7529 */
7530 if (!c->klass->change_aio_ctx) {
7531 char *user = bdrv_child_user_desc(c);
7532 error_setg(errp, "Changing iothreads is not supported by %s", user);
7533 g_free(user);
7534 return false;
7535 }
7536 if (!c->klass->change_aio_ctx(c, ctx, visited, tran, errp)) {
7537 assert(!errp || *errp);
7538 return false;
7539 }
7540 return true;
7541}
7542
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007543bool bdrv_child_change_aio_context(BdrvChild *c, AioContext *ctx,
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007544 GHashTable *visited, Transaction *tran,
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007545 Error **errp)
7546{
7547 GLOBAL_STATE_CODE();
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007548 if (g_hash_table_contains(visited, c)) {
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007549 return true;
7550 }
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007551 g_hash_table_add(visited, c);
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007552 return bdrv_change_aio_context(c->bs, ctx, visited, tran, errp);
7553}
7554
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007555static void bdrv_set_aio_context_clean(void *opaque)
7556{
7557 BdrvStateSetAioContext *state = (BdrvStateSetAioContext *) opaque;
7558 BlockDriverState *bs = (BlockDriverState *) state->bs;
7559
7560 /* Paired with bdrv_drained_begin in bdrv_change_aio_context() */
7561 bdrv_drained_end(bs);
7562
7563 g_free(state);
7564}
7565
7566static void bdrv_set_aio_context_commit(void *opaque)
7567{
7568 BdrvStateSetAioContext *state = (BdrvStateSetAioContext *) opaque;
7569 BlockDriverState *bs = (BlockDriverState *) state->bs;
7570 AioContext *new_context = state->new_ctx;
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007571
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007572 bdrv_detach_aio_context(bs);
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007573 bdrv_attach_aio_context(bs, new_context);
7574}
7575
7576static TransactionActionDrv set_aio_context = {
7577 .commit = bdrv_set_aio_context_commit,
7578 .clean = bdrv_set_aio_context_clean,
7579};
7580
Kevin Wolf42a65f02019-05-07 18:31:38 +02007581/*
7582 * Changes the AioContext used for fd handlers, timers, and BHs by this
7583 * BlockDriverState and all its children and parents.
7584 *
Max Reitz43eaaae2019-07-22 15:30:54 +02007585 * Must be called from the main AioContext.
7586 *
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007587 * @visited will accumulate all visited BdrvChild objects. The caller is
Kevin Wolf42a65f02019-05-07 18:31:38 +02007588 * responsible for freeing the list afterwards.
7589 */
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007590static bool bdrv_change_aio_context(BlockDriverState *bs, AioContext *ctx,
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007591 GHashTable *visited, Transaction *tran,
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007592 Error **errp)
Kevin Wolf5d231842019-05-06 19:17:56 +02007593{
7594 BdrvChild *c;
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007595 BdrvStateSetAioContext *state;
7596
7597 GLOBAL_STATE_CODE();
Kevin Wolf5d231842019-05-06 19:17:56 +02007598
7599 if (bdrv_get_aio_context(bs) == ctx) {
7600 return true;
7601 }
7602
Kevin Wolf7f831d22023-09-11 11:46:17 +02007603 bdrv_graph_rdlock_main_loop();
Kevin Wolf5d231842019-05-06 19:17:56 +02007604 QLIST_FOREACH(c, &bs->parents, next_parent) {
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007605 if (!bdrv_parent_change_aio_context(c, ctx, visited, tran, errp)) {
Kevin Wolf7f831d22023-09-11 11:46:17 +02007606 bdrv_graph_rdunlock_main_loop();
Kevin Wolf5d231842019-05-06 19:17:56 +02007607 return false;
7608 }
7609 }
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007610
Kevin Wolf5d231842019-05-06 19:17:56 +02007611 QLIST_FOREACH(c, &bs->children, next) {
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007612 if (!bdrv_child_change_aio_context(c, ctx, visited, tran, errp)) {
Kevin Wolf7f831d22023-09-11 11:46:17 +02007613 bdrv_graph_rdunlock_main_loop();
Kevin Wolf5d231842019-05-06 19:17:56 +02007614 return false;
7615 }
7616 }
Kevin Wolf7f831d22023-09-11 11:46:17 +02007617 bdrv_graph_rdunlock_main_loop();
Kevin Wolf5d231842019-05-06 19:17:56 +02007618
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007619 state = g_new(BdrvStateSetAioContext, 1);
7620 *state = (BdrvStateSetAioContext) {
7621 .new_ctx = ctx,
7622 .bs = bs,
7623 };
7624
7625 /* Paired with bdrv_drained_end in bdrv_set_aio_context_clean() */
7626 bdrv_drained_begin(bs);
7627
7628 tran_add(tran, &set_aio_context, state);
7629
Kevin Wolf5d231842019-05-06 19:17:56 +02007630 return true;
7631}
7632
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007633/*
7634 * Change bs's and recursively all of its parents' and children's AioContext
7635 * to the given new context, returning an error if that isn't possible.
7636 *
7637 * If ignore_child is not NULL, that child (and its subgraph) will not
7638 * be touched.
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007639 */
Emanuele Giuseppe Espositoa41cfda2022-10-25 04:49:51 -04007640int bdrv_try_change_aio_context(BlockDriverState *bs, AioContext *ctx,
7641 BdrvChild *ignore_child, Error **errp)
Kevin Wolf5d231842019-05-06 19:17:56 +02007642{
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007643 Transaction *tran;
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007644 GHashTable *visited;
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007645 int ret;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007646 GLOBAL_STATE_CODE();
7647
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007648 /*
7649 * Recursion phase: go through all nodes of the graph.
7650 * Take care of checking that all nodes support changing AioContext
Michael Tokarev3202d8e2023-07-14 14:06:05 +03007651 * and drain them, building a linear list of callbacks to run if everything
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007652 * is successful (the transaction itself).
7653 */
7654 tran = tran_new();
Emanuele Giuseppe Espositoe08cc002022-10-25 04:49:45 -04007655 visited = g_hash_table_new(NULL, NULL);
7656 if (ignore_child) {
7657 g_hash_table_add(visited, ignore_child);
7658 }
7659 ret = bdrv_change_aio_context(bs, ctx, visited, tran, errp);
7660 g_hash_table_destroy(visited);
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007661
7662 /*
7663 * Linear phase: go through all callbacks collected in the transaction.
Stefan Hajnoczi23c983c2023-12-05 13:20:11 -05007664 * Run all callbacks collected in the recursion to switch every node's
7665 * AioContext (transaction commit), or undo all changes done in the
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007666 * recursion (transaction abort).
7667 */
Kevin Wolf5d231842019-05-06 19:17:56 +02007668
7669 if (!ret) {
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007670 /* Just run clean() callbacks. No AioContext changed. */
7671 tran_abort(tran);
Kevin Wolf5d231842019-05-06 19:17:56 +02007672 return -EPERM;
7673 }
7674
Emanuele Giuseppe Esposito7e8c1822022-10-25 04:49:44 -04007675 tran_commit(tran);
Kevin Wolf5d231842019-05-06 19:17:56 +02007676 return 0;
7677}
7678
Max Reitz33384422014-06-20 21:57:33 +02007679void bdrv_add_aio_context_notifier(BlockDriverState *bs,
7680 void (*attached_aio_context)(AioContext *new_context, void *opaque),
7681 void (*detach_aio_context)(void *opaque), void *opaque)
7682{
7683 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
7684 *ban = (BdrvAioNotifier){
7685 .attached_aio_context = attached_aio_context,
7686 .detach_aio_context = detach_aio_context,
7687 .opaque = opaque
7688 };
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007689 GLOBAL_STATE_CODE();
Max Reitz33384422014-06-20 21:57:33 +02007690
7691 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
7692}
7693
7694void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
7695 void (*attached_aio_context)(AioContext *,
7696 void *),
7697 void (*detach_aio_context)(void *),
7698 void *opaque)
7699{
7700 BdrvAioNotifier *ban, *ban_next;
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007701 GLOBAL_STATE_CODE();
Max Reitz33384422014-06-20 21:57:33 +02007702
7703 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
7704 if (ban->attached_aio_context == attached_aio_context &&
7705 ban->detach_aio_context == detach_aio_context &&
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007706 ban->opaque == opaque &&
7707 ban->deleted == false)
Max Reitz33384422014-06-20 21:57:33 +02007708 {
Stefan Hajnoczie8a095d2016-06-16 17:56:26 +01007709 if (bs->walking_aio_notifiers) {
7710 ban->deleted = true;
7711 } else {
7712 bdrv_do_remove_aio_context_notifier(ban);
7713 }
Max Reitz33384422014-06-20 21:57:33 +02007714 return;
7715 }
7716 }
7717
7718 abort();
7719}
7720
Max Reitz77485432014-10-27 11:12:50 +01007721int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
Max Reitzd1402b52018-05-09 23:00:18 +02007722 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
Maxim Levitskya3579bf2020-06-25 14:55:38 +02007723 bool force,
Max Reitzd1402b52018-05-09 23:00:18 +02007724 Error **errp)
Max Reitz6f176b42013-09-03 10:09:50 +02007725{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007726 GLOBAL_STATE_CODE();
Max Reitzd470ad42017-11-10 21:31:09 +01007727 if (!bs->drv) {
Max Reitzd1402b52018-05-09 23:00:18 +02007728 error_setg(errp, "Node is ejected");
Max Reitzd470ad42017-11-10 21:31:09 +01007729 return -ENOMEDIUM;
7730 }
Chunyan Liuc282e1f2014-06-05 17:21:11 +08007731 if (!bs->drv->bdrv_amend_options) {
Max Reitzd1402b52018-05-09 23:00:18 +02007732 error_setg(errp, "Block driver '%s' does not support option amendment",
7733 bs->drv->format_name);
Max Reitz6f176b42013-09-03 10:09:50 +02007734 return -ENOTSUP;
7735 }
Maxim Levitskya3579bf2020-06-25 14:55:38 +02007736 return bs->drv->bdrv_amend_options(bs, opts, status_cb,
7737 cb_opaque, force, errp);
Max Reitz6f176b42013-09-03 10:09:50 +02007738}
Benoît Canetf6186f42013-10-02 14:33:48 +02007739
Max Reitz5d69b5a2020-02-18 11:34:41 +01007740/*
7741 * This function checks whether the given @to_replace is allowed to be
7742 * replaced by a node that always shows the same data as @bs. This is
7743 * used for example to verify whether the mirror job can replace
7744 * @to_replace by the target mirrored from @bs.
7745 * To be replaceable, @bs and @to_replace may either be guaranteed to
7746 * always show the same data (because they are only connected through
7747 * filters), or some driver may allow replacing one of its children
7748 * because it can guarantee that this child's data is not visible at
7749 * all (for example, for dissenting quorum children that have no other
7750 * parents).
7751 */
7752bool bdrv_recurse_can_replace(BlockDriverState *bs,
7753 BlockDriverState *to_replace)
7754{
Max Reitz93393e62019-06-12 17:03:38 +02007755 BlockDriverState *filtered;
7756
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -05007757 GLOBAL_STATE_CODE();
7758
Max Reitz5d69b5a2020-02-18 11:34:41 +01007759 if (!bs || !bs->drv) {
7760 return false;
7761 }
7762
7763 if (bs == to_replace) {
7764 return true;
7765 }
7766
7767 /* See what the driver can do */
7768 if (bs->drv->bdrv_recurse_can_replace) {
7769 return bs->drv->bdrv_recurse_can_replace(bs, to_replace);
7770 }
7771
7772 /* For filters without an own implementation, we can recurse on our own */
Max Reitz93393e62019-06-12 17:03:38 +02007773 filtered = bdrv_filter_bs(bs);
7774 if (filtered) {
7775 return bdrv_recurse_can_replace(filtered, to_replace);
Max Reitz5d69b5a2020-02-18 11:34:41 +01007776 }
7777
7778 /* Safe default */
7779 return false;
7780}
7781
Max Reitz810803a2020-02-18 11:34:44 +01007782/*
7783 * Check whether the given @node_name can be replaced by a node that
7784 * has the same data as @parent_bs. If so, return @node_name's BDS;
7785 * NULL otherwise.
7786 *
7787 * @node_name must be a (recursive) *child of @parent_bs (or this
7788 * function will return NULL).
7789 *
7790 * The result (whether the node can be replaced or not) is only valid
7791 * for as long as no graph or permission changes occur.
7792 */
Wen Congyange12f3782015-07-17 10:12:22 +08007793BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
7794 const char *node_name, Error **errp)
Benoît Canet09158f02014-06-27 18:25:25 +02007795{
7796 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01007797
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007798 GLOBAL_STATE_CODE();
7799
Benoît Canet09158f02014-06-27 18:25:25 +02007800 if (!to_replace_bs) {
Connor Kuehl785ec4b2021-03-05 09:19:28 -06007801 error_setg(errp, "Failed to find node with node-name='%s'", node_name);
Benoît Canet09158f02014-06-27 18:25:25 +02007802 return NULL;
7803 }
7804
7805 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
Stefan Hajnoczib49f4752023-12-05 13:20:03 -05007806 return NULL;
Benoît Canet09158f02014-06-27 18:25:25 +02007807 }
7808
7809 /* We don't want arbitrary node of the BDS chain to be replaced only the top
7810 * most non filter in order to prevent data corruption.
7811 * Another benefit is that this tests exclude backing files which are
7812 * blocked by the backing blockers.
7813 */
Max Reitz810803a2020-02-18 11:34:44 +01007814 if (!bdrv_recurse_can_replace(parent_bs, to_replace_bs)) {
7815 error_setg(errp, "Cannot replace '%s' by a node mirrored from '%s', "
7816 "because it cannot be guaranteed that doing so would not "
7817 "lead to an abrupt change of visible data",
7818 node_name, parent_bs->node_name);
Stefan Hajnoczib49f4752023-12-05 13:20:03 -05007819 return NULL;
Benoît Canet09158f02014-06-27 18:25:25 +02007820 }
7821
7822 return to_replace_bs;
7823}
Ming Lei448ad912014-07-04 18:04:33 +08007824
Max Reitz97e2f022019-02-01 20:29:27 +01007825/**
7826 * Iterates through the list of runtime option keys that are said to
7827 * be "strong" for a BDS. An option is called "strong" if it changes
7828 * a BDS's data. For example, the null block driver's "size" and
7829 * "read-zeroes" options are strong, but its "latency-ns" option is
7830 * not.
7831 *
7832 * If a key returned by this function ends with a dot, all options
7833 * starting with that prefix are strong.
7834 */
7835static const char *const *strong_options(BlockDriverState *bs,
7836 const char *const *curopt)
7837{
7838 static const char *const global_options[] = {
7839 "driver", "filename", NULL
7840 };
7841
7842 if (!curopt) {
7843 return &global_options[0];
7844 }
7845
7846 curopt++;
7847 if (curopt == &global_options[ARRAY_SIZE(global_options) - 1] && bs->drv) {
7848 curopt = bs->drv->strong_runtime_opts;
7849 }
7850
7851 return (curopt && *curopt) ? curopt : NULL;
7852}
7853
7854/**
7855 * Copies all strong runtime options from bs->options to the given
7856 * QDict. The set of strong option keys is determined by invoking
7857 * strong_options().
7858 *
7859 * Returns true iff any strong option was present in bs->options (and
7860 * thus copied to the target QDict) with the exception of "filename"
7861 * and "driver". The caller is expected to use this value to decide
7862 * whether the existence of strong options prevents the generation of
7863 * a plain filename.
7864 */
7865static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs)
7866{
7867 bool found_any = false;
7868 const char *const *option_name = NULL;
7869
7870 if (!bs->drv) {
7871 return false;
7872 }
7873
7874 while ((option_name = strong_options(bs, option_name))) {
7875 bool option_given = false;
7876
7877 assert(strlen(*option_name) > 0);
7878 if ((*option_name)[strlen(*option_name) - 1] != '.') {
7879 QObject *entry = qdict_get(bs->options, *option_name);
7880 if (!entry) {
7881 continue;
7882 }
7883
7884 qdict_put_obj(d, *option_name, qobject_ref(entry));
7885 option_given = true;
7886 } else {
7887 const QDictEntry *entry;
7888 for (entry = qdict_first(bs->options); entry;
7889 entry = qdict_next(bs->options, entry))
7890 {
7891 if (strstart(qdict_entry_key(entry), *option_name, NULL)) {
7892 qdict_put_obj(d, qdict_entry_key(entry),
7893 qobject_ref(qdict_entry_value(entry)));
7894 option_given = true;
7895 }
7896 }
7897 }
7898
7899 /* While "driver" and "filename" need to be included in a JSON filename,
7900 * their existence does not prohibit generation of a plain filename. */
7901 if (!found_any && option_given &&
7902 strcmp(*option_name, "driver") && strcmp(*option_name, "filename"))
7903 {
7904 found_any = true;
7905 }
7906 }
7907
Max Reitz62a01a272019-02-01 20:29:34 +01007908 if (!qdict_haskey(d, "driver")) {
7909 /* Drivers created with bdrv_new_open_driver() may not have a
7910 * @driver option. Add it here. */
7911 qdict_put_str(d, "driver", bs->drv->format_name);
7912 }
7913
Max Reitz97e2f022019-02-01 20:29:27 +01007914 return found_any;
7915}
7916
Max Reitz90993622019-02-01 20:29:09 +01007917/* Note: This function may return false positives; it may return true
7918 * even if opening the backing file specified by bs's image header
7919 * would result in exactly bs->backing. */
Kevin Wolf004915a2023-10-27 17:53:26 +02007920static bool GRAPH_RDLOCK bdrv_backing_overridden(BlockDriverState *bs)
Max Reitz90993622019-02-01 20:29:09 +01007921{
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -05007922 GLOBAL_STATE_CODE();
Max Reitz90993622019-02-01 20:29:09 +01007923 if (bs->backing) {
7924 return strcmp(bs->auto_backing_file,
7925 bs->backing->bs->filename);
7926 } else {
7927 /* No backing BDS, so if the image header reports any backing
7928 * file, it must have been suppressed */
7929 return bs->auto_backing_file[0] != '\0';
7930 }
7931}
7932
Max Reitz91af7012014-07-18 20:24:56 +02007933/* Updates the following BDS fields:
7934 * - exact_filename: A filename which may be used for opening a block device
7935 * which (mostly) equals the given BDS (even without any
7936 * other options; so reading and writing must return the same
7937 * results, but caching etc. may be different)
7938 * - full_open_options: Options which, when given when opening a block device
7939 * (without a filename), result in a BDS (mostly)
7940 * equalling the given one
7941 * - filename: If exact_filename is set, it is copied here. Otherwise,
7942 * full_open_options is converted to a JSON object, prefixed with
7943 * "json:" (for use through the JSON pseudo protocol) and put here.
7944 */
7945void bdrv_refresh_filename(BlockDriverState *bs)
7946{
7947 BlockDriver *drv = bs->drv;
Max Reitze24518e2019-02-01 20:29:06 +01007948 BdrvChild *child;
Max Reitz52f72d62019-06-12 17:43:03 +02007949 BlockDriverState *primary_child_bs;
Max Reitz91af7012014-07-18 20:24:56 +02007950 QDict *opts;
Max Reitz90993622019-02-01 20:29:09 +01007951 bool backing_overridden;
Max Reitz998b3a12019-02-01 20:29:28 +01007952 bool generate_json_filename; /* Whether our default implementation should
7953 fill exact_filename (false) or not (true) */
Max Reitz91af7012014-07-18 20:24:56 +02007954
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05007955 GLOBAL_STATE_CODE();
7956
Max Reitz91af7012014-07-18 20:24:56 +02007957 if (!drv) {
7958 return;
7959 }
7960
Max Reitze24518e2019-02-01 20:29:06 +01007961 /* This BDS's file name may depend on any of its children's file names, so
7962 * refresh those first */
7963 QLIST_FOREACH(child, &bs->children, next) {
7964 bdrv_refresh_filename(child->bs);
Max Reitz91af7012014-07-18 20:24:56 +02007965 }
7966
Max Reitzbb808d52019-02-01 20:29:07 +01007967 if (bs->implicit) {
7968 /* For implicit nodes, just copy everything from the single child */
7969 child = QLIST_FIRST(&bs->children);
7970 assert(QLIST_NEXT(child, next) == NULL);
7971
7972 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
7973 child->bs->exact_filename);
7974 pstrcpy(bs->filename, sizeof(bs->filename), child->bs->filename);
7975
Pan Nengyuancb895612020-01-16 16:56:00 +08007976 qobject_unref(bs->full_open_options);
Max Reitzbb808d52019-02-01 20:29:07 +01007977 bs->full_open_options = qobject_ref(child->bs->full_open_options);
7978
7979 return;
7980 }
7981
Max Reitz90993622019-02-01 20:29:09 +01007982 backing_overridden = bdrv_backing_overridden(bs);
7983
7984 if (bs->open_flags & BDRV_O_NO_IO) {
7985 /* Without I/O, the backing file does not change anything.
7986 * Therefore, in such a case (primarily qemu-img), we can
7987 * pretend the backing file has not been overridden even if
7988 * it technically has been. */
7989 backing_overridden = false;
7990 }
7991
Max Reitz97e2f022019-02-01 20:29:27 +01007992 /* Gather the options QDict */
7993 opts = qdict_new();
Max Reitz998b3a12019-02-01 20:29:28 +01007994 generate_json_filename = append_strong_runtime_options(opts, bs);
7995 generate_json_filename |= backing_overridden;
Max Reitz97e2f022019-02-01 20:29:27 +01007996
7997 if (drv->bdrv_gather_child_options) {
7998 /* Some block drivers may not want to present all of their children's
7999 * options, or name them differently from BdrvChild.name */
8000 drv->bdrv_gather_child_options(bs, opts, backing_overridden);
8001 } else {
8002 QLIST_FOREACH(child, &bs->children, next) {
Max Reitz25191e52020-05-13 13:05:33 +02008003 if (child == bs->backing && !backing_overridden) {
Max Reitz97e2f022019-02-01 20:29:27 +01008004 /* We can skip the backing BDS if it has not been overridden */
8005 continue;
8006 }
8007
8008 qdict_put(opts, child->name,
8009 qobject_ref(child->bs->full_open_options));
8010 }
8011
8012 if (backing_overridden && !bs->backing) {
8013 /* Force no backing file */
8014 qdict_put_null(opts, "backing");
8015 }
8016 }
8017
8018 qobject_unref(bs->full_open_options);
8019 bs->full_open_options = opts;
8020
Max Reitz52f72d62019-06-12 17:43:03 +02008021 primary_child_bs = bdrv_primary_bs(bs);
8022
Max Reitz998b3a12019-02-01 20:29:28 +01008023 if (drv->bdrv_refresh_filename) {
8024 /* Obsolete information is of no use here, so drop the old file name
8025 * information before refreshing it */
8026 bs->exact_filename[0] = '\0';
8027
8028 drv->bdrv_refresh_filename(bs);
Max Reitz52f72d62019-06-12 17:43:03 +02008029 } else if (primary_child_bs) {
8030 /*
8031 * Try to reconstruct valid information from the underlying
8032 * file -- this only works for format nodes (filter nodes
8033 * cannot be probed and as such must be selected by the user
8034 * either through an options dict, or through a special
8035 * filename which the filter driver must construct in its
8036 * .bdrv_refresh_filename() implementation).
8037 */
Max Reitz998b3a12019-02-01 20:29:28 +01008038
8039 bs->exact_filename[0] = '\0';
8040
Max Reitzfb695c72019-02-01 20:29:29 +01008041 /*
8042 * We can use the underlying file's filename if:
8043 * - it has a filename,
Max Reitz52f72d62019-06-12 17:43:03 +02008044 * - the current BDS is not a filter,
Max Reitzfb695c72019-02-01 20:29:29 +01008045 * - the file is a protocol BDS, and
8046 * - opening that file (as this BDS's format) will automatically create
8047 * the BDS tree we have right now, that is:
8048 * - the user did not significantly change this BDS's behavior with
8049 * some explicit (strong) options
8050 * - no non-file child of this BDS has been overridden by the user
8051 * Both of these conditions are represented by generate_json_filename.
8052 */
Max Reitz52f72d62019-06-12 17:43:03 +02008053 if (primary_child_bs->exact_filename[0] &&
Paolo Bonzini41770f62022-11-24 16:21:18 +01008054 primary_child_bs->drv->protocol_name &&
Max Reitz52f72d62019-06-12 17:43:03 +02008055 !drv->is_filter && !generate_json_filename)
Max Reitzfb695c72019-02-01 20:29:29 +01008056 {
Max Reitz52f72d62019-06-12 17:43:03 +02008057 strcpy(bs->exact_filename, primary_child_bs->exact_filename);
Max Reitz998b3a12019-02-01 20:29:28 +01008058 }
8059 }
8060
Max Reitz91af7012014-07-18 20:24:56 +02008061 if (bs->exact_filename[0]) {
8062 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
Max Reitz97e2f022019-02-01 20:29:27 +01008063 } else {
Markus Armbrustereab3a462020-12-11 18:11:37 +01008064 GString *json = qobject_to_json(QOBJECT(bs->full_open_options));
Eric Blake5c86bdf2020-06-08 13:26:38 -05008065 if (snprintf(bs->filename, sizeof(bs->filename), "json:%s",
Markus Armbrustereab3a462020-12-11 18:11:37 +01008066 json->str) >= sizeof(bs->filename)) {
Eric Blake5c86bdf2020-06-08 13:26:38 -05008067 /* Give user a hint if we truncated things. */
8068 strcpy(bs->filename + sizeof(bs->filename) - 4, "...");
8069 }
Markus Armbrustereab3a462020-12-11 18:11:37 +01008070 g_string_free(json, true);
Max Reitz91af7012014-07-18 20:24:56 +02008071 }
8072}
Wen Congyange06018a2016-05-10 15:36:37 +08008073
Max Reitz1e89d0f2019-02-01 20:29:18 +01008074char *bdrv_dirname(BlockDriverState *bs, Error **errp)
8075{
8076 BlockDriver *drv = bs->drv;
Max Reitz52f72d62019-06-12 17:43:03 +02008077 BlockDriverState *child_bs;
Max Reitz1e89d0f2019-02-01 20:29:18 +01008078
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05008079 GLOBAL_STATE_CODE();
8080
Max Reitz1e89d0f2019-02-01 20:29:18 +01008081 if (!drv) {
8082 error_setg(errp, "Node '%s' is ejected", bs->node_name);
8083 return NULL;
8084 }
8085
8086 if (drv->bdrv_dirname) {
8087 return drv->bdrv_dirname(bs, errp);
8088 }
8089
Max Reitz52f72d62019-06-12 17:43:03 +02008090 child_bs = bdrv_primary_bs(bs);
8091 if (child_bs) {
8092 return bdrv_dirname(child_bs, errp);
Max Reitz1e89d0f2019-02-01 20:29:18 +01008093 }
8094
8095 bdrv_refresh_filename(bs);
8096 if (bs->exact_filename[0] != '\0') {
8097 return path_combine(bs->exact_filename, "");
8098 }
8099
8100 error_setg(errp, "Cannot generate a base directory for %s nodes",
8101 drv->format_name);
8102 return NULL;
8103}
8104
Wen Congyange06018a2016-05-10 15:36:37 +08008105/*
8106 * Hot add/remove a BDS's child. So the user can take a child offline when
8107 * it is broken and take a new child online
8108 */
8109void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
8110 Error **errp)
8111{
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05008112 GLOBAL_STATE_CODE();
Wen Congyange06018a2016-05-10 15:36:37 +08008113 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
8114 error_setg(errp, "The node %s does not support adding a child",
8115 bdrv_get_device_or_node_name(parent_bs));
8116 return;
8117 }
8118
Sam Li774c7262023-05-08 12:55:30 +08008119 /*
8120 * Non-zoned block drivers do not follow zoned storage constraints
8121 * (i.e. sequential writes to zones). Refuse mixing zoned and non-zoned
8122 * drivers in a graph.
8123 */
8124 if (!parent_bs->drv->supports_zoned_children &&
8125 child_bs->bl.zoned == BLK_Z_HM) {
8126 /*
8127 * The host-aware model allows zoned storage constraints and random
8128 * write. Allow mixing host-aware and non-zoned drivers. Using
8129 * host-aware device as a regular device.
8130 */
8131 error_setg(errp, "Cannot add a %s child to a %s parent",
8132 child_bs->bl.zoned == BLK_Z_HM ? "zoned" : "non-zoned",
8133 parent_bs->drv->supports_zoned_children ?
8134 "support zoned children" : "not support zoned children");
8135 return;
8136 }
8137
Wen Congyange06018a2016-05-10 15:36:37 +08008138 if (!QLIST_EMPTY(&child_bs->parents)) {
8139 error_setg(errp, "The node %s already has a parent",
8140 child_bs->node_name);
8141 return;
8142 }
8143
8144 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
8145}
8146
8147void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
8148{
8149 BdrvChild *tmp;
8150
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05008151 GLOBAL_STATE_CODE();
Wen Congyange06018a2016-05-10 15:36:37 +08008152 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
8153 error_setg(errp, "The node %s does not support removing a child",
8154 bdrv_get_device_or_node_name(parent_bs));
8155 return;
8156 }
8157
8158 QLIST_FOREACH(tmp, &parent_bs->children, next) {
8159 if (tmp == child) {
8160 break;
8161 }
8162 }
8163
8164 if (!tmp) {
8165 error_setg(errp, "The node %s does not have a child named %s",
8166 bdrv_get_device_or_node_name(parent_bs),
8167 bdrv_get_device_or_node_name(child->bs));
8168 return;
8169 }
8170
8171 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
8172}
Max Reitz6f7a3b52020-04-29 16:11:23 +02008173
8174int bdrv_make_empty(BdrvChild *c, Error **errp)
8175{
8176 BlockDriver *drv = c->bs->drv;
8177 int ret;
8178
Emanuele Giuseppe Espositof791bf72022-03-03 10:15:49 -05008179 GLOBAL_STATE_CODE();
Max Reitz6f7a3b52020-04-29 16:11:23 +02008180 assert(c->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED));
8181
8182 if (!drv->bdrv_make_empty) {
8183 error_setg(errp, "%s does not support emptying nodes",
8184 drv->format_name);
8185 return -ENOTSUP;
8186 }
8187
8188 ret = drv->bdrv_make_empty(c->bs);
8189 if (ret < 0) {
8190 error_setg_errno(errp, -ret, "Failed to empty %s",
8191 c->bs->filename);
8192 return ret;
8193 }
8194
8195 return 0;
8196}
Max Reitz9a6fc882019-05-31 15:23:11 +02008197
8198/*
8199 * Return the child that @bs acts as an overlay for, and from which data may be
8200 * copied in COW or COR operations. Usually this is the backing file.
8201 */
8202BdrvChild *bdrv_cow_child(BlockDriverState *bs)
8203{
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008204 IO_CODE();
8205
Max Reitz9a6fc882019-05-31 15:23:11 +02008206 if (!bs || !bs->drv) {
8207 return NULL;
8208 }
8209
8210 if (bs->drv->is_filter) {
8211 return NULL;
8212 }
8213
8214 if (!bs->backing) {
8215 return NULL;
8216 }
8217
8218 assert(bs->backing->role & BDRV_CHILD_COW);
8219 return bs->backing;
8220}
8221
8222/*
8223 * If @bs acts as a filter for exactly one of its children, return
8224 * that child.
8225 */
8226BdrvChild *bdrv_filter_child(BlockDriverState *bs)
8227{
8228 BdrvChild *c;
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008229 IO_CODE();
Max Reitz9a6fc882019-05-31 15:23:11 +02008230
8231 if (!bs || !bs->drv) {
8232 return NULL;
8233 }
8234
8235 if (!bs->drv->is_filter) {
8236 return NULL;
8237 }
8238
8239 /* Only one of @backing or @file may be used */
8240 assert(!(bs->backing && bs->file));
8241
8242 c = bs->backing ?: bs->file;
8243 if (!c) {
8244 return NULL;
8245 }
8246
8247 assert(c->role & BDRV_CHILD_FILTERED);
8248 return c;
8249}
8250
8251/*
8252 * Return either the result of bdrv_cow_child() or bdrv_filter_child(),
8253 * whichever is non-NULL.
8254 *
8255 * Return NULL if both are NULL.
8256 */
8257BdrvChild *bdrv_filter_or_cow_child(BlockDriverState *bs)
8258{
8259 BdrvChild *cow_child = bdrv_cow_child(bs);
8260 BdrvChild *filter_child = bdrv_filter_child(bs);
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008261 IO_CODE();
Max Reitz9a6fc882019-05-31 15:23:11 +02008262
8263 /* Filter nodes cannot have COW backing files */
8264 assert(!(cow_child && filter_child));
8265
8266 return cow_child ?: filter_child;
8267}
8268
8269/*
8270 * Return the primary child of this node: For filters, that is the
8271 * filtered child. For other nodes, that is usually the child storing
8272 * metadata.
8273 * (A generally more helpful description is that this is (usually) the
8274 * child that has the same filename as @bs.)
8275 *
8276 * Drivers do not necessarily have a primary child; for example quorum
8277 * does not.
8278 */
8279BdrvChild *bdrv_primary_child(BlockDriverState *bs)
8280{
8281 BdrvChild *c, *found = NULL;
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008282 IO_CODE();
Max Reitz9a6fc882019-05-31 15:23:11 +02008283
8284 QLIST_FOREACH(c, &bs->children, next) {
8285 if (c->role & BDRV_CHILD_PRIMARY) {
8286 assert(!found);
8287 found = c;
8288 }
8289 }
8290
8291 return found;
8292}
Max Reitzd38d7eb2019-06-12 15:06:37 +02008293
Kevin Wolfec82cc42023-10-27 17:53:20 +02008294static BlockDriverState * GRAPH_RDLOCK
8295bdrv_do_skip_filters(BlockDriverState *bs, bool stop_on_explicit_filter)
Max Reitzd38d7eb2019-06-12 15:06:37 +02008296{
8297 BdrvChild *c;
8298
8299 if (!bs) {
8300 return NULL;
8301 }
8302
8303 while (!(stop_on_explicit_filter && !bs->implicit)) {
8304 c = bdrv_filter_child(bs);
8305 if (!c) {
8306 /*
8307 * A filter that is embedded in a working block graph must
8308 * have a child. Assert this here so this function does
8309 * not return a filter node that is not expected by the
8310 * caller.
8311 */
8312 assert(!bs->drv || !bs->drv->is_filter);
8313 break;
8314 }
8315 bs = c->bs;
8316 }
8317 /*
8318 * Note that this treats nodes with bs->drv == NULL as not being
8319 * filters (bs->drv == NULL should be replaced by something else
8320 * anyway).
8321 * The advantage of this behavior is that this function will thus
8322 * always return a non-NULL value (given a non-NULL @bs).
8323 */
8324
8325 return bs;
8326}
8327
8328/*
8329 * Return the first BDS that has not been added implicitly or that
8330 * does not have a filtered child down the chain starting from @bs
8331 * (including @bs itself).
8332 */
8333BlockDriverState *bdrv_skip_implicit_filters(BlockDriverState *bs)
8334{
Emanuele Giuseppe Espositob4ad82a2022-03-03 10:15:57 -05008335 GLOBAL_STATE_CODE();
Max Reitzd38d7eb2019-06-12 15:06:37 +02008336 return bdrv_do_skip_filters(bs, true);
8337}
8338
8339/*
8340 * Return the first BDS that does not have a filtered child down the
8341 * chain starting from @bs (including @bs itself).
8342 */
8343BlockDriverState *bdrv_skip_filters(BlockDriverState *bs)
8344{
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008345 IO_CODE();
Max Reitzd38d7eb2019-06-12 15:06:37 +02008346 return bdrv_do_skip_filters(bs, false);
8347}
8348
8349/*
8350 * For a backing chain, return the first non-filter backing image of
8351 * the first non-filter image.
8352 */
8353BlockDriverState *bdrv_backing_chain_next(BlockDriverState *bs)
8354{
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008355 IO_CODE();
Max Reitzd38d7eb2019-06-12 15:06:37 +02008356 return bdrv_skip_filters(bdrv_cow_bs(bdrv_skip_filters(bs)));
8357}
Hanna Reitz0bc329f2021-08-12 10:41:44 +02008358
8359/**
8360 * Check whether [offset, offset + bytes) overlaps with the cached
8361 * block-status data region.
8362 *
8363 * If so, and @pnum is not NULL, set *pnum to `bsc.data_end - offset`,
8364 * which is what bdrv_bsc_is_data()'s interface needs.
8365 * Otherwise, *pnum is not touched.
8366 */
8367static bool bdrv_bsc_range_overlaps_locked(BlockDriverState *bs,
8368 int64_t offset, int64_t bytes,
8369 int64_t *pnum)
8370{
8371 BdrvBlockStatusCache *bsc = qatomic_rcu_read(&bs->block_status_cache);
8372 bool overlaps;
8373
8374 overlaps =
8375 qatomic_read(&bsc->valid) &&
8376 ranges_overlap(offset, bytes, bsc->data_start,
8377 bsc->data_end - bsc->data_start);
8378
8379 if (overlaps && pnum) {
8380 *pnum = bsc->data_end - offset;
8381 }
8382
8383 return overlaps;
8384}
8385
8386/**
8387 * See block_int.h for this function's documentation.
8388 */
8389bool bdrv_bsc_is_data(BlockDriverState *bs, int64_t offset, int64_t *pnum)
8390{
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008391 IO_CODE();
Hanna Reitz0bc329f2021-08-12 10:41:44 +02008392 RCU_READ_LOCK_GUARD();
Hanna Reitz0bc329f2021-08-12 10:41:44 +02008393 return bdrv_bsc_range_overlaps_locked(bs, offset, 1, pnum);
8394}
8395
8396/**
8397 * See block_int.h for this function's documentation.
8398 */
8399void bdrv_bsc_invalidate_range(BlockDriverState *bs,
8400 int64_t offset, int64_t bytes)
8401{
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008402 IO_CODE();
Hanna Reitz0bc329f2021-08-12 10:41:44 +02008403 RCU_READ_LOCK_GUARD();
8404
8405 if (bdrv_bsc_range_overlaps_locked(bs, offset, bytes, NULL)) {
8406 qatomic_set(&bs->block_status_cache->valid, false);
8407 }
8408}
8409
8410/**
8411 * See block_int.h for this function's documentation.
8412 */
8413void bdrv_bsc_fill(BlockDriverState *bs, int64_t offset, int64_t bytes)
8414{
8415 BdrvBlockStatusCache *new_bsc = g_new(BdrvBlockStatusCache, 1);
8416 BdrvBlockStatusCache *old_bsc;
Emanuele Giuseppe Esposito967d7902022-03-03 10:15:58 -05008417 IO_CODE();
Hanna Reitz0bc329f2021-08-12 10:41:44 +02008418
8419 *new_bsc = (BdrvBlockStatusCache) {
8420 .valid = true,
8421 .data_start = offset,
8422 .data_end = offset + bytes,
8423 };
8424
8425 QEMU_LOCK_GUARD(&bs->bsc_modify_lock);
8426
8427 old_bsc = qatomic_rcu_read(&bs->block_status_cache);
8428 qatomic_rcu_set(&bs->block_status_cache, new_bsc);
8429 if (old_bsc) {
8430 g_free_rcu(old_bsc, rcu);
8431 }
8432}