2003-06-30 12:03:06 +02:00
|
|
|
/*
|
|
|
|
* QEMU System Emulator block driver
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2003-06-30 12:03:06 +02:00
|
|
|
* Copyright (c) 2003 Fabrice Bellard
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2003-06-30 12:03:06 +02:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2018-02-01 12:18:31 +01:00
|
|
|
|
2016-01-29 18:50:05 +01:00
|
|
|
#include "qemu/osdep.h"
|
2017-01-25 17:14:15 +01:00
|
|
|
#include "block/trace.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block_int.h"
|
|
|
|
#include "block/blockjob.h"
|
2016-07-06 11:22:39 +02:00
|
|
|
#include "block/nbd.h"
|
2018-06-14 21:14:28 +02:00
|
|
|
#include "block/qdict.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qemu/error-report.h"
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
#include "module_block.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/module.h"
|
2018-02-01 12:18:31 +01:00
|
|
|
#include "qapi/error.h"
|
2018-02-01 12:18:39 +01:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qjson.h"
|
2018-02-24 16:40:32 +01:00
|
|
|
#include "qapi/qmp/qnull.h"
|
2018-02-01 12:18:40 +01:00
|
|
|
#include "qapi/qmp/qstring.h"
|
2018-01-10 15:52:33 +01:00
|
|
|
#include "qapi/qobject-output-visitor.h"
|
|
|
|
#include "qapi/qapi-visit-block-core.h"
|
2014-10-07 13:59:11 +02:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/notify.h"
|
2018-02-01 12:18:46 +01:00
|
|
|
#include "qemu/option.h"
|
2015-09-01 15:48:02 +02:00
|
|
|
#include "qemu/coroutine.h"
|
2014-01-23 21:31:34 +01:00
|
|
|
#include "block/qapi.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/timer.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
|
|
|
#include "qemu/id.h"
|
2003-06-30 12:03:06 +02:00
|
|
|
|
2009-07-27 16:12:56 +02:00
|
|
|
#ifdef CONFIG_BSD
|
2005-04-26 23:59:26 +02:00
|
|
|
#include <sys/ioctl.h>
|
2009-09-12 09:36:22 +02:00
|
|
|
#include <sys/queue.h>
|
2009-03-07 21:06:23 +01:00
|
|
|
#ifndef __DragonFly__
|
2005-04-26 23:59:26 +02:00
|
|
|
#include <sys/disk.h>
|
|
|
|
#endif
|
2009-03-07 21:06:23 +01:00
|
|
|
#endif
|
2005-04-26 23:59:26 +02:00
|
|
|
|
2009-03-08 17:26:59 +01:00
|
|
|
#ifdef _WIN32
|
|
|
|
#include <windows.h>
|
|
|
|
#endif
|
|
|
|
|
2011-10-13 14:08:22 +02:00
|
|
|
#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
|
|
|
|
|
2014-01-23 21:31:32 +01:00
|
|
|
static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
|
|
|
|
QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
|
|
|
|
|
2016-01-29 16:36:11 +01:00
|
|
|
static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
|
|
|
|
QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
|
|
|
|
|
2010-04-13 11:29:33 +02:00
|
|
|
static QLIST_HEAD(, BlockDriver) bdrv_drivers =
|
|
|
|
QLIST_HEAD_INITIALIZER(bdrv_drivers);
|
2004-08-01 23:59:26 +02:00
|
|
|
|
2016-05-17 16:41:31 +02:00
|
|
|
static BlockDriverState *bdrv_open_inherit(const char *filename,
|
|
|
|
const char *reference,
|
|
|
|
QDict *options, int flags,
|
|
|
|
BlockDriverState *parent,
|
|
|
|
const BdrvChildRole *child_role,
|
|
|
|
Error **errp);
|
2015-04-08 13:43:47 +02:00
|
|
|
|
2009-10-27 18:41:44 +01:00
|
|
|
/* If non-zero, use only whitelisted block drivers */
|
|
|
|
static int use_bdrv_whitelist;
|
|
|
|
|
2010-12-09 12:53:00 +01:00
|
|
|
#ifdef _WIN32
|
|
|
|
static int is_windows_drive_prefix(const char *filename)
|
|
|
|
{
|
|
|
|
return (((filename[0] >= 'a' && filename[0] <= 'z') ||
|
|
|
|
(filename[0] >= 'A' && filename[0] <= 'Z')) &&
|
|
|
|
filename[1] == ':');
|
|
|
|
}
|
|
|
|
|
|
|
|
int is_windows_drive(const char *filename)
|
|
|
|
{
|
|
|
|
if (is_windows_drive_prefix(filename) &&
|
|
|
|
filename[2] == '\0')
|
|
|
|
return 1;
|
|
|
|
if (strstart(filename, "\\\\.\\", NULL) ||
|
|
|
|
strstart(filename, "//./", NULL))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-11-28 10:23:32 +01:00
|
|
|
size_t bdrv_opt_mem_align(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
if (!bs || !bs->drv) {
|
block: align bounce buffers to page
The following sequence
int fd = open(argv[1], O_RDWR | O_CREAT | O_DIRECT, 0644);
for (i = 0; i < 100000; i++)
write(fd, buf, 4096);
performs 5% better if buf is aligned to 4096 bytes.
The difference is quite reliable.
On the other hand we do not want at the moment to enforce bounce
buffering if guest request is aligned to 512 bytes.
The patch changes default bounce buffer optimal alignment to
MAX(page size, 4k). 4k is chosen as maximal known sector size on real
HDD.
The justification of the performance improve is quite interesting.
From the kernel point of view each request to the disk was split
by two. This could be seen by blktrace like this:
9,0 11 1 0.000000000 11151 Q WS 312737792 + 1023 [qemu-img]
9,0 11 2 0.000007938 11151 Q WS 312738815 + 8 [qemu-img]
9,0 11 3 0.000030735 11151 Q WS 312738823 + 1016 [qemu-img]
9,0 11 4 0.000032482 11151 Q WS 312739839 + 8 [qemu-img]
9,0 11 5 0.000041379 11151 Q WS 312739847 + 1016 [qemu-img]
9,0 11 6 0.000042818 11151 Q WS 312740863 + 8 [qemu-img]
9,0 11 7 0.000051236 11151 Q WS 312740871 + 1017 [qemu-img]
9,0 5 1 0.169071519 11151 Q WS 312741888 + 1023 [qemu-img]
After the patch the pattern becomes normal:
9,0 6 1 0.000000000 12422 Q WS 314834944 + 1024 [qemu-img]
9,0 6 2 0.000038527 12422 Q WS 314835968 + 1024 [qemu-img]
9,0 6 3 0.000072849 12422 Q WS 314836992 + 1024 [qemu-img]
9,0 6 4 0.000106276 12422 Q WS 314838016 + 1024 [qemu-img]
and the amount of requests sent to disk (could be calculated counting
number of lines in the output of blktrace) is reduced about 2 times.
Both qemu-img and qemu-io are affected while qemu-kvm is not. The guest
does his job well and real requests comes properly aligned (to page).
Signed-off-by: Denis V. Lunev <den@openvz.org>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 1431441056-26198-3-git-send-email-den@openvz.org
CC: Paolo Bonzini <pbonzini@redhat.com>
CC: Kevin Wolf <kwolf@redhat.com>
CC: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-05-12 16:30:56 +02:00
|
|
|
/* page size or 4k (hdd sector size) should be on the safe side */
|
|
|
|
return MAX(4096, getpagesize());
|
2013-11-28 10:23:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return bs->bl.opt_mem_alignment;
|
|
|
|
}
|
|
|
|
|
2015-05-12 16:30:55 +02:00
|
|
|
size_t bdrv_min_mem_align(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
if (!bs || !bs->drv) {
|
block: align bounce buffers to page
The following sequence
int fd = open(argv[1], O_RDWR | O_CREAT | O_DIRECT, 0644);
for (i = 0; i < 100000; i++)
write(fd, buf, 4096);
performs 5% better if buf is aligned to 4096 bytes.
The difference is quite reliable.
On the other hand we do not want at the moment to enforce bounce
buffering if guest request is aligned to 512 bytes.
The patch changes default bounce buffer optimal alignment to
MAX(page size, 4k). 4k is chosen as maximal known sector size on real
HDD.
The justification of the performance improve is quite interesting.
From the kernel point of view each request to the disk was split
by two. This could be seen by blktrace like this:
9,0 11 1 0.000000000 11151 Q WS 312737792 + 1023 [qemu-img]
9,0 11 2 0.000007938 11151 Q WS 312738815 + 8 [qemu-img]
9,0 11 3 0.000030735 11151 Q WS 312738823 + 1016 [qemu-img]
9,0 11 4 0.000032482 11151 Q WS 312739839 + 8 [qemu-img]
9,0 11 5 0.000041379 11151 Q WS 312739847 + 1016 [qemu-img]
9,0 11 6 0.000042818 11151 Q WS 312740863 + 8 [qemu-img]
9,0 11 7 0.000051236 11151 Q WS 312740871 + 1017 [qemu-img]
9,0 5 1 0.169071519 11151 Q WS 312741888 + 1023 [qemu-img]
After the patch the pattern becomes normal:
9,0 6 1 0.000000000 12422 Q WS 314834944 + 1024 [qemu-img]
9,0 6 2 0.000038527 12422 Q WS 314835968 + 1024 [qemu-img]
9,0 6 3 0.000072849 12422 Q WS 314836992 + 1024 [qemu-img]
9,0 6 4 0.000106276 12422 Q WS 314838016 + 1024 [qemu-img]
and the amount of requests sent to disk (could be calculated counting
number of lines in the output of blktrace) is reduced about 2 times.
Both qemu-img and qemu-io are affected while qemu-kvm is not. The guest
does his job well and real requests comes properly aligned (to page).
Signed-off-by: Denis V. Lunev <den@openvz.org>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 1431441056-26198-3-git-send-email-den@openvz.org
CC: Paolo Bonzini <pbonzini@redhat.com>
CC: Kevin Wolf <kwolf@redhat.com>
CC: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-05-12 16:30:56 +02:00
|
|
|
/* page size or 4k (hdd sector size) should be on the safe side */
|
|
|
|
return MAX(4096, getpagesize());
|
2015-05-12 16:30:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return bs->bl.min_mem_alignment;
|
|
|
|
}
|
|
|
|
|
2010-12-09 12:53:00 +01:00
|
|
|
/* check if the path starts with "<protocol>:" */
|
2014-12-03 14:57:22 +01:00
|
|
|
int path_has_protocol(const char *path)
|
2010-12-09 12:53:00 +01:00
|
|
|
{
|
2012-05-08 16:51:48 +02:00
|
|
|
const char *p;
|
|
|
|
|
2010-12-09 12:53:00 +01:00
|
|
|
#ifdef _WIN32
|
|
|
|
if (is_windows_drive(path) ||
|
|
|
|
is_windows_drive_prefix(path)) {
|
|
|
|
return 0;
|
|
|
|
}
|
2012-05-08 16:51:48 +02:00
|
|
|
p = path + strcspn(path, ":/\\");
|
|
|
|
#else
|
|
|
|
p = path + strcspn(path, ":/");
|
2010-12-09 12:53:00 +01:00
|
|
|
#endif
|
|
|
|
|
2012-05-08 16:51:48 +02:00
|
|
|
return *p == ':';
|
2010-12-09 12:53:00 +01:00
|
|
|
}
|
|
|
|
|
2006-08-01 18:21:11 +02:00
|
|
|
int path_is_absolute(const char *path)
|
2005-10-30 19:30:10 +01:00
|
|
|
{
|
2007-01-07 19:22:37 +01:00
|
|
|
#ifdef _WIN32
|
|
|
|
/* specific case for names like: "\\.\d:" */
|
2012-05-08 16:51:47 +02:00
|
|
|
if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
|
2007-01-07 19:22:37 +01:00
|
|
|
return 1;
|
2012-05-08 16:51:47 +02:00
|
|
|
}
|
|
|
|
return (*path == '/' || *path == '\\');
|
2007-01-07 18:27:07 +01:00
|
|
|
#else
|
2012-05-08 16:51:47 +02:00
|
|
|
return (*path == '/');
|
2007-01-07 18:27:07 +01:00
|
|
|
#endif
|
2005-10-30 19:30:10 +01:00
|
|
|
}
|
|
|
|
|
2006-08-01 18:21:11 +02:00
|
|
|
/* if filename is absolute, just copy it to dest. Otherwise, build a
|
|
|
|
path to it by considering it is relative to base_path. URL are
|
|
|
|
supported. */
|
|
|
|
void path_combine(char *dest, int dest_size,
|
|
|
|
const char *base_path,
|
|
|
|
const char *filename)
|
2005-10-30 19:30:10 +01:00
|
|
|
{
|
2006-08-01 18:21:11 +02:00
|
|
|
const char *p, *p1;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (dest_size <= 0)
|
|
|
|
return;
|
|
|
|
if (path_is_absolute(filename)) {
|
|
|
|
pstrcpy(dest, dest_size, filename);
|
|
|
|
} else {
|
2017-05-22 21:52:15 +02:00
|
|
|
const char *protocol_stripped = NULL;
|
|
|
|
|
|
|
|
if (path_has_protocol(base_path)) {
|
|
|
|
protocol_stripped = strchr(base_path, ':');
|
|
|
|
if (protocol_stripped) {
|
|
|
|
protocol_stripped++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
p = protocol_stripped ?: base_path;
|
|
|
|
|
2007-01-07 18:27:07 +01:00
|
|
|
p1 = strrchr(base_path, '/');
|
|
|
|
#ifdef _WIN32
|
|
|
|
{
|
|
|
|
const char *p2;
|
|
|
|
p2 = strrchr(base_path, '\\');
|
|
|
|
if (!p1 || p2 > p1)
|
|
|
|
p1 = p2;
|
|
|
|
}
|
|
|
|
#endif
|
2006-08-01 18:21:11 +02:00
|
|
|
if (p1)
|
|
|
|
p1++;
|
|
|
|
else
|
|
|
|
p1 = base_path;
|
|
|
|
if (p1 > p)
|
|
|
|
p = p1;
|
|
|
|
len = p - base_path;
|
|
|
|
if (len > dest_size - 1)
|
|
|
|
len = dest_size - 1;
|
|
|
|
memcpy(dest, base_path, len);
|
|
|
|
dest[len] = '\0';
|
|
|
|
pstrcat(dest, dest_size, filename);
|
2005-10-30 19:30:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-22 21:52:16 +02:00
|
|
|
/*
|
|
|
|
* Helper function for bdrv_parse_filename() implementations to remove optional
|
|
|
|
* protocol prefixes (especially "file:") from a filename and for putting the
|
|
|
|
* stripped filename into the options QDict if there is such a prefix.
|
|
|
|
*/
|
|
|
|
void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix,
|
|
|
|
QDict *options)
|
|
|
|
{
|
|
|
|
if (strstart(filename, prefix, &filename)) {
|
|
|
|
/* Stripping the explicit protocol prefix may result in a protocol
|
|
|
|
* prefix being (wrongly) detected (if the filename contains a colon) */
|
|
|
|
if (path_has_protocol(filename)) {
|
|
|
|
QString *fat_filename;
|
|
|
|
|
|
|
|
/* This means there is some colon before the first slash; therefore,
|
|
|
|
* this cannot be an absolute path */
|
|
|
|
assert(!path_is_absolute(filename));
|
|
|
|
|
|
|
|
/* And we can thus fix the protocol detection issue by prefixing it
|
|
|
|
* by "./" */
|
|
|
|
fat_filename = qstring_from_str("./");
|
|
|
|
qstring_append(fat_filename, filename);
|
|
|
|
|
|
|
|
assert(!path_has_protocol(qstring_get_str(fat_filename)));
|
|
|
|
|
|
|
|
qdict_put(options, "filename", fat_filename);
|
|
|
|
} else {
|
|
|
|
/* If no protocol prefix was detected, we can use the shortened
|
|
|
|
* filename as-is */
|
|
|
|
qdict_put_str(options, "filename", filename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-05-04 18:52:40 +02:00
|
|
|
/* Returns whether the image file is opened as read-only. Note that this can
|
|
|
|
* return false and writing to the image file is still not possible because the
|
|
|
|
* image is inactivated. */
|
2017-04-07 22:55:28 +02:00
|
|
|
bool bdrv_is_read_only(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
return bs->read_only;
|
|
|
|
}
|
|
|
|
|
2017-08-03 17:02:58 +02:00
|
|
|
int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
|
|
|
|
bool ignore_allow_rdw, Error **errp)
|
2017-04-07 22:55:25 +02:00
|
|
|
{
|
block: do not set BDS read_only if copy_on_read enabled
A few block drivers will set the BDS read_only flag from their
.bdrv_open() function. This means the bs->read_only flag could
be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ
flag check occurs prior to the call to bdrv->bdrv_open().
This adds an error return to bdrv_set_read_only(), and an error will be
return if we try to set the BDS to read_only while copy_on_read is
enabled.
This patch also changes the behavior of vvfat. Before, vvfat could
override the drive 'readonly' flag with its own, internal 'rw' flag.
For instance, this -drive parameter would result in a writable image:
"-drive format=vvfat,dir=/tmp/vvfat,rw,if=virtio,readonly=on"
This is not correct. Now, attempting to use the above -drive parameter
will result in an error (i.e., 'rw' is incompatible with 'readonly=on').
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 0c5b4c1cc2c651471b131f21376dfd5ea24d2196.1491597120.git.jcody@redhat.com
2017-04-07 22:55:26 +02:00
|
|
|
/* Do not set read_only if copy_on_read is enabled */
|
|
|
|
if (bs->copy_on_read && read_only) {
|
|
|
|
error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
|
|
|
|
bdrv_get_device_or_node_name(bs));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-04-07 22:55:27 +02:00
|
|
|
/* Do not clear read_only if it is prohibited */
|
2017-08-03 17:02:58 +02:00
|
|
|
if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&
|
|
|
|
!ignore_allow_rdw)
|
|
|
|
{
|
2017-04-07 22:55:27 +02:00
|
|
|
error_setg(errp, "Node '%s' is read only",
|
|
|
|
bdrv_get_device_or_node_name(bs));
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
2017-04-07 22:55:29 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-10-12 11:27:41 +02:00
|
|
|
/*
|
|
|
|
* Called by a driver that can only provide a read-only image.
|
|
|
|
*
|
|
|
|
* Returns 0 if the node is already read-only or it could switch the node to
|
|
|
|
* read-only because BDRV_O_AUTO_RDONLY is set.
|
|
|
|
*
|
|
|
|
* Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set
|
|
|
|
* or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg
|
|
|
|
* is not NULL, it is used as the error message for the Error object.
|
|
|
|
*/
|
|
|
|
int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
|
|
|
|
Error **errp)
|
2017-04-07 22:55:29 +02:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2018-10-12 11:27:41 +02:00
|
|
|
if (!(bs->open_flags & BDRV_O_RDWR)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) {
|
|
|
|
goto fail;
|
2017-04-07 22:55:29 +02:00
|
|
|
}
|
|
|
|
|
2018-10-12 11:27:41 +02:00
|
|
|
ret = bdrv_can_set_read_only(bs, true, false, NULL);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
2018-10-09 16:57:12 +02:00
|
|
|
}
|
|
|
|
|
2018-10-12 11:27:41 +02:00
|
|
|
bs->read_only = true;
|
|
|
|
bs->open_flags &= ~BDRV_O_RDWR;
|
|
|
|
|
block: do not set BDS read_only if copy_on_read enabled
A few block drivers will set the BDS read_only flag from their
.bdrv_open() function. This means the bs->read_only flag could
be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ
flag check occurs prior to the call to bdrv->bdrv_open().
This adds an error return to bdrv_set_read_only(), and an error will be
return if we try to set the BDS to read_only while copy_on_read is
enabled.
This patch also changes the behavior of vvfat. Before, vvfat could
override the drive 'readonly' flag with its own, internal 'rw' flag.
For instance, this -drive parameter would result in a writable image:
"-drive format=vvfat,dir=/tmp/vvfat,rw,if=virtio,readonly=on"
This is not correct. Now, attempting to use the above -drive parameter
will result in an error (i.e., 'rw' is incompatible with 'readonly=on').
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 0c5b4c1cc2c651471b131f21376dfd5ea24d2196.1491597120.git.jcody@redhat.com
2017-04-07 22:55:26 +02:00
|
|
|
return 0;
|
2018-10-12 11:27:41 +02:00
|
|
|
|
|
|
|
fail:
|
|
|
|
error_setg(errp, "%s", errmsg ?: "Image is read-only");
|
|
|
|
return -EACCES;
|
2017-04-07 22:55:25 +02:00
|
|
|
}
|
|
|
|
|
2014-11-26 17:20:25 +01:00
|
|
|
void bdrv_get_full_backing_filename_from_filename(const char *backed,
|
|
|
|
const char *backing,
|
2014-11-26 17:20:26 +01:00
|
|
|
char *dest, size_t sz,
|
|
|
|
Error **errp)
|
2012-05-08 16:51:50 +02:00
|
|
|
{
|
2014-11-26 17:20:26 +01:00
|
|
|
if (backing[0] == '\0' || path_has_protocol(backing) ||
|
|
|
|
path_is_absolute(backing))
|
|
|
|
{
|
2014-11-26 17:20:25 +01:00
|
|
|
pstrcpy(dest, sz, backing);
|
2014-11-26 17:20:26 +01:00
|
|
|
} else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
|
|
|
|
error_setg(errp, "Cannot use relative backing file names for '%s'",
|
|
|
|
backed);
|
2012-05-08 16:51:50 +02:00
|
|
|
} else {
|
2014-11-26 17:20:25 +01:00
|
|
|
path_combine(dest, sz, backed, backing);
|
2012-05-08 16:51:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-26 17:20:26 +01:00
|
|
|
void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
|
|
|
|
Error **errp)
|
2014-11-26 17:20:25 +01:00
|
|
|
{
|
2014-11-26 17:20:26 +01:00
|
|
|
char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
|
|
|
|
|
|
|
|
bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
|
|
|
|
dest, sz, errp);
|
2014-11-26 17:20:25 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:51 +02:00
|
|
|
void bdrv_register(BlockDriver *bdrv)
|
|
|
|
{
|
2010-04-13 11:29:33 +02:00
|
|
|
QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
|
2004-08-01 23:59:26 +02:00
|
|
|
}
|
2004-03-14 22:38:54 +01:00
|
|
|
|
2014-10-07 13:59:03 +02:00
|
|
|
BlockDriverState *bdrv_new(void)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs;
|
|
|
|
int i;
|
|
|
|
|
block: Use g_new() & friends where that makes obvious sense
g_new(T, n) is neater than g_malloc(sizeof(T) * n). It's also safer,
for two reasons. One, it catches multiplication overflowing size_t.
Two, it returns T * rather than void *, which lets the compiler catch
more type errors.
Patch created with Coccinelle, with two manual changes on top:
* Add const to bdrv_iterate_format() to keep the types straight
* Convert the allocation in bdrv_drop_intermediate(), which Coccinelle
inexplicably misses
Coccinelle semantic patch:
@@
type T;
@@
-g_malloc(sizeof(T))
+g_new(T, 1)
@@
type T;
@@
-g_try_malloc(sizeof(T))
+g_try_new(T, 1)
@@
type T;
@@
-g_malloc0(sizeof(T))
+g_new0(T, 1)
@@
type T;
@@
-g_try_malloc0(sizeof(T))
+g_try_new0(T, 1)
@@
type T;
expression n;
@@
-g_malloc(sizeof(T) * (n))
+g_new(T, n)
@@
type T;
expression n;
@@
-g_try_malloc(sizeof(T) * (n))
+g_try_new(T, n)
@@
type T;
expression n;
@@
-g_malloc0(sizeof(T) * (n))
+g_new0(T, n)
@@
type T;
expression n;
@@
-g_try_malloc0(sizeof(T) * (n))
+g_try_new0(T, n)
@@
type T;
expression p, n;
@@
-g_realloc(p, sizeof(T) * (n))
+g_renew(T, p, n)
@@
type T;
expression p, n;
@@
-g_try_realloc(p, sizeof(T) * (n))
+g_try_renew(T, p, n)
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-08-19 10:31:08 +02:00
|
|
|
bs = g_new0(BlockDriverState, 1);
|
2013-11-13 11:29:43 +01:00
|
|
|
QLIST_INIT(&bs->dirty_bitmaps);
|
2014-05-23 15:29:42 +02:00
|
|
|
for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
|
|
|
|
QLIST_INIT(&bs->op_blockers[i]);
|
|
|
|
}
|
2013-06-24 17:13:10 +02:00
|
|
|
notifier_with_return_list_init(&bs->before_write_notifiers);
|
2017-06-05 14:39:02 +02:00
|
|
|
qemu_co_mutex_init(&bs->reqs_lock);
|
2017-06-05 14:39:03 +02:00
|
|
|
qemu_mutex_init(&bs->dirty_bitmap_mutex);
|
2013-08-23 03:14:46 +02:00
|
|
|
bs->refcnt = 1;
|
2014-05-08 16:34:37 +02:00
|
|
|
bs->aio_context = qemu_get_aio_context();
|
2012-08-23 11:20:36 +02:00
|
|
|
|
2016-07-18 21:39:52 +02:00
|
|
|
qemu_co_queue_init(&bs->flush_queue);
|
|
|
|
|
2018-03-28 18:29:18 +02:00
|
|
|
for (i = 0; i < bdrv_drain_all_count; i++) {
|
|
|
|
bdrv_drained_begin(bs);
|
|
|
|
}
|
|
|
|
|
2016-01-29 16:36:11 +01:00
|
|
|
QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
|
|
|
|
|
2004-03-14 22:38:54 +01:00
|
|
|
return bs;
|
|
|
|
}
|
|
|
|
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
static BlockDriver *bdrv_do_find_format(const char *format_name)
|
2004-08-01 23:59:26 +02:00
|
|
|
{
|
|
|
|
BlockDriver *drv1;
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
|
2010-04-13 11:29:33 +02:00
|
|
|
QLIST_FOREACH(drv1, &bdrv_drivers, list) {
|
|
|
|
if (!strcmp(drv1->format_name, format_name)) {
|
2004-08-01 23:59:26 +02:00
|
|
|
return drv1;
|
2010-04-13 11:29:33 +02:00
|
|
|
}
|
2004-08-01 23:59:26 +02:00
|
|
|
}
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
|
2004-08-01 23:59:26 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
BlockDriver *bdrv_find_format(const char *format_name)
|
|
|
|
{
|
|
|
|
BlockDriver *drv1;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
drv1 = bdrv_do_find_format(format_name);
|
|
|
|
if (drv1) {
|
|
|
|
return drv1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The driver isn't registered, maybe we need to load a module */
|
|
|
|
for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
|
|
|
|
if (!strcmp(block_driver_modules[i].format_name, format_name)) {
|
|
|
|
block_module_load_one(block_driver_modules[i].library_name);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return bdrv_do_find_format(format_name);
|
|
|
|
}
|
|
|
|
|
2018-02-21 11:47:43 +01:00
|
|
|
int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
|
2009-10-27 18:41:44 +01:00
|
|
|
{
|
2013-05-29 13:35:40 +02:00
|
|
|
static const char *whitelist_rw[] = {
|
|
|
|
CONFIG_BDRV_RW_WHITELIST
|
|
|
|
};
|
|
|
|
static const char *whitelist_ro[] = {
|
|
|
|
CONFIG_BDRV_RO_WHITELIST
|
2009-10-27 18:41:44 +01:00
|
|
|
};
|
|
|
|
const char **p;
|
|
|
|
|
2013-05-29 13:35:40 +02:00
|
|
|
if (!whitelist_rw[0] && !whitelist_ro[0]) {
|
2009-10-27 18:41:44 +01:00
|
|
|
return 1; /* no whitelist, anything goes */
|
2013-05-29 13:35:40 +02:00
|
|
|
}
|
2009-10-27 18:41:44 +01:00
|
|
|
|
2013-05-29 13:35:40 +02:00
|
|
|
for (p = whitelist_rw; *p; p++) {
|
2009-10-27 18:41:44 +01:00
|
|
|
if (!strcmp(drv->format_name, *p)) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2013-05-29 13:35:40 +02:00
|
|
|
if (read_only) {
|
|
|
|
for (p = whitelist_ro; *p; p++) {
|
|
|
|
if (!strcmp(drv->format_name, *p)) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-10-27 18:41:44 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-03-21 15:11:48 +01:00
|
|
|
bool bdrv_uses_whitelist(void)
|
|
|
|
{
|
|
|
|
return use_bdrv_whitelist;
|
|
|
|
}
|
|
|
|
|
2012-05-07 10:50:42 +02:00
|
|
|
typedef struct CreateCo {
|
|
|
|
BlockDriver *drv;
|
|
|
|
char *filename;
|
2014-06-05 11:20:51 +02:00
|
|
|
QemuOpts *opts;
|
2012-05-07 10:50:42 +02:00
|
|
|
int ret;
|
2013-09-06 17:14:26 +02:00
|
|
|
Error *err;
|
2012-05-07 10:50:42 +02:00
|
|
|
} CreateCo;
|
|
|
|
|
|
|
|
static void coroutine_fn bdrv_create_co_entry(void *opaque)
|
|
|
|
{
|
2013-09-06 17:14:26 +02:00
|
|
|
Error *local_err = NULL;
|
|
|
|
int ret;
|
|
|
|
|
2012-05-07 10:50:42 +02:00
|
|
|
CreateCo *cco = opaque;
|
|
|
|
assert(cco->drv);
|
|
|
|
|
2018-01-18 13:43:45 +01:00
|
|
|
ret = cco->drv->bdrv_co_create_opts(cco->filename, cco->opts, &local_err);
|
2016-06-13 23:57:56 +02:00
|
|
|
error_propagate(&cco->err, local_err);
|
2013-09-06 17:14:26 +02:00
|
|
|
cco->ret = ret;
|
2012-05-07 10:50:42 +02:00
|
|
|
}
|
|
|
|
|
2009-05-18 16:42:10 +02:00
|
|
|
int bdrv_create(BlockDriver *drv, const char* filename,
|
2014-06-05 11:20:51 +02:00
|
|
|
QemuOpts *opts, Error **errp)
|
2004-08-01 23:59:26 +02:00
|
|
|
{
|
2012-05-07 10:50:42 +02:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
Coroutine *co;
|
|
|
|
CreateCo cco = {
|
|
|
|
.drv = drv,
|
|
|
|
.filename = g_strdup(filename),
|
2014-06-05 11:20:51 +02:00
|
|
|
.opts = opts,
|
2012-05-07 10:50:42 +02:00
|
|
|
.ret = NOT_DONE,
|
2013-09-06 17:14:26 +02:00
|
|
|
.err = NULL,
|
2012-05-07 10:50:42 +02:00
|
|
|
};
|
|
|
|
|
2018-01-18 13:43:45 +01:00
|
|
|
if (!drv->bdrv_co_create_opts) {
|
2013-09-06 17:14:26 +02:00
|
|
|
error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
|
2012-10-17 21:45:25 +02:00
|
|
|
ret = -ENOTSUP;
|
|
|
|
goto out;
|
2012-05-07 10:50:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
/* Fast-path if already in coroutine context */
|
|
|
|
bdrv_create_co_entry(&cco);
|
|
|
|
} else {
|
coroutine: move entry argument to qemu_coroutine_create
In practice the entry argument is always known at creation time, and
it is confusing that sometimes qemu_coroutine_enter is used with a
non-NULL argument to re-enter a coroutine (this happens in
block/sheepdog.c and tests/test-coroutine.c). So pass the opaque value
at creation time, for consistency with e.g. aio_bh_new.
Mostly done with the following semantic patch:
@ entry1 @
expression entry, arg, co;
@@
- co = qemu_coroutine_create(entry);
+ co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry2 @
expression entry, arg;
identifier co;
@@
- Coroutine *co = qemu_coroutine_create(entry);
+ Coroutine *co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry3 @
expression entry, arg;
@@
- qemu_coroutine_enter(qemu_coroutine_create(entry), arg);
+ qemu_coroutine_enter(qemu_coroutine_create(entry, arg));
@ reentry @
expression co;
@@
- qemu_coroutine_enter(co, NULL);
+ qemu_coroutine_enter(co);
except for the aforementioned few places where the semantic patch
stumbled (as expected) and for test_co_queue, which would otherwise
produce an uninitialized variable warning.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-07-04 19:10:01 +02:00
|
|
|
co = qemu_coroutine_create(bdrv_create_co_entry, &cco);
|
|
|
|
qemu_coroutine_enter(co);
|
2012-05-07 10:50:42 +02:00
|
|
|
while (cco.ret == NOT_DONE) {
|
2014-07-07 15:18:01 +02:00
|
|
|
aio_poll(qemu_get_aio_context(), true);
|
2012-05-07 10:50:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = cco.ret;
|
2013-09-06 17:14:26 +02:00
|
|
|
if (ret < 0) {
|
2014-01-30 15:07:28 +01:00
|
|
|
if (cco.err) {
|
2013-09-06 17:14:26 +02:00
|
|
|
error_propagate(errp, cco.err);
|
|
|
|
} else {
|
|
|
|
error_setg_errno(errp, -ret, "Could not create image");
|
|
|
|
}
|
|
|
|
}
|
2009-05-18 16:42:10 +02:00
|
|
|
|
2012-10-17 21:45:25 +02:00
|
|
|
out:
|
|
|
|
g_free(cco.filename);
|
2012-05-07 10:50:42 +02:00
|
|
|
return ret;
|
2004-08-01 23:59:26 +02:00
|
|
|
}
|
|
|
|
|
2014-06-05 11:21:11 +02:00
|
|
|
int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
|
2010-04-07 22:30:24 +02:00
|
|
|
{
|
|
|
|
BlockDriver *drv;
|
2013-09-06 17:14:26 +02:00
|
|
|
Error *local_err = NULL;
|
|
|
|
int ret;
|
2010-04-07 22:30:24 +02:00
|
|
|
|
2015-02-05 19:58:12 +01:00
|
|
|
drv = bdrv_find_protocol(filename, true, errp);
|
2010-04-07 22:30:24 +02:00
|
|
|
if (drv == NULL) {
|
2010-11-30 16:14:14 +01:00
|
|
|
return -ENOENT;
|
2010-04-07 22:30:24 +02:00
|
|
|
}
|
|
|
|
|
2014-06-05 11:21:11 +02:00
|
|
|
ret = bdrv_create(drv, filename, opts, &local_err);
|
2016-06-13 23:57:56 +02:00
|
|
|
error_propagate(errp, local_err);
|
2013-09-06 17:14:26 +02:00
|
|
|
return ret;
|
2010-04-07 22:30:24 +02:00
|
|
|
}
|
|
|
|
|
2015-02-16 12:47:54 +01:00
|
|
|
/**
|
|
|
|
* Try to get @bs's logical and physical block size.
|
|
|
|
* On success, store them in @bsz struct and return 0.
|
|
|
|
* On failure return -errno.
|
|
|
|
* @bs must not be empty.
|
|
|
|
*/
|
|
|
|
int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
|
|
|
|
if (drv && drv->bdrv_probe_blocksizes) {
|
|
|
|
return drv->bdrv_probe_blocksizes(bs, bsz);
|
2017-07-13 17:30:25 +02:00
|
|
|
} else if (drv && drv->is_filter && bs->file) {
|
|
|
|
return bdrv_probe_blocksizes(bs->file->bs, bsz);
|
2015-02-16 12:47:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Try to get @bs's geometry (cyls, heads, sectors).
|
|
|
|
* On success, store them in @geo struct and return 0.
|
|
|
|
* On failure return -errno.
|
|
|
|
* @bs must not be empty.
|
|
|
|
*/
|
|
|
|
int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
|
|
|
|
if (drv && drv->bdrv_probe_geometry) {
|
|
|
|
return drv->bdrv_probe_geometry(bs, geo);
|
2017-07-13 17:30:25 +02:00
|
|
|
} else if (drv && drv->is_filter && bs->file) {
|
|
|
|
return bdrv_probe_geometry(bs->file->bs, geo);
|
2015-02-16 12:47:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
2012-05-28 09:27:54 +02:00
|
|
|
/*
|
|
|
|
* Create a uniquely-named empty temporary file.
|
|
|
|
* Return 0 upon success, otherwise a negative errno value.
|
|
|
|
*/
|
|
|
|
int get_tmp_filename(char *filename, int size)
|
2004-08-03 23:14:23 +02:00
|
|
|
{
|
2012-05-28 09:27:54 +02:00
|
|
|
#ifdef _WIN32
|
2007-01-07 18:27:07 +01:00
|
|
|
char temp_dir[MAX_PATH];
|
2012-05-28 09:27:54 +02:00
|
|
|
/* GetTempFileName requires that its output buffer (4th param)
|
|
|
|
have length MAX_PATH or greater. */
|
|
|
|
assert(size >= MAX_PATH);
|
|
|
|
return (GetTempPath(MAX_PATH, temp_dir)
|
|
|
|
&& GetTempFileName(temp_dir, "qem", 0, filename)
|
|
|
|
? 0 : -GetLastError());
|
2004-08-03 23:14:23 +02:00
|
|
|
#else
|
2004-04-01 01:37:16 +02:00
|
|
|
int fd;
|
2008-09-14 08:45:34 +02:00
|
|
|
const char *tmpdir;
|
2008-03-10 01:05:34 +01:00
|
|
|
tmpdir = getenv("TMPDIR");
|
2014-02-26 10:42:37 +01:00
|
|
|
if (!tmpdir) {
|
|
|
|
tmpdir = "/var/tmp";
|
|
|
|
}
|
2012-05-28 09:27:54 +02:00
|
|
|
if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
|
|
|
|
return -EOVERFLOW;
|
|
|
|
}
|
2004-08-01 23:59:26 +02:00
|
|
|
fd = mkstemp(filename);
|
2012-09-05 15:26:22 +02:00
|
|
|
if (fd < 0) {
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
if (close(fd) != 0) {
|
|
|
|
unlink(filename);
|
2012-05-28 09:27:54 +02:00
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
return 0;
|
2004-08-03 23:14:23 +02:00
|
|
|
#endif
|
2012-05-28 09:27:54 +02:00
|
|
|
}
|
2003-06-30 12:03:06 +02:00
|
|
|
|
2010-04-07 22:30:24 +02:00
|
|
|
/*
|
|
|
|
* Detect host devices. By convention, /dev/cdrom[N] is always
|
|
|
|
* recognized as a host CDROM.
|
|
|
|
*/
|
|
|
|
static BlockDriver *find_hdev_driver(const char *filename)
|
|
|
|
{
|
|
|
|
int score_max = 0, score;
|
|
|
|
BlockDriver *drv = NULL, *d;
|
|
|
|
|
|
|
|
QLIST_FOREACH(d, &bdrv_drivers, list) {
|
|
|
|
if (d->bdrv_probe_device) {
|
|
|
|
score = d->bdrv_probe_device(filename);
|
|
|
|
if (score > score_max) {
|
|
|
|
score_max = score;
|
|
|
|
drv = d;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return drv;
|
|
|
|
}
|
|
|
|
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
static BlockDriver *bdrv_do_find_protocol(const char *protocol)
|
|
|
|
{
|
|
|
|
BlockDriver *drv1;
|
|
|
|
|
|
|
|
QLIST_FOREACH(drv1, &bdrv_drivers, list) {
|
|
|
|
if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
|
|
|
|
return drv1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-07-10 15:47:39 +02:00
|
|
|
BlockDriver *bdrv_find_protocol(const char *filename,
|
2015-02-05 19:58:12 +01:00
|
|
|
bool allow_protocol_prefix,
|
|
|
|
Error **errp)
|
2006-08-01 18:21:11 +02:00
|
|
|
{
|
|
|
|
BlockDriver *drv1;
|
|
|
|
char protocol[128];
|
2009-07-02 15:12:26 +02:00
|
|
|
int len;
|
2006-08-01 18:21:11 +02:00
|
|
|
const char *p;
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
int i;
|
2006-08-19 13:45:59 +02:00
|
|
|
|
2010-04-14 14:17:38 +02:00
|
|
|
/* TODO Drivers without bdrv_file_open must be specified explicitly */
|
|
|
|
|
2010-06-23 12:25:17 +02:00
|
|
|
/*
|
|
|
|
* XXX(hch): we really should not let host device detection
|
|
|
|
* override an explicit protocol specification, but moving this
|
|
|
|
* later breaks access to device names with colons in them.
|
|
|
|
* Thanks to the brain-dead persistent naming schemes on udev-
|
|
|
|
* based Linux systems those actually are quite common.
|
|
|
|
*/
|
|
|
|
drv1 = find_hdev_driver(filename);
|
|
|
|
if (drv1) {
|
|
|
|
return drv1;
|
|
|
|
}
|
|
|
|
|
2013-07-10 15:47:39 +02:00
|
|
|
if (!path_has_protocol(filename) || !allow_protocol_prefix) {
|
2014-12-02 18:32:42 +01:00
|
|
|
return &bdrv_file;
|
2010-04-07 22:30:24 +02:00
|
|
|
}
|
2013-07-10 15:47:39 +02:00
|
|
|
|
2010-12-09 12:53:00 +01:00
|
|
|
p = strchr(filename, ':');
|
|
|
|
assert(p != NULL);
|
2009-07-02 15:12:26 +02:00
|
|
|
len = p - filename;
|
|
|
|
if (len > sizeof(protocol) - 1)
|
|
|
|
len = sizeof(protocol) - 1;
|
|
|
|
memcpy(protocol, filename, len);
|
|
|
|
protocol[len] = '\0';
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
|
|
|
|
drv1 = bdrv_do_find_protocol(protocol);
|
|
|
|
if (drv1) {
|
|
|
|
return drv1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
|
|
|
|
if (block_driver_modules[i].protocol_name &&
|
|
|
|
!strcmp(block_driver_modules[i].protocol_name, protocol)) {
|
|
|
|
block_module_load_one(block_driver_modules[i].library_name);
|
|
|
|
break;
|
2010-04-13 11:29:33 +02:00
|
|
|
}
|
2006-08-01 18:21:11 +02:00
|
|
|
}
|
2015-02-05 19:58:12 +01:00
|
|
|
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
drv1 = bdrv_do_find_protocol(protocol);
|
|
|
|
if (!drv1) {
|
|
|
|
error_setg(errp, "Unknown protocol '%s'", protocol);
|
|
|
|
}
|
|
|
|
return drv1;
|
2006-08-01 18:21:11 +02:00
|
|
|
}
|
|
|
|
|
2014-11-20 16:27:10 +01:00
|
|
|
/*
|
|
|
|
* Guess image format by probing its contents.
|
|
|
|
* This is not a good idea when your image is raw (CVE-2008-2004), but
|
|
|
|
* we do it anyway for backward compatibility.
|
|
|
|
*
|
|
|
|
* @buf contains the image's first @buf_size bytes.
|
2014-11-20 16:27:11 +01:00
|
|
|
* @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
|
|
|
|
* but can be smaller if the image file is smaller)
|
2014-11-20 16:27:10 +01:00
|
|
|
* @filename is its filename.
|
|
|
|
*
|
|
|
|
* For all block drivers, call the bdrv_probe() method to get its
|
|
|
|
* probing score.
|
|
|
|
* Return the first block driver with the highest probing score.
|
|
|
|
*/
|
raw: Prohibit dangerous writes for probed images
If the user neglects to specify the image format, QEMU probes the
image to guess it automatically, for convenience.
Relying on format probing is insecure for raw images (CVE-2008-2004).
If the guest writes a suitable header to the device, the next probe
will recognize a format chosen by the guest. A malicious guest can
abuse this to gain access to host files, e.g. by crafting a QCOW2
header with backing file /etc/shadow.
Commit 1e72d3b (April 2008) provided -drive parameter format to let
users disable probing. Commit f965509 (March 2009) extended QCOW2 to
optionally store the backing file format, to let users disable backing
file probing. QED has had a flag to suppress probing since the
beginning (2010), set whenever a raw backing file is assigned.
All of these additions that allow to avoid format probing have to be
specified explicitly. The default still allows the attack.
In order to fix this, commit 79368c8 (July 2010) put probed raw images
in a restricted mode, in which they wouldn't be able to overwrite the
first few bytes of the image so that they would identify as a different
image. If a write to the first sector would write one of the signatures
of another driver, qemu would instead zero out the first four bytes.
This patch was later reverted in commit 8b33d9e (September 2010) because
it didn't get the handling of unaligned qiov members right.
Today's block layer that is based on coroutines and has qiov utility
functions makes it much easier to get this functionality right, so this
patch implements it.
The other differences of this patch to the old one are that it doesn't
silently write something different than the guest requested by zeroing
out some bytes (it fails the request instead) and that it doesn't
maintain a list of signatures in the raw driver (it calls the usual
probe function instead).
Note that this change doesn't introduce new breakage for false positive
cases where the guest legitimately writes data into the first sector
that matches the signatures of an image format (e.g. for nested virt):
These cases were broken before, only the failure mode changes from
corruption after the next restart (when the wrong format is probed) to
failing the problematic write request.
Also note that like in the original patch, the restrictions only apply
if the image format has been guessed by probing. Explicitly specifying a
format allows guests to write anything they like.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1416497234-29880-8-git-send-email-kwolf@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-11-20 16:27:12 +01:00
|
|
|
BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
|
|
|
|
const char *filename)
|
2014-11-20 16:27:10 +01:00
|
|
|
{
|
|
|
|
int score_max = 0, score;
|
|
|
|
BlockDriver *drv = NULL, *d;
|
|
|
|
|
|
|
|
QLIST_FOREACH(d, &bdrv_drivers, list) {
|
|
|
|
if (d->bdrv_probe) {
|
|
|
|
score = d->bdrv_probe(buf, buf_size, filename);
|
|
|
|
if (score > score_max) {
|
|
|
|
score_max = score;
|
|
|
|
drv = d;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return drv;
|
|
|
|
}
|
|
|
|
|
2017-02-17 18:39:24 +01:00
|
|
|
static int find_image_format(BlockBackend *file, const char *filename,
|
2013-09-05 14:45:29 +02:00
|
|
|
BlockDriver **pdrv, Error **errp)
|
2009-06-15 13:55:19 +02:00
|
|
|
{
|
2014-11-20 16:27:10 +01:00
|
|
|
BlockDriver *drv;
|
2014-11-20 16:27:11 +01:00
|
|
|
uint8_t buf[BLOCK_PROBE_BUF_SIZE];
|
2012-11-12 17:35:27 +01:00
|
|
|
int ret = 0;
|
2010-05-17 18:45:57 +02:00
|
|
|
|
2010-06-01 18:37:31 +02:00
|
|
|
/* Return the raw BlockDriver * to scsi-generic devices or empty drives */
|
2017-02-17 18:39:24 +01:00
|
|
|
if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
|
2014-12-02 18:32:42 +01:00
|
|
|
*pdrv = &bdrv_raw;
|
2010-07-21 21:51:51 +02:00
|
|
|
return ret;
|
2010-05-27 17:56:28 +02:00
|
|
|
}
|
2010-05-17 18:45:57 +02:00
|
|
|
|
2017-02-17 18:39:24 +01:00
|
|
|
ret = blk_pread(file, 0, buf, sizeof(buf));
|
2006-08-01 18:21:11 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 14:45:29 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not read image for determining its "
|
|
|
|
"format");
|
2010-07-21 21:51:51 +02:00
|
|
|
*pdrv = NULL;
|
|
|
|
return ret;
|
2006-08-01 18:21:11 +02:00
|
|
|
}
|
|
|
|
|
2014-11-20 16:27:10 +01:00
|
|
|
drv = bdrv_probe_all(buf, ret, filename);
|
2010-07-21 21:51:51 +02:00
|
|
|
if (!drv) {
|
2013-09-05 14:45:29 +02:00
|
|
|
error_setg(errp, "Could not determine image format: No compatible "
|
|
|
|
"driver found");
|
2010-07-21 21:51:51 +02:00
|
|
|
ret = -ENOENT;
|
|
|
|
}
|
|
|
|
*pdrv = drv;
|
|
|
|
return ret;
|
2004-08-01 23:59:26 +02:00
|
|
|
}
|
|
|
|
|
2010-04-19 17:56:41 +02:00
|
|
|
/**
|
|
|
|
* Set the current 'total_sectors' value
|
2014-06-26 13:23:17 +02:00
|
|
|
* Return 0 on success, -errno on error.
|
2010-04-19 17:56:41 +02:00
|
|
|
*/
|
2018-06-26 13:55:20 +02:00
|
|
|
int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
|
2010-04-19 17:56:41 +02:00
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
|
2017-11-10 21:31:09 +01:00
|
|
|
if (!drv) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
|
2010-05-17 18:46:04 +02:00
|
|
|
/* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
|
2015-06-23 12:44:56 +02:00
|
|
|
if (bdrv_is_sg(bs))
|
2010-05-17 18:46:04 +02:00
|
|
|
return 0;
|
|
|
|
|
2010-04-19 17:56:41 +02:00
|
|
|
/* query actual device if possible, otherwise just trust the hint */
|
|
|
|
if (drv->bdrv_getlength) {
|
|
|
|
int64_t length = drv->bdrv_getlength(bs);
|
|
|
|
if (length < 0) {
|
|
|
|
return length;
|
|
|
|
}
|
2013-11-06 12:48:06 +01:00
|
|
|
hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
|
2010-04-19 17:56:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bs->total_sectors = hint;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-16 16:43:27 +01:00
|
|
|
/**
|
|
|
|
* Combines a QDict of new block driver @options with any missing options taken
|
|
|
|
* from @old_options, so that leaving out an option defaults to its old value.
|
|
|
|
*/
|
|
|
|
static void bdrv_join_options(BlockDriverState *bs, QDict *options,
|
|
|
|
QDict *old_options)
|
|
|
|
{
|
|
|
|
if (bs->drv && bs->drv->bdrv_join_options) {
|
|
|
|
bs->drv->bdrv_join_options(options, old_options);
|
|
|
|
} else {
|
|
|
|
qdict_join(options, old_options, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-06 11:37:09 +02:00
|
|
|
static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
|
|
|
|
int open_flags,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
char *value = qemu_opt_get_del(opts, "detect-zeroes");
|
|
|
|
BlockdevDetectZeroesOptions detect_zeroes =
|
|
|
|
qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup, value,
|
|
|
|
BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, &local_err);
|
|
|
|
g_free(value);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return detect_zeroes;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
|
|
|
|
!(open_flags & BDRV_O_UNMAP))
|
|
|
|
{
|
|
|
|
error_setg(errp, "setting detect-zeroes to unmap is not allowed "
|
|
|
|
"without setting discard operation to unmap");
|
|
|
|
}
|
|
|
|
|
|
|
|
return detect_zeroes;
|
|
|
|
}
|
|
|
|
|
2013-02-08 14:06:11 +01:00
|
|
|
/**
|
|
|
|
* Set open flags for a given discard mode
|
|
|
|
*
|
|
|
|
* Return 0 on success, -1 if the discard mode was invalid.
|
|
|
|
*/
|
|
|
|
int bdrv_parse_discard_flags(const char *mode, int *flags)
|
|
|
|
{
|
|
|
|
*flags &= ~BDRV_O_UNMAP;
|
|
|
|
|
|
|
|
if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
|
|
|
|
/* do nothing */
|
|
|
|
} else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
|
|
|
|
*flags |= BDRV_O_UNMAP;
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-04 13:26:51 +02:00
|
|
|
/**
|
|
|
|
* Set open flags for a given cache mode
|
|
|
|
*
|
|
|
|
* Return 0 on success, -1 if the cache mode was invalid.
|
|
|
|
*/
|
2016-03-18 15:36:58 +01:00
|
|
|
int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
|
2011-08-04 13:26:51 +02:00
|
|
|
{
|
|
|
|
*flags &= ~BDRV_O_CACHE_MASK;
|
|
|
|
|
|
|
|
if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
|
2016-03-18 15:36:58 +01:00
|
|
|
*writethrough = false;
|
|
|
|
*flags |= BDRV_O_NOCACHE;
|
2011-08-04 13:26:52 +02:00
|
|
|
} else if (!strcmp(mode, "directsync")) {
|
2016-03-18 15:36:58 +01:00
|
|
|
*writethrough = true;
|
2011-08-04 13:26:52 +02:00
|
|
|
*flags |= BDRV_O_NOCACHE;
|
2011-08-04 13:26:51 +02:00
|
|
|
} else if (!strcmp(mode, "writeback")) {
|
2016-03-18 15:36:58 +01:00
|
|
|
*writethrough = false;
|
2011-08-04 13:26:51 +02:00
|
|
|
} else if (!strcmp(mode, "unsafe")) {
|
2016-03-18 15:36:58 +01:00
|
|
|
*writethrough = false;
|
2011-08-04 13:26:51 +02:00
|
|
|
*flags |= BDRV_O_NO_FLUSH;
|
|
|
|
} else if (!strcmp(mode, "writethrough")) {
|
2016-03-18 15:36:58 +01:00
|
|
|
*writethrough = true;
|
2011-08-04 13:26:51 +02:00
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-17 15:56:16 +01:00
|
|
|
static char *bdrv_child_get_parent_desc(BdrvChild *c)
|
|
|
|
{
|
|
|
|
BlockDriverState *parent = c->opaque;
|
|
|
|
return g_strdup(bdrv_get_device_or_node_name(parent));
|
|
|
|
}
|
|
|
|
|
2016-05-23 18:46:59 +02:00
|
|
|
static void bdrv_child_cb_drained_begin(BdrvChild *child)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = child->opaque;
|
2018-05-29 17:17:45 +02:00
|
|
|
bdrv_do_drained_begin_quiesce(bs, NULL, false);
|
2016-05-23 18:46:59 +02:00
|
|
|
}
|
|
|
|
|
2018-03-22 14:11:20 +01:00
|
|
|
static bool bdrv_child_cb_drained_poll(BdrvChild *child)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = child->opaque;
|
2018-05-29 17:17:45 +02:00
|
|
|
return bdrv_drain_poll(bs, false, NULL, false);
|
2018-03-22 14:11:20 +01:00
|
|
|
}
|
|
|
|
|
2016-05-23 18:46:59 +02:00
|
|
|
static void bdrv_child_cb_drained_end(BdrvChild *child)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = child->opaque;
|
|
|
|
bdrv_drained_end(bs);
|
|
|
|
}
|
|
|
|
|
2017-12-18 16:05:48 +01:00
|
|
|
static void bdrv_child_cb_attach(BdrvChild *child)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = child->opaque;
|
|
|
|
bdrv_apply_subtree_drain(child, bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bdrv_child_cb_detach(BdrvChild *child)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = child->opaque;
|
|
|
|
bdrv_unapply_subtree_drain(child, bs);
|
|
|
|
}
|
|
|
|
|
2017-05-04 18:52:39 +02:00
|
|
|
static int bdrv_child_cb_inactivate(BdrvChild *child)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = child->opaque;
|
|
|
|
assert(bs->open_flags & BDRV_O_INACTIVE);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-06 12:11:42 +02:00
|
|
|
/*
|
2016-03-07 13:02:15 +01:00
|
|
|
* Returns the options and flags that a temporary snapshot should get, based on
|
|
|
|
* the originally requested flags (the originally requested image will have
|
|
|
|
* flags like a backing file)
|
2014-05-06 12:11:42 +02:00
|
|
|
*/
|
2016-03-07 13:02:15 +01:00
|
|
|
static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
|
|
|
|
int parent_flags, QDict *parent_options)
|
2014-05-06 12:11:42 +02:00
|
|
|
{
|
2016-03-07 13:02:15 +01:00
|
|
|
*child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
|
|
|
|
|
|
|
|
/* For temporary files, unconditional cache=unsafe is fine */
|
|
|
|
qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
|
|
|
|
qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
|
2016-06-16 12:59:30 +02:00
|
|
|
|
2016-09-15 16:53:02 +02:00
|
|
|
/* Copy the read-only option from the parent */
|
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
|
|
|
|
|
2016-06-16 12:59:30 +02:00
|
|
|
/* aio=native doesn't work for cache.direct=off, so disable it for the
|
|
|
|
* temporary snapshot */
|
|
|
|
*child_flags &= ~BDRV_O_NATIVE_AIO;
|
2014-05-06 12:11:42 +02:00
|
|
|
}
|
|
|
|
|
2014-04-11 21:29:52 +02:00
|
|
|
/*
|
2015-04-29 17:29:39 +02:00
|
|
|
* Returns the options and flags that bs->file should get if a protocol driver
|
|
|
|
* is expected, based on the given options and flags for the parent BDS
|
2014-04-11 21:29:52 +02:00
|
|
|
*/
|
2015-04-29 17:29:39 +02:00
|
|
|
static void bdrv_inherited_options(int *child_flags, QDict *child_options,
|
|
|
|
int parent_flags, QDict *parent_options)
|
2014-04-11 21:29:52 +02:00
|
|
|
{
|
2015-04-29 17:29:39 +02:00
|
|
|
int flags = parent_flags;
|
|
|
|
|
2014-04-11 21:29:52 +02:00
|
|
|
/* Enable protocol handling, disable format probing for bs->file */
|
|
|
|
flags |= BDRV_O_PROTOCOL;
|
|
|
|
|
2015-05-08 17:49:53 +02:00
|
|
|
/* If the cache mode isn't explicitly set, inherit direct and no-flush from
|
|
|
|
* the parent. */
|
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
|
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
|
2017-05-02 18:35:37 +02:00
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
|
2015-05-08 17:49:53 +02:00
|
|
|
|
2016-09-15 16:53:02 +02:00
|
|
|
/* Inherit the read-only option from the parent if it's not set */
|
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
|
block: Add auto-read-only option
If a management application builds the block graph node by node, the
protocol layer doesn't inherit its read-only option from the format
layer any more, so it must be set explicitly.
Backing files should work on read-only storage, but at the same time, a
block job like commit should be able to reopen them read-write if they
are on read-write storage. However, without option inheritance, reopen
only changes the read-only option for the root node (typically the
format layer), but not the protocol layer, so reopening fails (the
format layer wants to get write permissions, but the protocol layer is
still read-only).
A simple workaround for the problem in the management tool would be to
open the protocol layer always read-write and to make only the format
layer read-only for backing files. However, sometimes the file is
actually stored on read-only storage and we don't know whether the image
can be opened read-write (for example, for NBD it depends on the server
we're trying to connect to). This adds an option that makes QEMU try to
open the image read-write, but allows it to degrade to a read-only mode
without returning an error.
The documentation for this option is consciously phrased in a way that
allows QEMU to switch to a better model eventually: Instead of trying
when the image is first opened, making the read-only flag dynamic and
changing it automatically whenever the first BLK_PERM_WRITE user is
attached or the last one is detached would be much more useful
behaviour.
Unfortunately, this more useful behaviour is also a lot harder to
implement, and libvirt needs a solution now before it can switch to
-blockdev, so let's start with this easier approach for now.
Instead of adding a new auto-read-only option, turning the existing
read-only into an enum (with a bool alternate for compatibility) was
considered, but it complicated the implementation to the point that it
didn't seem to be worth it.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2018-10-05 18:57:40 +02:00
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_AUTO_READ_ONLY);
|
2016-09-15 16:53:02 +02:00
|
|
|
|
2014-04-11 21:29:52 +02:00
|
|
|
/* Our block drivers take care to send flushes and respect unmap policy,
|
2015-05-08 17:49:53 +02:00
|
|
|
* so we can default to enable both on lower layers regardless of the
|
|
|
|
* corresponding parent options. */
|
2016-09-12 18:03:18 +02:00
|
|
|
qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
|
2014-04-11 21:29:52 +02:00
|
|
|
|
|
|
|
/* Clear flags that only apply to the top layer */
|
2016-03-21 15:11:42 +01:00
|
|
|
flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
|
|
|
|
BDRV_O_NO_IO);
|
2014-04-11 21:29:52 +02:00
|
|
|
|
2015-04-29 17:29:39 +02:00
|
|
|
*child_flags = flags;
|
2014-04-11 21:29:52 +02:00
|
|
|
}
|
|
|
|
|
2015-04-08 13:43:47 +02:00
|
|
|
const BdrvChildRole child_file = {
|
2018-05-29 17:17:45 +02:00
|
|
|
.parent_is_bds = true,
|
2017-01-17 15:56:16 +01:00
|
|
|
.get_parent_desc = bdrv_child_get_parent_desc,
|
2015-04-29 17:29:39 +02:00
|
|
|
.inherit_options = bdrv_inherited_options,
|
2016-05-23 18:46:59 +02:00
|
|
|
.drained_begin = bdrv_child_cb_drained_begin,
|
2018-03-22 14:11:20 +01:00
|
|
|
.drained_poll = bdrv_child_cb_drained_poll,
|
2016-05-23 18:46:59 +02:00
|
|
|
.drained_end = bdrv_child_cb_drained_end,
|
2017-12-18 16:05:48 +01:00
|
|
|
.attach = bdrv_child_cb_attach,
|
|
|
|
.detach = bdrv_child_cb_detach,
|
2017-05-04 18:52:39 +02:00
|
|
|
.inactivate = bdrv_child_cb_inactivate,
|
2015-04-08 13:43:47 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2015-04-29 17:29:39 +02:00
|
|
|
* Returns the options and flags that bs->file should get if the use of formats
|
|
|
|
* (and not only protocols) is permitted for it, based on the given options and
|
|
|
|
* flags for the parent BDS
|
2015-04-08 13:43:47 +02:00
|
|
|
*/
|
2015-04-29 17:29:39 +02:00
|
|
|
static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
|
|
|
|
int parent_flags, QDict *parent_options)
|
2015-04-08 13:43:47 +02:00
|
|
|
{
|
2015-04-29 17:29:39 +02:00
|
|
|
child_file.inherit_options(child_flags, child_options,
|
|
|
|
parent_flags, parent_options);
|
|
|
|
|
2016-03-21 15:11:42 +01:00
|
|
|
*child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
|
2015-04-08 13:43:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const BdrvChildRole child_format = {
|
2018-05-29 17:17:45 +02:00
|
|
|
.parent_is_bds = true,
|
2017-01-17 15:56:16 +01:00
|
|
|
.get_parent_desc = bdrv_child_get_parent_desc,
|
2015-04-29 17:29:39 +02:00
|
|
|
.inherit_options = bdrv_inherited_fmt_options,
|
2016-05-23 18:46:59 +02:00
|
|
|
.drained_begin = bdrv_child_cb_drained_begin,
|
2018-03-22 14:11:20 +01:00
|
|
|
.drained_poll = bdrv_child_cb_drained_poll,
|
2016-05-23 18:46:59 +02:00
|
|
|
.drained_end = bdrv_child_cb_drained_end,
|
2017-12-18 16:05:48 +01:00
|
|
|
.attach = bdrv_child_cb_attach,
|
|
|
|
.detach = bdrv_child_cb_detach,
|
2017-05-04 18:52:39 +02:00
|
|
|
.inactivate = bdrv_child_cb_inactivate,
|
2015-04-08 13:43:47 +02:00
|
|
|
};
|
|
|
|
|
2017-02-08 11:28:52 +01:00
|
|
|
static void bdrv_backing_attach(BdrvChild *c)
|
|
|
|
{
|
|
|
|
BlockDriverState *parent = c->opaque;
|
|
|
|
BlockDriverState *backing_hd = c->bs;
|
|
|
|
|
|
|
|
assert(!parent->backing_blocker);
|
|
|
|
error_setg(&parent->backing_blocker,
|
|
|
|
"node is used as backing hd of '%s'",
|
|
|
|
bdrv_get_device_or_node_name(parent));
|
|
|
|
|
|
|
|
parent->open_flags &= ~BDRV_O_NO_BACKING;
|
|
|
|
pstrcpy(parent->backing_file, sizeof(parent->backing_file),
|
|
|
|
backing_hd->filename);
|
|
|
|
pstrcpy(parent->backing_format, sizeof(parent->backing_format),
|
|
|
|
backing_hd->drv ? backing_hd->drv->format_name : "");
|
|
|
|
|
|
|
|
bdrv_op_block_all(backing_hd, parent->backing_blocker);
|
|
|
|
/* Otherwise we won't be able to commit or stream */
|
|
|
|
bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
|
|
|
|
parent->backing_blocker);
|
|
|
|
bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
|
|
|
|
parent->backing_blocker);
|
|
|
|
/*
|
|
|
|
* We do backup in 3 ways:
|
|
|
|
* 1. drive backup
|
|
|
|
* The target bs is new opened, and the source is top BDS
|
|
|
|
* 2. blockdev backup
|
|
|
|
* Both the source and the target are top BDSes.
|
|
|
|
* 3. internal backup(used for block replication)
|
|
|
|
* Both the source and the target are backing file
|
|
|
|
*
|
|
|
|
* In case 1 and 2, neither the source nor the target is the backing file.
|
|
|
|
* In case 3, we will block the top BDS, so there is only one block job
|
|
|
|
* for the top BDS and its backing chain.
|
|
|
|
*/
|
|
|
|
bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
|
|
|
|
parent->backing_blocker);
|
|
|
|
bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
|
|
|
|
parent->backing_blocker);
|
2017-12-18 16:05:48 +01:00
|
|
|
|
|
|
|
bdrv_child_cb_attach(c);
|
2017-02-08 11:28:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void bdrv_backing_detach(BdrvChild *c)
|
|
|
|
{
|
|
|
|
BlockDriverState *parent = c->opaque;
|
|
|
|
|
|
|
|
assert(parent->backing_blocker);
|
|
|
|
bdrv_op_unblock_all(c->bs, parent->backing_blocker);
|
|
|
|
error_free(parent->backing_blocker);
|
|
|
|
parent->backing_blocker = NULL;
|
2017-12-18 16:05:48 +01:00
|
|
|
|
|
|
|
bdrv_child_cb_detach(c);
|
2017-02-08 11:28:52 +01:00
|
|
|
}
|
|
|
|
|
2014-04-25 13:27:34 +02:00
|
|
|
/*
|
2015-04-29 17:29:39 +02:00
|
|
|
* Returns the options and flags that bs->backing should get, based on the
|
|
|
|
* given options and flags for the parent BDS
|
2014-04-25 13:27:34 +02:00
|
|
|
*/
|
2015-04-29 17:29:39 +02:00
|
|
|
static void bdrv_backing_options(int *child_flags, QDict *child_options,
|
|
|
|
int parent_flags, QDict *parent_options)
|
2014-04-25 13:27:34 +02:00
|
|
|
{
|
2015-04-29 17:29:39 +02:00
|
|
|
int flags = parent_flags;
|
|
|
|
|
2016-03-04 14:52:32 +01:00
|
|
|
/* The cache mode is inherited unmodified for backing files; except WCE,
|
|
|
|
* which is only applied on the top level (BlockBackend) */
|
2015-05-08 17:49:53 +02:00
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
|
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
|
2017-05-02 18:35:37 +02:00
|
|
|
qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
|
2015-05-08 17:49:53 +02:00
|
|
|
|
2014-04-25 13:27:34 +02:00
|
|
|
/* backing files always opened read-only */
|
2016-09-15 16:53:02 +02:00
|
|
|
qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
|
block: Add auto-read-only option
If a management application builds the block graph node by node, the
protocol layer doesn't inherit its read-only option from the format
layer any more, so it must be set explicitly.
Backing files should work on read-only storage, but at the same time, a
block job like commit should be able to reopen them read-write if they
are on read-write storage. However, without option inheritance, reopen
only changes the read-only option for the root node (typically the
format layer), but not the protocol layer, so reopening fails (the
format layer wants to get write permissions, but the protocol layer is
still read-only).
A simple workaround for the problem in the management tool would be to
open the protocol layer always read-write and to make only the format
layer read-only for backing files. However, sometimes the file is
actually stored on read-only storage and we don't know whether the image
can be opened read-write (for example, for NBD it depends on the server
we're trying to connect to). This adds an option that makes QEMU try to
open the image read-write, but allows it to degrade to a read-only mode
without returning an error.
The documentation for this option is consciously phrased in a way that
allows QEMU to switch to a better model eventually: Instead of trying
when the image is first opened, making the read-only flag dynamic and
changing it automatically whenever the first BLK_PERM_WRITE user is
attached or the last one is detached would be much more useful
behaviour.
Unfortunately, this more useful behaviour is also a lot harder to
implement, and libvirt needs a solution now before it can switch to
-blockdev, so let's start with this easier approach for now.
Instead of adding a new auto-read-only option, turning the existing
read-only into an enum (with a bool alternate for compatibility) was
considered, but it complicated the implementation to the point that it
didn't seem to be worth it.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2018-10-05 18:57:40 +02:00
|
|
|
qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
|
2016-09-15 16:53:02 +02:00
|
|
|
flags &= ~BDRV_O_COPY_ON_READ;
|
2014-04-25 13:27:34 +02:00
|
|
|
|
|
|
|
/* snapshot=on is handled on the top layer */
|
2014-04-11 19:16:36 +02:00
|
|
|
flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
|
2014-04-25 13:27:34 +02:00
|
|
|
|
2015-04-29 17:29:39 +02:00
|
|
|
*child_flags = flags;
|
2014-04-25 13:27:34 +02:00
|
|
|
}
|
|
|
|
|
2017-06-29 19:32:21 +02:00
|
|
|
static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
|
|
|
|
const char *filename, Error **errp)
|
|
|
|
{
|
|
|
|
BlockDriverState *parent = c->opaque;
|
2017-09-19 16:22:54 +02:00
|
|
|
int orig_flags = bdrv_get_flags(parent);
|
2017-06-29 19:32:21 +02:00
|
|
|
int ret;
|
|
|
|
|
2017-09-19 16:22:54 +02:00
|
|
|
if (!(orig_flags & BDRV_O_RDWR)) {
|
|
|
|
ret = bdrv_reopen(parent, orig_flags | BDRV_O_RDWR, errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-29 19:32:21 +02:00
|
|
|
ret = bdrv_change_backing_file(parent, filename,
|
|
|
|
base->drv ? base->drv->format_name : "");
|
|
|
|
if (ret < 0) {
|
2017-11-06 17:52:58 +01:00
|
|
|
error_setg_errno(errp, -ret, "Could not update backing file link");
|
2017-06-29 19:32:21 +02:00
|
|
|
}
|
|
|
|
|
2017-09-19 16:22:54 +02:00
|
|
|
if (!(orig_flags & BDRV_O_RDWR)) {
|
|
|
|
bdrv_reopen(parent, orig_flags, NULL);
|
|
|
|
}
|
|
|
|
|
2017-06-29 19:32:21 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-12-20 16:23:46 +01:00
|
|
|
const BdrvChildRole child_backing = {
|
2018-05-29 17:17:45 +02:00
|
|
|
.parent_is_bds = true,
|
2017-01-17 15:56:16 +01:00
|
|
|
.get_parent_desc = bdrv_child_get_parent_desc,
|
2017-02-08 11:28:52 +01:00
|
|
|
.attach = bdrv_backing_attach,
|
|
|
|
.detach = bdrv_backing_detach,
|
2015-04-29 17:29:39 +02:00
|
|
|
.inherit_options = bdrv_backing_options,
|
2016-05-23 18:46:59 +02:00
|
|
|
.drained_begin = bdrv_child_cb_drained_begin,
|
2018-03-22 14:11:20 +01:00
|
|
|
.drained_poll = bdrv_child_cb_drained_poll,
|
2016-05-23 18:46:59 +02:00
|
|
|
.drained_end = bdrv_child_cb_drained_end,
|
2017-05-04 18:52:39 +02:00
|
|
|
.inactivate = bdrv_child_cb_inactivate,
|
2017-06-29 19:32:21 +02:00
|
|
|
.update_filename = bdrv_backing_update_filename,
|
2015-04-08 13:43:47 +02:00
|
|
|
};
|
|
|
|
|
2012-11-12 17:05:39 +01:00
|
|
|
static int bdrv_open_flags(BlockDriverState *bs, int flags)
|
|
|
|
{
|
2016-03-18 17:46:45 +01:00
|
|
|
int open_flags = flags;
|
2012-11-12 17:05:39 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear flags that are internal to the block layer before opening the
|
|
|
|
* image.
|
|
|
|
*/
|
2014-06-04 14:33:27 +02:00
|
|
|
open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
|
2012-11-12 17:05:39 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Snapshots should be writable.
|
|
|
|
*/
|
2014-04-11 19:16:36 +02:00
|
|
|
if (flags & BDRV_O_TEMPORARY) {
|
2012-11-12 17:05:39 +01:00
|
|
|
open_flags |= BDRV_O_RDWR;
|
|
|
|
}
|
|
|
|
|
|
|
|
return open_flags;
|
|
|
|
}
|
|
|
|
|
2015-05-08 17:49:53 +02:00
|
|
|
static void update_flags_from_options(int *flags, QemuOpts *opts)
|
|
|
|
{
|
|
|
|
*flags &= ~BDRV_O_CACHE_MASK;
|
|
|
|
|
|
|
|
assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
|
2018-09-06 11:37:06 +02:00
|
|
|
if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
|
2015-05-08 17:49:53 +02:00
|
|
|
*flags |= BDRV_O_NO_FLUSH;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
|
2018-09-06 11:37:06 +02:00
|
|
|
if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_DIRECT, false)) {
|
2015-05-08 17:49:53 +02:00
|
|
|
*flags |= BDRV_O_NOCACHE;
|
|
|
|
}
|
2016-09-15 16:53:02 +02:00
|
|
|
|
|
|
|
*flags &= ~BDRV_O_RDWR;
|
|
|
|
|
|
|
|
assert(qemu_opt_find(opts, BDRV_OPT_READ_ONLY));
|
2018-09-06 11:37:06 +02:00
|
|
|
if (!qemu_opt_get_bool_del(opts, BDRV_OPT_READ_ONLY, false)) {
|
2016-09-15 16:53:02 +02:00
|
|
|
*flags |= BDRV_O_RDWR;
|
|
|
|
}
|
|
|
|
|
block: Add auto-read-only option
If a management application builds the block graph node by node, the
protocol layer doesn't inherit its read-only option from the format
layer any more, so it must be set explicitly.
Backing files should work on read-only storage, but at the same time, a
block job like commit should be able to reopen them read-write if they
are on read-write storage. However, without option inheritance, reopen
only changes the read-only option for the root node (typically the
format layer), but not the protocol layer, so reopening fails (the
format layer wants to get write permissions, but the protocol layer is
still read-only).
A simple workaround for the problem in the management tool would be to
open the protocol layer always read-write and to make only the format
layer read-only for backing files. However, sometimes the file is
actually stored on read-only storage and we don't know whether the image
can be opened read-write (for example, for NBD it depends on the server
we're trying to connect to). This adds an option that makes QEMU try to
open the image read-write, but allows it to degrade to a read-only mode
without returning an error.
The documentation for this option is consciously phrased in a way that
allows QEMU to switch to a better model eventually: Instead of trying
when the image is first opened, making the read-only flag dynamic and
changing it automatically whenever the first BLK_PERM_WRITE user is
attached or the last one is detached would be much more useful
behaviour.
Unfortunately, this more useful behaviour is also a lot harder to
implement, and libvirt needs a solution now before it can switch to
-blockdev, so let's start with this easier approach for now.
Instead of adding a new auto-read-only option, turning the existing
read-only into an enum (with a bool alternate for compatibility) was
considered, but it complicated the implementation to the point that it
didn't seem to be worth it.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2018-10-05 18:57:40 +02:00
|
|
|
assert(qemu_opt_find(opts, BDRV_OPT_AUTO_READ_ONLY));
|
|
|
|
if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
|
|
|
|
*flags |= BDRV_O_AUTO_RDONLY;
|
|
|
|
}
|
2015-05-08 17:49:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void update_options_from_flags(QDict *options, int flags)
|
|
|
|
{
|
|
|
|
if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
|
2015-05-08 17:49:53 +02:00
|
|
|
}
|
|
|
|
if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
|
|
|
|
flags & BDRV_O_NO_FLUSH);
|
2015-05-08 17:49:53 +02:00
|
|
|
}
|
2016-09-15 16:53:02 +02:00
|
|
|
if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
|
2016-09-15 16:53:02 +02:00
|
|
|
}
|
block: Add auto-read-only option
If a management application builds the block graph node by node, the
protocol layer doesn't inherit its read-only option from the format
layer any more, so it must be set explicitly.
Backing files should work on read-only storage, but at the same time, a
block job like commit should be able to reopen them read-write if they
are on read-write storage. However, without option inheritance, reopen
only changes the read-only option for the root node (typically the
format layer), but not the protocol layer, so reopening fails (the
format layer wants to get write permissions, but the protocol layer is
still read-only).
A simple workaround for the problem in the management tool would be to
open the protocol layer always read-write and to make only the format
layer read-only for backing files. However, sometimes the file is
actually stored on read-only storage and we don't know whether the image
can be opened read-write (for example, for NBD it depends on the server
we're trying to connect to). This adds an option that makes QEMU try to
open the image read-write, but allows it to degrade to a read-only mode
without returning an error.
The documentation for this option is consciously phrased in a way that
allows QEMU to switch to a better model eventually: Instead of trying
when the image is first opened, making the read-only flag dynamic and
changing it automatically whenever the first BLK_PERM_WRITE user is
attached or the last one is detached would be much more useful
behaviour.
Unfortunately, this more useful behaviour is also a lot harder to
implement, and libvirt needs a solution now before it can switch to
-blockdev, so let's start with this easier approach for now.
Instead of adding a new auto-read-only option, turning the existing
read-only into an enum (with a bool alternate for compatibility) was
considered, but it complicated the implementation to the point that it
didn't seem to be worth it.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2018-10-05 18:57:40 +02:00
|
|
|
if (!qdict_haskey(options, BDRV_OPT_AUTO_READ_ONLY)) {
|
|
|
|
qdict_put_bool(options, BDRV_OPT_AUTO_READ_ONLY,
|
|
|
|
flags & BDRV_O_AUTO_RDONLY);
|
|
|
|
}
|
2015-05-08 17:49:53 +02:00
|
|
|
}
|
|
|
|
|
2014-01-24 14:11:52 +01:00
|
|
|
static void bdrv_assign_node_name(BlockDriverState *bs,
|
|
|
|
const char *node_name,
|
|
|
|
Error **errp)
|
2014-01-23 21:31:33 +01:00
|
|
|
{
|
2015-10-13 01:36:50 +02:00
|
|
|
char *gen_node_name = NULL;
|
2014-01-23 21:31:33 +01:00
|
|
|
|
2015-10-13 01:36:50 +02:00
|
|
|
if (!node_name) {
|
|
|
|
node_name = gen_node_name = id_generate(ID_BLOCK);
|
|
|
|
} else if (!id_wellformed(node_name)) {
|
|
|
|
/*
|
|
|
|
* Check for empty string or invalid characters, but not if it is
|
|
|
|
* generated (generated names use characters not available to the user)
|
|
|
|
*/
|
2014-09-25 09:54:02 +02:00
|
|
|
error_setg(errp, "Invalid node name");
|
2014-01-24 14:11:52 +01:00
|
|
|
return;
|
2014-01-23 21:31:33 +01:00
|
|
|
}
|
|
|
|
|
2014-02-12 17:15:07 +01:00
|
|
|
/* takes care of avoiding namespaces collisions */
|
2014-10-07 13:59:12 +02:00
|
|
|
if (blk_by_name(node_name)) {
|
2014-02-12 17:15:07 +01:00
|
|
|
error_setg(errp, "node-name=%s is conflicting with a device id",
|
|
|
|
node_name);
|
2015-10-13 01:36:50 +02:00
|
|
|
goto out;
|
2014-02-12 17:15:07 +01:00
|
|
|
}
|
|
|
|
|
2014-01-23 21:31:33 +01:00
|
|
|
/* takes care of avoiding duplicates node names */
|
|
|
|
if (bdrv_find_node(node_name)) {
|
|
|
|
error_setg(errp, "Duplicate node name");
|
2015-10-13 01:36:50 +02:00
|
|
|
goto out;
|
2014-01-23 21:31:33 +01:00
|
|
|
}
|
|
|
|
|
2018-07-04 13:28:29 +02:00
|
|
|
/* Make sure that the node name isn't truncated */
|
|
|
|
if (strlen(node_name) >= sizeof(bs->node_name)) {
|
|
|
|
error_setg(errp, "Node name too long");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-01-23 21:31:33 +01:00
|
|
|
/* copy node name into the bs and insert it into the graph list */
|
|
|
|
pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
|
|
|
|
QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
|
2015-10-13 01:36:50 +02:00
|
|
|
out:
|
|
|
|
g_free(gen_node_name);
|
2014-01-23 21:31:33 +01:00
|
|
|
}
|
|
|
|
|
2017-01-18 15:51:56 +01:00
|
|
|
static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
|
|
|
|
const char *node_name, QDict *options,
|
|
|
|
int open_flags, Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
2018-03-28 18:29:18 +02:00
|
|
|
int i, ret;
|
2017-01-18 15:51:56 +01:00
|
|
|
|
|
|
|
bdrv_assign_node_name(bs, node_name, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
bs->drv = drv;
|
2017-01-18 17:16:41 +01:00
|
|
|
bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
|
2017-01-18 15:51:56 +01:00
|
|
|
bs->opaque = g_malloc0(drv->instance_size);
|
|
|
|
|
|
|
|
if (drv->bdrv_file_open) {
|
|
|
|
assert(!drv->bdrv_needs_filename || bs->filename[0]);
|
|
|
|
ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
|
2017-01-18 17:16:41 +01:00
|
|
|
} else if (drv->bdrv_open) {
|
2017-01-18 15:51:56 +01:00
|
|
|
ret = drv->bdrv_open(bs, options, open_flags, &local_err);
|
2017-01-18 17:16:41 +01:00
|
|
|
} else {
|
|
|
|
ret = 0;
|
2017-01-18 15:51:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
} else if (bs->filename[0]) {
|
|
|
|
error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
|
|
|
|
} else {
|
|
|
|
error_setg_errno(errp, -ret, "Could not open image");
|
|
|
|
}
|
2017-07-14 16:35:48 +02:00
|
|
|
goto open_failed;
|
2017-01-18 15:51:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = refresh_total_sectors(bs, bs->total_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_setg_errno(errp, -ret, "Could not refresh total sector count");
|
2017-07-14 16:35:48 +02:00
|
|
|
return ret;
|
2017-01-18 15:51:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bdrv_refresh_limits(bs, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
2017-07-14 16:35:48 +02:00
|
|
|
return -EINVAL;
|
2017-01-18 15:51:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(bdrv_opt_mem_align(bs) != 0);
|
|
|
|
assert(bdrv_min_mem_align(bs) != 0);
|
|
|
|
assert(is_power_of_2(bs->bl.request_alignment));
|
|
|
|
|
2018-03-28 18:29:18 +02:00
|
|
|
for (i = 0; i < bs->quiesce_counter; i++) {
|
|
|
|
if (drv->bdrv_co_drain_begin) {
|
|
|
|
drv->bdrv_co_drain_begin(bs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 15:51:56 +01:00
|
|
|
return 0;
|
2017-07-14 16:35:48 +02:00
|
|
|
open_failed:
|
|
|
|
bs->drv = NULL;
|
|
|
|
if (bs->file != NULL) {
|
|
|
|
bdrv_unref_child(bs, bs->file);
|
|
|
|
bs->file = NULL;
|
|
|
|
}
|
2017-01-18 15:51:56 +01:00
|
|
|
g_free(bs->opaque);
|
|
|
|
bs->opaque = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-01-18 17:16:41 +01:00
|
|
|
BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
|
|
|
|
int flags, Error **errp)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
bs = bdrv_new();
|
|
|
|
bs->open_flags = flags;
|
|
|
|
bs->explicit_options = qdict_new();
|
|
|
|
bs->options = qdict_new();
|
|
|
|
bs->opaque = NULL;
|
|
|
|
|
|
|
|
update_options_from_flags(bs->options, flags);
|
|
|
|
|
|
|
|
ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
|
|
|
|
if (ret < 0) {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs->explicit_options);
|
2017-07-14 16:35:48 +02:00
|
|
|
bs->explicit_options = NULL;
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs->options);
|
2017-07-14 16:35:48 +02:00
|
|
|
bs->options = NULL;
|
2017-01-18 17:16:41 +01:00
|
|
|
bdrv_unref(bs);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return bs;
|
|
|
|
}
|
|
|
|
|
2016-10-06 11:33:17 +02:00
|
|
|
QemuOptsList bdrv_runtime_opts = {
|
2015-04-07 17:12:56 +02:00
|
|
|
.name = "bdrv_common",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = "node-name",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Node name of the block device node",
|
|
|
|
},
|
2015-04-24 16:38:02 +02:00
|
|
|
{
|
|
|
|
.name = "driver",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Block driver to use for the node",
|
|
|
|
},
|
2015-05-08 17:49:53 +02:00
|
|
|
{
|
|
|
|
.name = BDRV_OPT_CACHE_DIRECT,
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "Bypass software writeback cache on the host",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = BDRV_OPT_CACHE_NO_FLUSH,
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "Ignore flush requests",
|
|
|
|
},
|
2016-09-15 16:53:02 +02:00
|
|
|
{
|
|
|
|
.name = BDRV_OPT_READ_ONLY,
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "Node is opened in read-only mode",
|
|
|
|
},
|
block: Add auto-read-only option
If a management application builds the block graph node by node, the
protocol layer doesn't inherit its read-only option from the format
layer any more, so it must be set explicitly.
Backing files should work on read-only storage, but at the same time, a
block job like commit should be able to reopen them read-write if they
are on read-write storage. However, without option inheritance, reopen
only changes the read-only option for the root node (typically the
format layer), but not the protocol layer, so reopening fails (the
format layer wants to get write permissions, but the protocol layer is
still read-only).
A simple workaround for the problem in the management tool would be to
open the protocol layer always read-write and to make only the format
layer read-only for backing files. However, sometimes the file is
actually stored on read-only storage and we don't know whether the image
can be opened read-write (for example, for NBD it depends on the server
we're trying to connect to). This adds an option that makes QEMU try to
open the image read-write, but allows it to degrade to a read-only mode
without returning an error.
The documentation for this option is consciously phrased in a way that
allows QEMU to switch to a better model eventually: Instead of trying
when the image is first opened, making the read-only flag dynamic and
changing it automatically whenever the first BLK_PERM_WRITE user is
attached or the last one is detached would be much more useful
behaviour.
Unfortunately, this more useful behaviour is also a lot harder to
implement, and libvirt needs a solution now before it can switch to
-blockdev, so let's start with this easier approach for now.
Instead of adding a new auto-read-only option, turning the existing
read-only into an enum (with a bool alternate for compatibility) was
considered, but it complicated the implementation to the point that it
didn't seem to be worth it.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2018-10-05 18:57:40 +02:00
|
|
|
{
|
|
|
|
.name = BDRV_OPT_AUTO_READ_ONLY,
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "Node can become read-only if opening read-write fails",
|
|
|
|
},
|
2016-09-12 21:00:41 +02:00
|
|
|
{
|
|
|
|
.name = "detect-zeroes",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "try to optimize zero writes (off, on, unmap)",
|
|
|
|
},
|
2016-09-12 18:03:18 +02:00
|
|
|
{
|
2018-10-03 12:23:13 +02:00
|
|
|
.name = BDRV_OPT_DISCARD,
|
2016-09-12 18:03:18 +02:00
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "discard operation (ignore/off, unmap/on)",
|
|
|
|
},
|
2017-05-02 18:35:37 +02:00
|
|
|
{
|
|
|
|
.name = BDRV_OPT_FORCE_SHARE,
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "always accept other writers (default: off)",
|
|
|
|
},
|
2015-04-07 17:12:56 +02:00
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-04-14 15:24:50 +02:00
|
|
|
/*
|
|
|
|
* Common part for opening disk images and files
|
2013-03-15 10:35:04 +01:00
|
|
|
*
|
|
|
|
* Removes all processed options from *options.
|
2010-04-14 15:24:50 +02:00
|
|
|
*/
|
2017-02-17 18:39:24 +01:00
|
|
|
static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
|
2016-01-11 19:07:50 +01:00
|
|
|
QDict *options, Error **errp)
|
2010-04-14 15:24:50 +02:00
|
|
|
{
|
|
|
|
int ret, open_flags;
|
2013-04-09 14:34:19 +02:00
|
|
|
const char *filename;
|
2015-04-24 16:38:02 +02:00
|
|
|
const char *driver_name = NULL;
|
2014-01-23 21:31:33 +01:00
|
|
|
const char *node_name = NULL;
|
2016-09-12 18:03:18 +02:00
|
|
|
const char *discard;
|
2015-04-07 17:12:56 +02:00
|
|
|
QemuOpts *opts;
|
2015-04-24 16:38:02 +02:00
|
|
|
BlockDriver *drv;
|
2013-09-05 14:45:29 +02:00
|
|
|
Error *local_err = NULL;
|
2010-04-14 15:24:50 +02:00
|
|
|
|
2012-05-08 16:51:49 +02:00
|
|
|
assert(bs->file == NULL);
|
2013-03-06 12:20:31 +01:00
|
|
|
assert(options != NULL && bs->options != options);
|
2010-04-14 15:24:50 +02:00
|
|
|
|
2015-04-24 16:38:02 +02:00
|
|
|
opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
|
|
|
|
qemu_opts_absorb_qdict(opts, options, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail_opts;
|
|
|
|
}
|
|
|
|
|
2016-09-15 16:53:01 +02:00
|
|
|
update_flags_from_options(&bs->open_flags, opts);
|
|
|
|
|
2015-04-24 16:38:02 +02:00
|
|
|
driver_name = qemu_opt_get(opts, "driver");
|
|
|
|
drv = bdrv_find_format(driver_name);
|
|
|
|
assert(drv != NULL);
|
|
|
|
|
2017-05-02 18:35:37 +02:00
|
|
|
bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);
|
|
|
|
|
|
|
|
if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {
|
|
|
|
error_setg(errp,
|
|
|
|
BDRV_OPT_FORCE_SHARE
|
|
|
|
"=on can only be used with read-only images");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail_opts;
|
|
|
|
}
|
|
|
|
|
2013-04-22 17:48:40 +02:00
|
|
|
if (file != NULL) {
|
2017-02-17 18:39:24 +01:00
|
|
|
filename = blk_bs(file)->filename;
|
2013-04-22 17:48:40 +02:00
|
|
|
} else {
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/*
|
|
|
|
* Caution: while qdict_get_try_str() is fine, getting
|
|
|
|
* non-string types would require more care. When @options
|
|
|
|
* come from -blockdev or blockdev_add, its members are typed
|
|
|
|
* according to the QAPI schema, but when they come from
|
|
|
|
* -drive, they're all QString.
|
|
|
|
*/
|
2013-04-22 17:48:40 +02:00
|
|
|
filename = qdict_get_try_str(options, "filename");
|
|
|
|
}
|
|
|
|
|
2017-04-13 18:06:24 +02:00
|
|
|
if (drv->bdrv_needs_filename && (!filename || !filename[0])) {
|
2014-02-03 14:49:42 +01:00
|
|
|
error_setg(errp, "The '%s' block driver requires a file name",
|
|
|
|
drv->format_name);
|
2015-04-07 17:12:56 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail_opts;
|
2014-01-23 21:31:33 +01:00
|
|
|
}
|
|
|
|
|
2016-01-11 19:07:50 +01:00
|
|
|
trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
|
|
|
|
drv->format_name);
|
2015-04-24 16:38:02 +02:00
|
|
|
|
2016-01-11 19:07:50 +01:00
|
|
|
bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
|
2013-05-29 13:35:40 +02:00
|
|
|
|
|
|
|
if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
|
2013-10-10 11:45:55 +02:00
|
|
|
error_setg(errp,
|
|
|
|
!bs->read_only && bdrv_is_whitelisted(drv, true)
|
|
|
|
? "Driver '%s' can only be used for read-only devices"
|
|
|
|
: "Driver '%s' is not whitelisted",
|
|
|
|
drv->format_name);
|
2015-04-07 17:12:56 +02:00
|
|
|
ret = -ENOTSUP;
|
|
|
|
goto fail_opts;
|
2013-05-29 13:35:40 +02:00
|
|
|
}
|
2010-04-14 15:24:50 +02:00
|
|
|
|
2017-06-05 14:38:50 +02:00
|
|
|
/* bdrv_new() and bdrv_close() make it so */
|
|
|
|
assert(atomic_read(&bs->copy_on_read) == 0);
|
|
|
|
|
2016-01-11 19:07:50 +01:00
|
|
|
if (bs->open_flags & BDRV_O_COPY_ON_READ) {
|
2013-09-19 15:12:18 +02:00
|
|
|
if (!bs->read_only) {
|
|
|
|
bdrv_enable_copy_on_read(bs);
|
|
|
|
} else {
|
|
|
|
error_setg(errp, "Can't use copy-on-read on read-only device");
|
2015-04-07 17:12:56 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail_opts;
|
2013-09-19 15:12:18 +02:00
|
|
|
}
|
2011-11-28 17:08:47 +01:00
|
|
|
}
|
|
|
|
|
2018-10-03 12:23:13 +02:00
|
|
|
discard = qemu_opt_get(opts, BDRV_OPT_DISCARD);
|
2016-09-12 18:03:18 +02:00
|
|
|
if (discard != NULL) {
|
|
|
|
if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
|
|
|
|
error_setg(errp, "Invalid discard option");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail_opts;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-06 11:37:09 +02:00
|
|
|
bs->detect_zeroes =
|
|
|
|
bdrv_parse_detect_zeroes(opts, bs->open_flags, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail_opts;
|
2016-09-12 21:00:41 +02:00
|
|
|
}
|
|
|
|
|
2013-03-18 16:40:51 +01:00
|
|
|
if (filename != NULL) {
|
|
|
|
pstrcpy(bs->filename, sizeof(bs->filename), filename);
|
|
|
|
} else {
|
|
|
|
bs->filename[0] = '\0';
|
|
|
|
}
|
2014-07-18 20:24:56 +02:00
|
|
|
pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
|
2010-04-14 15:24:50 +02:00
|
|
|
|
2010-04-14 14:17:38 +02:00
|
|
|
/* Open the image, either directly or using a protocol */
|
2016-01-11 19:07:50 +01:00
|
|
|
open_flags = bdrv_open_flags(bs, bs->open_flags);
|
2017-01-18 15:51:56 +01:00
|
|
|
node_name = qemu_opt_get(opts, "node-name");
|
2010-04-14 15:24:50 +02:00
|
|
|
|
2017-01-18 15:51:56 +01:00
|
|
|
assert(!drv->bdrv_file_open || file == NULL);
|
|
|
|
ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
|
2010-04-19 17:56:41 +02:00
|
|
|
if (ret < 0) {
|
2017-01-18 15:51:56 +01:00
|
|
|
goto fail_opts;
|
2014-07-16 17:48:16 +02:00
|
|
|
}
|
|
|
|
|
2015-04-07 17:12:56 +02:00
|
|
|
qemu_opts_del(opts);
|
2010-04-14 15:24:50 +02:00
|
|
|
return 0;
|
|
|
|
|
2015-04-07 17:12:56 +02:00
|
|
|
fail_opts:
|
|
|
|
qemu_opts_del(opts);
|
2010-04-14 15:24:50 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-05-26 11:45:08 +02:00
|
|
|
static QDict *parse_json_filename(const char *filename, Error **errp)
|
|
|
|
{
|
|
|
|
QObject *options_obj;
|
|
|
|
QDict *options;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = strstart(filename, "json:", &filename);
|
|
|
|
assert(ret);
|
|
|
|
|
2017-02-28 22:26:59 +01:00
|
|
|
options_obj = qobject_from_json(filename, errp);
|
2014-05-26 11:45:08 +02:00
|
|
|
if (!options_obj) {
|
2017-02-28 22:26:59 +01:00
|
|
|
error_prepend(errp, "Could not parse the JSON options: ");
|
2014-05-26 11:45:08 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2018-02-24 16:40:29 +01:00
|
|
|
options = qobject_to(QDict, options_obj);
|
2017-02-17 21:38:18 +01:00
|
|
|
if (!options) {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(options_obj);
|
2014-05-26 11:45:08 +02:00
|
|
|
error_setg(errp, "Invalid JSON object given");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
qdict_flatten(options);
|
|
|
|
|
|
|
|
return options;
|
|
|
|
}
|
|
|
|
|
2015-10-29 15:24:41 +01:00
|
|
|
static void parse_json_protocol(QDict *options, const char **pfilename,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QDict *json_options;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
/* Parse json: pseudo-protocol */
|
|
|
|
if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
json_options = parse_json_filename(*pfilename, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Options given in the filename have lower priority than options
|
|
|
|
* specified directly */
|
|
|
|
qdict_join(options, json_options, false);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(json_options);
|
2015-10-29 15:24:41 +01:00
|
|
|
*pfilename = NULL;
|
|
|
|
}
|
|
|
|
|
2010-04-12 16:37:13 +02:00
|
|
|
/*
|
2014-05-26 11:09:59 +02:00
|
|
|
* Fills in default options for opening images and converts the legacy
|
|
|
|
* filename/flags pair to option QDict entries.
|
block: driver should override flags in bdrv_open()
The BDRV_O_PROTOCOL flag should have an impact only if no driver is
specified explicitly. Therefore, if bdrv_open() is called with an
explicit block driver argument (either through the options QDict or
through the drv parameter) and that block driver is a protocol block
driver, BDRV_O_PROTOCOL should be set; if it is a format block driver,
BDRV_O_PROTOCOL should be unset.
While there was code to unset the flag in case a format block driver
has been selected, it only followed the bdrv_fill_options() function
call whereas the flag in fact needs to be adjusted before it is used
there.
With that change, BDRV_O_PROTOCOL will always be set if the BDS should
be a protocol driver; if the driver has been specified explicitly, the
new code will set it; and bdrv_fill_options() will only "probe" a
protocol driver if BDRV_O_PROTOCOL is set. The probing after
bdrv_fill_options() cannot select a protocol driver.
Thus, bdrv_open_image() to open BDS.file is never called if a protocol
BDS is about to be created. With that change in turn it is impossible to
call bdrv_open_common() with a protocol drv and file != NULL, which
allows us to remove the bdrv_swap() call.
This change breaks a test case in qemu-iotest 051:
"-drive file=t.qcow2,file.driver=qcow2" now works because the explicitly
specified "qcow2" overrides the BDRV_O_PROTOCOL which is automatically
set for the "file" BDS (and the filename is just passed down).
Therefore, this patch removes that test case.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-03-19 19:53:16 +01:00
|
|
|
* The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
|
|
|
|
* block driver has been specified explicitly.
|
2010-04-12 16:37:13 +02:00
|
|
|
*/
|
2015-10-29 15:24:41 +01:00
|
|
|
static int bdrv_fill_options(QDict **options, const char *filename,
|
2015-08-26 19:47:51 +02:00
|
|
|
int *flags, Error **errp)
|
2004-08-01 23:59:26 +02:00
|
|
|
{
|
2013-03-18 16:40:51 +01:00
|
|
|
const char *drvname;
|
block: driver should override flags in bdrv_open()
The BDRV_O_PROTOCOL flag should have an impact only if no driver is
specified explicitly. Therefore, if bdrv_open() is called with an
explicit block driver argument (either through the options QDict or
through the drv parameter) and that block driver is a protocol block
driver, BDRV_O_PROTOCOL should be set; if it is a format block driver,
BDRV_O_PROTOCOL should be unset.
While there was code to unset the flag in case a format block driver
has been selected, it only followed the bdrv_fill_options() function
call whereas the flag in fact needs to be adjusted before it is used
there.
With that change, BDRV_O_PROTOCOL will always be set if the BDS should
be a protocol driver; if the driver has been specified explicitly, the
new code will set it; and bdrv_fill_options() will only "probe" a
protocol driver if BDRV_O_PROTOCOL is set. The probing after
bdrv_fill_options() cannot select a protocol driver.
Thus, bdrv_open_image() to open BDS.file is never called if a protocol
BDS is about to be created. With that change in turn it is impossible to
call bdrv_open_common() with a protocol drv and file != NULL, which
allows us to remove the bdrv_swap() call.
This change breaks a test case in qemu-iotest 051:
"-drive file=t.qcow2,file.driver=qcow2" now works because the explicitly
specified "qcow2" overrides the BDRV_O_PROTOCOL which is automatically
set for the "file" BDS (and the filename is just passed down).
Therefore, this patch removes that test case.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-03-19 19:53:16 +01:00
|
|
|
bool protocol = *flags & BDRV_O_PROTOCOL;
|
2014-04-03 12:45:51 +02:00
|
|
|
bool parse_filename = false;
|
2015-08-26 19:47:51 +02:00
|
|
|
BlockDriver *drv = NULL;
|
2013-09-05 14:45:29 +02:00
|
|
|
Error *local_err = NULL;
|
2006-08-01 18:21:11 +02:00
|
|
|
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/*
|
|
|
|
* Caution: while qdict_get_try_str() is fine, getting non-string
|
|
|
|
* types would require more care. When @options come from
|
|
|
|
* -blockdev or blockdev_add, its members are typed according to
|
|
|
|
* the QAPI schema, but when they come from -drive, they're all
|
|
|
|
* QString.
|
|
|
|
*/
|
block: driver should override flags in bdrv_open()
The BDRV_O_PROTOCOL flag should have an impact only if no driver is
specified explicitly. Therefore, if bdrv_open() is called with an
explicit block driver argument (either through the options QDict or
through the drv parameter) and that block driver is a protocol block
driver, BDRV_O_PROTOCOL should be set; if it is a format block driver,
BDRV_O_PROTOCOL should be unset.
While there was code to unset the flag in case a format block driver
has been selected, it only followed the bdrv_fill_options() function
call whereas the flag in fact needs to be adjusted before it is used
there.
With that change, BDRV_O_PROTOCOL will always be set if the BDS should
be a protocol driver; if the driver has been specified explicitly, the
new code will set it; and bdrv_fill_options() will only "probe" a
protocol driver if BDRV_O_PROTOCOL is set. The probing after
bdrv_fill_options() cannot select a protocol driver.
Thus, bdrv_open_image() to open BDS.file is never called if a protocol
BDS is about to be created. With that change in turn it is impossible to
call bdrv_open_common() with a protocol drv and file != NULL, which
allows us to remove the bdrv_swap() call.
This change breaks a test case in qemu-iotest 051:
"-drive file=t.qcow2,file.driver=qcow2" now works because the explicitly
specified "qcow2" overrides the BDRV_O_PROTOCOL which is automatically
set for the "file" BDS (and the filename is just passed down).
Therefore, this patch removes that test case.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-03-19 19:53:16 +01:00
|
|
|
drvname = qdict_get_try_str(*options, "driver");
|
2015-08-26 19:47:51 +02:00
|
|
|
if (drvname) {
|
|
|
|
drv = bdrv_find_format(drvname);
|
|
|
|
if (!drv) {
|
|
|
|
error_setg(errp, "Unknown driver '%s'", drvname);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
/* If the user has explicitly specified the driver, this choice should
|
|
|
|
* override the BDRV_O_PROTOCOL flag */
|
|
|
|
protocol = drv->bdrv_file_open;
|
block: driver should override flags in bdrv_open()
The BDRV_O_PROTOCOL flag should have an impact only if no driver is
specified explicitly. Therefore, if bdrv_open() is called with an
explicit block driver argument (either through the options QDict or
through the drv parameter) and that block driver is a protocol block
driver, BDRV_O_PROTOCOL should be set; if it is a format block driver,
BDRV_O_PROTOCOL should be unset.
While there was code to unset the flag in case a format block driver
has been selected, it only followed the bdrv_fill_options() function
call whereas the flag in fact needs to be adjusted before it is used
there.
With that change, BDRV_O_PROTOCOL will always be set if the BDS should
be a protocol driver; if the driver has been specified explicitly, the
new code will set it; and bdrv_fill_options() will only "probe" a
protocol driver if BDRV_O_PROTOCOL is set. The probing after
bdrv_fill_options() cannot select a protocol driver.
Thus, bdrv_open_image() to open BDS.file is never called if a protocol
BDS is about to be created. With that change in turn it is impossible to
call bdrv_open_common() with a protocol drv and file != NULL, which
allows us to remove the bdrv_swap() call.
This change breaks a test case in qemu-iotest 051:
"-drive file=t.qcow2,file.driver=qcow2" now works because the explicitly
specified "qcow2" overrides the BDRV_O_PROTOCOL which is automatically
set for the "file" BDS (and the filename is just passed down).
Therefore, this patch removes that test case.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-03-19 19:53:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (protocol) {
|
|
|
|
*flags |= BDRV_O_PROTOCOL;
|
|
|
|
} else {
|
|
|
|
*flags &= ~BDRV_O_PROTOCOL;
|
|
|
|
}
|
|
|
|
|
2015-05-08 17:49:53 +02:00
|
|
|
/* Translate cache options from flags into options */
|
|
|
|
update_options_from_flags(*options, *flags);
|
|
|
|
|
2013-04-09 14:34:19 +02:00
|
|
|
/* Fetch the file name from the options QDict if necessary */
|
2014-05-27 10:50:29 +02:00
|
|
|
if (protocol && filename) {
|
2014-05-26 11:09:59 +02:00
|
|
|
if (!qdict_haskey(*options, "filename")) {
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(*options, "filename", filename);
|
2014-05-26 11:09:59 +02:00
|
|
|
parse_filename = true;
|
|
|
|
} else {
|
|
|
|
error_setg(errp, "Can't specify 'file' and 'filename' options at "
|
|
|
|
"the same time");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-04-09 14:34:19 +02:00
|
|
|
}
|
|
|
|
|
2013-03-18 16:40:51 +01:00
|
|
|
/* Find the right block driver */
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/* See cautionary note on accessing @options above */
|
2014-05-26 11:09:59 +02:00
|
|
|
filename = qdict_get_try_str(*options, "filename");
|
|
|
|
|
2015-08-26 19:47:51 +02:00
|
|
|
if (!drvname && protocol) {
|
|
|
|
if (filename) {
|
|
|
|
drv = bdrv_find_protocol(filename, parse_filename, errp);
|
2014-05-27 10:50:29 +02:00
|
|
|
if (!drv) {
|
2015-08-26 19:47:51 +02:00
|
|
|
return -EINVAL;
|
2014-05-27 10:50:29 +02:00
|
|
|
}
|
2015-08-26 19:47:51 +02:00
|
|
|
|
|
|
|
drvname = drv->format_name;
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(*options, "driver", drvname);
|
2015-08-26 19:47:51 +02:00
|
|
|
} else {
|
|
|
|
error_setg(errp, "Must specify either driver or file");
|
|
|
|
return -EINVAL;
|
2013-07-10 15:47:39 +02:00
|
|
|
}
|
2013-03-18 16:40:51 +01:00
|
|
|
}
|
|
|
|
|
2014-05-27 10:50:29 +02:00
|
|
|
assert(drv || !protocol);
|
2013-03-18 16:40:51 +01:00
|
|
|
|
2014-05-26 11:09:59 +02:00
|
|
|
/* Driver-specific filename parsing */
|
2014-05-27 10:50:29 +02:00
|
|
|
if (drv && drv->bdrv_parse_filename && parse_filename) {
|
2014-02-18 18:33:11 +01:00
|
|
|
drv->bdrv_parse_filename(filename, *options, &local_err);
|
2014-01-30 15:07:28 +01:00
|
|
|
if (local_err) {
|
2013-09-05 14:45:29 +02:00
|
|
|
error_propagate(errp, local_err);
|
2014-05-26 11:09:59 +02:00
|
|
|
return -EINVAL;
|
2013-03-15 18:47:22 +01:00
|
|
|
}
|
2014-03-05 22:41:36 +01:00
|
|
|
|
|
|
|
if (!drv->bdrv_needs_filename) {
|
|
|
|
qdict_del(*options, "filename");
|
|
|
|
}
|
2013-03-15 18:47:22 +01:00
|
|
|
}
|
|
|
|
|
2014-05-26 11:09:59 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-09-14 14:42:12 +02:00
|
|
|
static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
|
|
|
|
uint64_t perm, uint64_t shared,
|
2017-03-14 03:30:50 +01:00
|
|
|
GSList *ignore_children, Error **errp);
|
|
|
|
static void bdrv_child_abort_perm_update(BdrvChild *c);
|
|
|
|
static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);
|
|
|
|
|
2017-09-14 14:32:04 +02:00
|
|
|
typedef struct BlockReopenQueueEntry {
|
|
|
|
bool prepared;
|
|
|
|
BDRVReopenState state;
|
|
|
|
QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
|
|
|
|
} BlockReopenQueueEntry;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the flags that @bs will have after the reopens in @q have
|
|
|
|
* successfully completed. If @q is NULL (or @bs is not contained in @q),
|
|
|
|
* return the current flags.
|
|
|
|
*/
|
|
|
|
static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BlockReopenQueueEntry *entry;
|
|
|
|
|
|
|
|
if (q != NULL) {
|
|
|
|
QSIMPLEQ_FOREACH(entry, q, entry) {
|
|
|
|
if (entry->state.bs == bs) {
|
|
|
|
return entry->state.flags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return bs->open_flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns whether the image file can be written to after the reopen queue @q
|
|
|
|
* has been successfully applied, or right now if @q is NULL. */
|
2018-06-06 21:37:00 +02:00
|
|
|
static bool bdrv_is_writable_after_reopen(BlockDriverState *bs,
|
|
|
|
BlockReopenQueue *q)
|
2017-09-14 14:32:04 +02:00
|
|
|
{
|
|
|
|
int flags = bdrv_reopen_get_flags(q, bs);
|
|
|
|
|
|
|
|
return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR;
|
|
|
|
}
|
|
|
|
|
2018-06-06 21:37:00 +02:00
|
|
|
/*
|
|
|
|
* Return whether the BDS can be written to. This is not necessarily
|
|
|
|
* the same as !bdrv_is_read_only(bs), as inactivated images may not
|
|
|
|
* be written to but do not count as read-only images.
|
|
|
|
*/
|
|
|
|
bool bdrv_is_writable(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
return bdrv_is_writable_after_reopen(bs, NULL);
|
|
|
|
}
|
|
|
|
|
2017-05-02 18:35:38 +02:00
|
|
|
static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
|
2017-09-14 12:47:11 +02:00
|
|
|
BdrvChild *c, const BdrvChildRole *role,
|
|
|
|
BlockReopenQueue *reopen_queue,
|
2017-05-02 18:35:38 +02:00
|
|
|
uint64_t parent_perm, uint64_t parent_shared,
|
|
|
|
uint64_t *nperm, uint64_t *nshared)
|
|
|
|
{
|
|
|
|
if (bs->drv && bs->drv->bdrv_child_perm) {
|
2017-09-14 12:47:11 +02:00
|
|
|
bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
|
2017-05-02 18:35:38 +02:00
|
|
|
parent_perm, parent_shared,
|
|
|
|
nperm, nshared);
|
|
|
|
}
|
2017-09-14 12:47:11 +02:00
|
|
|
/* TODO Take force_share from reopen_queue */
|
2017-05-02 18:35:38 +02:00
|
|
|
if (child_bs && child_bs->force_share) {
|
|
|
|
*nshared = BLK_PERM_ALL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-15 13:04:20 +01:00
|
|
|
/*
|
|
|
|
* Check whether permissions on this node can be changed in a way that
|
|
|
|
* @cumulative_perms and @cumulative_shared_perms are the new cumulative
|
|
|
|
* permissions of all its parents. This involves checking whether all necessary
|
|
|
|
* permission changes to child nodes can be performed.
|
|
|
|
*
|
|
|
|
* A call to this function must always be followed by a call to bdrv_set_perm()
|
|
|
|
* or bdrv_abort_perm_update().
|
|
|
|
*/
|
2017-09-14 14:42:12 +02:00
|
|
|
static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q,
|
|
|
|
uint64_t cumulative_perms,
|
2017-03-06 15:00:13 +01:00
|
|
|
uint64_t cumulative_shared_perms,
|
|
|
|
GSList *ignore_children, Error **errp)
|
2016-12-15 13:04:20 +01:00
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
BdrvChild *c;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Write permissions never work with read-only images */
|
|
|
|
if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
|
2018-06-06 21:37:00 +02:00
|
|
|
!bdrv_is_writable_after_reopen(bs, q))
|
2016-12-15 13:04:20 +01:00
|
|
|
{
|
|
|
|
error_setg(errp, "Block node is read-only");
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check this node */
|
|
|
|
if (!drv) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (drv->bdrv_check_perm) {
|
|
|
|
return drv->bdrv_check_perm(bs, cumulative_perms,
|
|
|
|
cumulative_shared_perms, errp);
|
|
|
|
}
|
|
|
|
|
2016-12-20 23:25:12 +01:00
|
|
|
/* Drivers that never have children can omit .bdrv_child_perm() */
|
2016-12-15 13:04:20 +01:00
|
|
|
if (!drv->bdrv_child_perm) {
|
2016-12-20 23:25:12 +01:00
|
|
|
assert(QLIST_EMPTY(&bs->children));
|
2016-12-15 13:04:20 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check all children */
|
|
|
|
QLIST_FOREACH(c, &bs->children, next) {
|
|
|
|
uint64_t cur_perm, cur_shared;
|
2017-09-14 14:42:12 +02:00
|
|
|
bdrv_child_perm(bs, c->bs, c, c->role, q,
|
2017-05-02 18:35:38 +02:00
|
|
|
cumulative_perms, cumulative_shared_perms,
|
|
|
|
&cur_perm, &cur_shared);
|
2017-09-14 14:42:12 +02:00
|
|
|
ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared,
|
|
|
|
ignore_children, errp);
|
2016-12-15 13:04:20 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Notifies drivers that after a previous bdrv_check_perm() call, the
|
|
|
|
* permission update is not performed and any preparations made for it (e.g.
|
|
|
|
* taken file locks) need to be undone.
|
|
|
|
*
|
|
|
|
* This function recursively notifies all child nodes.
|
|
|
|
*/
|
|
|
|
static void bdrv_abort_perm_update(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
BdrvChild *c;
|
|
|
|
|
|
|
|
if (!drv) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (drv->bdrv_abort_perm_update) {
|
|
|
|
drv->bdrv_abort_perm_update(bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
QLIST_FOREACH(c, &bs->children, next) {
|
|
|
|
bdrv_child_abort_perm_update(c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
|
|
|
|
uint64_t cumulative_shared_perms)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
BdrvChild *c;
|
|
|
|
|
|
|
|
if (!drv) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update this node */
|
|
|
|
if (drv->bdrv_set_perm) {
|
|
|
|
drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);
|
|
|
|
}
|
|
|
|
|
2016-12-20 23:25:12 +01:00
|
|
|
/* Drivers that never have children can omit .bdrv_child_perm() */
|
2016-12-15 13:04:20 +01:00
|
|
|
if (!drv->bdrv_child_perm) {
|
2016-12-20 23:25:12 +01:00
|
|
|
assert(QLIST_EMPTY(&bs->children));
|
2016-12-15 13:04:20 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update all children */
|
|
|
|
QLIST_FOREACH(c, &bs->children, next) {
|
|
|
|
uint64_t cur_perm, cur_shared;
|
2017-09-14 12:47:11 +02:00
|
|
|
bdrv_child_perm(bs, c->bs, c, c->role, NULL,
|
2017-05-02 18:35:38 +02:00
|
|
|
cumulative_perms, cumulative_shared_perms,
|
|
|
|
&cur_perm, &cur_shared);
|
2016-12-15 13:04:20 +01:00
|
|
|
bdrv_child_set_perm(c, cur_perm, cur_shared);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
|
|
|
|
uint64_t *shared_perm)
|
|
|
|
{
|
|
|
|
BdrvChild *c;
|
|
|
|
uint64_t cumulative_perms = 0;
|
|
|
|
uint64_t cumulative_shared_perms = BLK_PERM_ALL;
|
|
|
|
|
|
|
|
QLIST_FOREACH(c, &bs->parents, next_parent) {
|
|
|
|
cumulative_perms |= c->perm;
|
|
|
|
cumulative_shared_perms &= c->shared_perm;
|
|
|
|
}
|
|
|
|
|
|
|
|
*perm = cumulative_perms;
|
|
|
|
*shared_perm = cumulative_shared_perms;
|
|
|
|
}
|
|
|
|
|
2017-01-16 18:26:20 +01:00
|
|
|
static char *bdrv_child_user_desc(BdrvChild *c)
|
|
|
|
{
|
|
|
|
if (c->role->get_parent_desc) {
|
|
|
|
return c->role->get_parent_desc(c);
|
|
|
|
}
|
|
|
|
|
|
|
|
return g_strdup("another user");
|
|
|
|
}
|
|
|
|
|
2017-05-02 18:35:36 +02:00
|
|
|
char *bdrv_perm_names(uint64_t perm)
|
2017-01-16 18:26:20 +01:00
|
|
|
{
|
|
|
|
struct perm_name {
|
|
|
|
uint64_t perm;
|
|
|
|
const char *name;
|
|
|
|
} permissions[] = {
|
|
|
|
{ BLK_PERM_CONSISTENT_READ, "consistent read" },
|
|
|
|
{ BLK_PERM_WRITE, "write" },
|
|
|
|
{ BLK_PERM_WRITE_UNCHANGED, "write unchanged" },
|
|
|
|
{ BLK_PERM_RESIZE, "resize" },
|
|
|
|
{ BLK_PERM_GRAPH_MOD, "change children" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
char *result = g_strdup("");
|
|
|
|
struct perm_name *p;
|
|
|
|
|
|
|
|
for (p = permissions; p->name; p++) {
|
|
|
|
if (perm & p->perm) {
|
|
|
|
char *old = result;
|
|
|
|
result = g_strdup_printf("%s%s%s", old, *old ? ", " : "", p->name);
|
|
|
|
g_free(old);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2016-12-15 13:04:20 +01:00
|
|
|
/*
|
|
|
|
* Checks whether a new reference to @bs can be added if the new user requires
|
2017-03-06 15:00:13 +01:00
|
|
|
* @new_used_perm/@new_shared_perm as its permissions. If @ignore_children is
|
|
|
|
* set, the BdrvChild objects in this list are ignored in the calculations;
|
|
|
|
* this allows checking permission updates for an existing reference.
|
2016-12-15 13:04:20 +01:00
|
|
|
*
|
|
|
|
* Needs to be followed by a call to either bdrv_set_perm() or
|
|
|
|
* bdrv_abort_perm_update(). */
|
2017-09-14 14:42:12 +02:00
|
|
|
static int bdrv_check_update_perm(BlockDriverState *bs, BlockReopenQueue *q,
|
|
|
|
uint64_t new_used_perm,
|
2016-12-14 17:24:36 +01:00
|
|
|
uint64_t new_shared_perm,
|
2017-03-06 15:00:13 +01:00
|
|
|
GSList *ignore_children, Error **errp)
|
2016-12-14 17:24:36 +01:00
|
|
|
{
|
|
|
|
BdrvChild *c;
|
2016-12-15 13:04:20 +01:00
|
|
|
uint64_t cumulative_perms = new_used_perm;
|
|
|
|
uint64_t cumulative_shared_perms = new_shared_perm;
|
2016-12-14 17:24:36 +01:00
|
|
|
|
|
|
|
/* There is no reason why anyone couldn't tolerate write_unchanged */
|
|
|
|
assert(new_shared_perm & BLK_PERM_WRITE_UNCHANGED);
|
|
|
|
|
|
|
|
QLIST_FOREACH(c, &bs->parents, next_parent) {
|
2017-03-06 15:00:13 +01:00
|
|
|
if (g_slist_find(ignore_children, c)) {
|
2016-12-14 17:24:36 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-01-16 18:26:20 +01:00
|
|
|
if ((new_used_perm & c->shared_perm) != new_used_perm) {
|
|
|
|
char *user = bdrv_child_user_desc(c);
|
|
|
|
char *perm_names = bdrv_perm_names(new_used_perm & ~c->shared_perm);
|
|
|
|
error_setg(errp, "Conflicts with use by %s as '%s', which does not "
|
|
|
|
"allow '%s' on %s",
|
|
|
|
user, c->name, perm_names, bdrv_get_node_name(c->bs));
|
|
|
|
g_free(user);
|
|
|
|
g_free(perm_names);
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((c->perm & new_shared_perm) != c->perm) {
|
|
|
|
char *user = bdrv_child_user_desc(c);
|
|
|
|
char *perm_names = bdrv_perm_names(c->perm & ~new_shared_perm);
|
|
|
|
error_setg(errp, "Conflicts with use by %s as '%s', which uses "
|
|
|
|
"'%s' on %s",
|
|
|
|
user, c->name, perm_names, bdrv_get_node_name(c->bs));
|
|
|
|
g_free(user);
|
|
|
|
g_free(perm_names);
|
2016-12-14 17:24:36 +01:00
|
|
|
return -EPERM;
|
|
|
|
}
|
2016-12-15 13:04:20 +01:00
|
|
|
|
|
|
|
cumulative_perms |= c->perm;
|
|
|
|
cumulative_shared_perms &= c->shared_perm;
|
2016-12-14 17:24:36 +01:00
|
|
|
}
|
|
|
|
|
2017-09-14 14:42:12 +02:00
|
|
|
return bdrv_check_perm(bs, q, cumulative_perms, cumulative_shared_perms,
|
2017-03-06 15:00:13 +01:00
|
|
|
ignore_children, errp);
|
2016-12-15 13:04:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Needs to be followed by a call to either bdrv_child_set_perm() or
|
|
|
|
* bdrv_child_abort_perm_update(). */
|
2017-09-14 14:42:12 +02:00
|
|
|
static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
|
|
|
|
uint64_t perm, uint64_t shared,
|
2017-03-14 03:30:50 +01:00
|
|
|
GSList *ignore_children, Error **errp)
|
2016-12-15 13:04:20 +01:00
|
|
|
{
|
2017-03-06 15:00:13 +01:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ignore_children = g_slist_prepend(g_slist_copy(ignore_children), c);
|
2017-09-14 14:42:12 +02:00
|
|
|
ret = bdrv_check_update_perm(c->bs, q, perm, shared, ignore_children, errp);
|
2017-03-06 15:00:13 +01:00
|
|
|
g_slist_free(ignore_children);
|
|
|
|
|
|
|
|
return ret;
|
2016-12-15 13:04:20 +01:00
|
|
|
}
|
|
|
|
|
2017-03-14 03:30:50 +01:00
|
|
|
static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared)
|
2016-12-15 13:04:20 +01:00
|
|
|
{
|
|
|
|
uint64_t cumulative_perms, cumulative_shared_perms;
|
|
|
|
|
|
|
|
c->perm = perm;
|
|
|
|
c->shared_perm = shared;
|
|
|
|
|
|
|
|
bdrv_get_cumulative_perm(c->bs, &cumulative_perms,
|
|
|
|
&cumulative_shared_perms);
|
|
|
|
bdrv_set_perm(c->bs, cumulative_perms, cumulative_shared_perms);
|
|
|
|
}
|
|
|
|
|
2017-03-14 03:30:50 +01:00
|
|
|
static void bdrv_child_abort_perm_update(BdrvChild *c)
|
2016-12-15 13:04:20 +01:00
|
|
|
{
|
|
|
|
bdrv_abort_perm_update(c->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2017-09-14 14:42:12 +02:00
|
|
|
ret = bdrv_child_check_perm(c, NULL, perm, shared, NULL, errp);
|
2016-12-15 13:04:20 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
bdrv_child_abort_perm_update(c);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bdrv_child_set_perm(c, perm, shared);
|
|
|
|
|
2016-12-14 17:24:36 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-12-15 11:27:32 +01:00
|
|
|
void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
|
|
|
|
const BdrvChildRole *role,
|
2017-09-14 12:47:11 +02:00
|
|
|
BlockReopenQueue *reopen_queue,
|
2016-12-15 11:27:32 +01:00
|
|
|
uint64_t perm, uint64_t shared,
|
|
|
|
uint64_t *nperm, uint64_t *nshared)
|
|
|
|
{
|
|
|
|
if (c == NULL) {
|
|
|
|
*nperm = perm & DEFAULT_PERM_PASSTHROUGH;
|
|
|
|
*nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*nperm = (perm & DEFAULT_PERM_PASSTHROUGH) |
|
|
|
|
(c->perm & DEFAULT_PERM_UNCHANGED);
|
|
|
|
*nshared = (shared & DEFAULT_PERM_PASSTHROUGH) |
|
|
|
|
(c->shared_perm & DEFAULT_PERM_UNCHANGED);
|
|
|
|
}
|
|
|
|
|
2016-12-19 15:21:48 +01:00
|
|
|
void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
|
|
|
|
const BdrvChildRole *role,
|
2017-09-14 12:47:11 +02:00
|
|
|
BlockReopenQueue *reopen_queue,
|
2016-12-19 15:21:48 +01:00
|
|
|
uint64_t perm, uint64_t shared,
|
|
|
|
uint64_t *nperm, uint64_t *nshared)
|
|
|
|
{
|
|
|
|
bool backing = (role == &child_backing);
|
|
|
|
assert(role == &child_backing || role == &child_file);
|
|
|
|
|
|
|
|
if (!backing) {
|
2017-11-30 17:38:43 +01:00
|
|
|
int flags = bdrv_reopen_get_flags(reopen_queue, bs);
|
|
|
|
|
2016-12-19 15:21:48 +01:00
|
|
|
/* Apart from the modifications below, the same permissions are
|
|
|
|
* forwarded and left alone as for filters */
|
2017-09-14 12:47:11 +02:00
|
|
|
bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
|
|
|
|
&perm, &shared);
|
2016-12-19 15:21:48 +01:00
|
|
|
|
|
|
|
/* Format drivers may touch metadata even if the guest doesn't write */
|
2018-06-06 21:37:00 +02:00
|
|
|
if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
|
2016-12-19 15:21:48 +01:00
|
|
|
perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bs->file always needs to be consistent because of the metadata. We
|
|
|
|
* can never allow other users to resize or write to it. */
|
2017-11-30 17:38:43 +01:00
|
|
|
if (!(flags & BDRV_O_NO_IO)) {
|
|
|
|
perm |= BLK_PERM_CONSISTENT_READ;
|
|
|
|
}
|
2016-12-19 15:21:48 +01:00
|
|
|
shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
|
|
|
|
} else {
|
|
|
|
/* We want consistent read from backing files if the parent needs it.
|
|
|
|
* No other operations are performed on backing files. */
|
|
|
|
perm &= BLK_PERM_CONSISTENT_READ;
|
|
|
|
|
|
|
|
/* If the parent can deal with changing data, we're okay with a
|
|
|
|
* writable and resizable backing file. */
|
|
|
|
/* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */
|
|
|
|
if (shared & BLK_PERM_WRITE) {
|
|
|
|
shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
|
|
|
|
} else {
|
|
|
|
shared = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
|
|
|
|
BLK_PERM_WRITE_UNCHANGED;
|
|
|
|
}
|
|
|
|
|
2017-05-04 18:52:40 +02:00
|
|
|
if (bs->open_flags & BDRV_O_INACTIVE) {
|
|
|
|
shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
|
|
|
|
}
|
|
|
|
|
2016-12-19 15:21:48 +01:00
|
|
|
*nperm = perm;
|
|
|
|
*nshared = shared;
|
|
|
|
}
|
|
|
|
|
2017-03-06 13:45:28 +01:00
|
|
|
static void bdrv_replace_child_noperm(BdrvChild *child,
|
|
|
|
BlockDriverState *new_bs)
|
2016-05-23 15:52:26 +02:00
|
|
|
{
|
|
|
|
BlockDriverState *old_bs = child->bs;
|
2017-12-07 13:03:13 +01:00
|
|
|
int i;
|
2016-05-23 15:52:26 +02:00
|
|
|
|
2017-04-07 08:54:10 +02:00
|
|
|
if (old_bs && new_bs) {
|
|
|
|
assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
|
|
|
|
}
|
2016-05-23 15:52:26 +02:00
|
|
|
if (old_bs) {
|
2017-12-18 16:05:48 +01:00
|
|
|
/* Detach first so that the recursive drain sections coming from @child
|
|
|
|
* are already gone and we only end the drain sections that came from
|
|
|
|
* elsewhere. */
|
|
|
|
if (child->role->detach) {
|
|
|
|
child->role->detach(child);
|
|
|
|
}
|
2016-05-17 14:51:55 +02:00
|
|
|
if (old_bs->quiesce_counter && child->role->drained_end) {
|
2018-03-28 18:29:18 +02:00
|
|
|
int num = old_bs->quiesce_counter;
|
|
|
|
if (child->role->parent_is_bds) {
|
|
|
|
num -= bdrv_drain_all_count;
|
|
|
|
}
|
|
|
|
assert(num >= 0);
|
|
|
|
for (i = 0; i < num; i++) {
|
2017-12-07 13:03:13 +01:00
|
|
|
child->role->drained_end(child);
|
|
|
|
}
|
2016-05-17 14:51:55 +02:00
|
|
|
}
|
2016-05-23 15:52:26 +02:00
|
|
|
QLIST_REMOVE(child, next_parent);
|
|
|
|
}
|
2016-05-17 14:51:55 +02:00
|
|
|
|
|
|
|
child->bs = new_bs;
|
|
|
|
|
2016-05-23 15:52:26 +02:00
|
|
|
if (new_bs) {
|
|
|
|
QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
|
2016-05-17 14:51:55 +02:00
|
|
|
if (new_bs->quiesce_counter && child->role->drained_begin) {
|
2018-03-28 18:29:18 +02:00
|
|
|
int num = new_bs->quiesce_counter;
|
|
|
|
if (child->role->parent_is_bds) {
|
|
|
|
num -= bdrv_drain_all_count;
|
|
|
|
}
|
|
|
|
assert(num >= 0);
|
|
|
|
for (i = 0; i < num; i++) {
|
2018-06-29 18:01:31 +02:00
|
|
|
bdrv_parent_drained_begin_single(child, true);
|
2017-12-07 13:03:13 +01:00
|
|
|
}
|
2016-05-17 14:51:55 +02:00
|
|
|
}
|
2016-12-15 13:04:20 +01:00
|
|
|
|
2017-12-18 16:05:48 +01:00
|
|
|
/* Attach only after starting new drained sections, so that recursive
|
|
|
|
* drain sections coming from @child don't get an extra .drained_begin
|
|
|
|
* callback. */
|
2017-03-06 13:45:28 +01:00
|
|
|
if (child->role->attach) {
|
|
|
|
child->role->attach(child);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-12-15 13:04:20 +01:00
|
|
|
|
2017-03-08 14:44:07 +01:00
|
|
|
/*
|
|
|
|
* Updates @child to change its reference to point to @new_bs, including
|
|
|
|
* checking and applying the necessary permisson updates both to the old node
|
|
|
|
* and to @new_bs.
|
|
|
|
*
|
|
|
|
* NULL is passed as @new_bs for removing the reference before freeing @child.
|
|
|
|
*
|
|
|
|
* If @new_bs is not NULL, bdrv_check_perm() must be called beforehand, as this
|
|
|
|
* function uses bdrv_set_perm() to update the permissions according to the new
|
|
|
|
* reference that @new_bs gets.
|
|
|
|
*/
|
|
|
|
static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)
|
2017-03-06 13:45:28 +01:00
|
|
|
{
|
|
|
|
BlockDriverState *old_bs = child->bs;
|
|
|
|
uint64_t perm, shared_perm;
|
|
|
|
|
2017-08-03 17:02:57 +02:00
|
|
|
bdrv_replace_child_noperm(child, new_bs);
|
|
|
|
|
2017-03-06 13:45:28 +01:00
|
|
|
if (old_bs) {
|
2016-12-15 13:04:20 +01:00
|
|
|
/* Update permissions for old node. This is guaranteed to succeed
|
|
|
|
* because we're just taking a parent away, so we're loosening
|
|
|
|
* restrictions. */
|
|
|
|
bdrv_get_cumulative_perm(old_bs, &perm, &shared_perm);
|
2017-09-14 14:42:12 +02:00
|
|
|
bdrv_check_perm(old_bs, NULL, perm, shared_perm, NULL, &error_abort);
|
2016-12-15 13:04:20 +01:00
|
|
|
bdrv_set_perm(old_bs, perm, shared_perm);
|
2016-05-23 15:52:26 +02:00
|
|
|
}
|
2016-05-17 14:51:55 +02:00
|
|
|
|
2016-05-23 15:52:26 +02:00
|
|
|
if (new_bs) {
|
2016-12-15 13:04:20 +01:00
|
|
|
bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm);
|
|
|
|
bdrv_set_perm(new_bs, perm, shared_perm);
|
2016-05-23 15:52:26 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-08 13:47:46 +01:00
|
|
|
BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
|
|
|
|
const char *child_name,
|
2016-05-17 14:51:55 +02:00
|
|
|
const BdrvChildRole *child_role,
|
2016-12-14 17:24:36 +01:00
|
|
|
uint64_t perm, uint64_t shared_perm,
|
|
|
|
void *opaque, Error **errp)
|
2015-06-15 11:53:47 +02:00
|
|
|
{
|
2016-12-14 17:24:36 +01:00
|
|
|
BdrvChild *child;
|
|
|
|
int ret;
|
|
|
|
|
2017-09-14 14:42:12 +02:00
|
|
|
ret = bdrv_check_update_perm(child_bs, NULL, perm, shared_perm, NULL, errp);
|
2016-12-14 17:24:36 +01:00
|
|
|
if (ret < 0) {
|
2016-12-15 13:04:20 +01:00
|
|
|
bdrv_abort_perm_update(child_bs);
|
2016-12-14 17:24:36 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
child = g_new(BdrvChild, 1);
|
2015-06-15 11:53:47 +02:00
|
|
|
*child = (BdrvChild) {
|
2016-12-14 17:24:36 +01:00
|
|
|
.bs = NULL,
|
|
|
|
.name = g_strdup(child_name),
|
|
|
|
.role = child_role,
|
|
|
|
.perm = perm,
|
|
|
|
.shared_perm = shared_perm,
|
|
|
|
.opaque = opaque,
|
2015-06-15 11:53:47 +02:00
|
|
|
};
|
|
|
|
|
2016-12-15 13:04:20 +01:00
|
|
|
/* This performs the matching bdrv_set_perm() for the above check. */
|
2017-03-08 14:44:07 +01:00
|
|
|
bdrv_replace_child(child, child_bs);
|
2015-06-15 13:24:19 +02:00
|
|
|
|
|
|
|
return child;
|
2015-06-15 11:53:47 +02:00
|
|
|
}
|
|
|
|
|
2016-05-10 09:36:38 +02:00
|
|
|
BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
|
|
|
|
BlockDriverState *child_bs,
|
|
|
|
const char *child_name,
|
2016-12-20 22:21:17 +01:00
|
|
|
const BdrvChildRole *child_role,
|
|
|
|
Error **errp)
|
2016-03-08 13:47:46 +01:00
|
|
|
{
|
2016-12-14 17:24:36 +01:00
|
|
|
BdrvChild *child;
|
2016-12-20 15:51:12 +01:00
|
|
|
uint64_t perm, shared_perm;
|
|
|
|
|
|
|
|
bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
|
|
|
|
|
|
|
|
assert(parent_bs->drv);
|
2017-04-07 08:54:10 +02:00
|
|
|
assert(bdrv_get_aio_context(parent_bs) == bdrv_get_aio_context(child_bs));
|
2017-09-14 12:47:11 +02:00
|
|
|
bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
|
2017-05-02 18:35:38 +02:00
|
|
|
perm, shared_perm, &perm, &shared_perm);
|
2016-12-14 17:24:36 +01:00
|
|
|
|
|
|
|
child = bdrv_root_attach_child(child_bs, child_name, child_role,
|
2016-12-20 15:51:12 +01:00
|
|
|
perm, shared_perm, parent_bs, errp);
|
2016-12-14 17:24:36 +01:00
|
|
|
if (child == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-03-08 13:47:46 +01:00
|
|
|
QLIST_INSERT_HEAD(&parent_bs->children, child, next);
|
|
|
|
return child;
|
|
|
|
}
|
|
|
|
|
2015-09-15 11:58:23 +02:00
|
|
|
static void bdrv_detach_child(BdrvChild *child)
|
2015-06-15 13:51:04 +02:00
|
|
|
{
|
2016-03-08 13:47:46 +01:00
|
|
|
if (child->next.le_prev) {
|
|
|
|
QLIST_REMOVE(child, next);
|
|
|
|
child->next.le_prev = NULL;
|
|
|
|
}
|
2016-05-23 15:52:26 +02:00
|
|
|
|
2017-03-08 14:44:07 +01:00
|
|
|
bdrv_replace_child(child, NULL);
|
2016-05-23 15:52:26 +02:00
|
|
|
|
2015-04-27 13:46:22 +02:00
|
|
|
g_free(child->name);
|
2015-06-15 13:51:04 +02:00
|
|
|
g_free(child);
|
|
|
|
}
|
|
|
|
|
2016-03-08 13:47:46 +01:00
|
|
|
void bdrv_root_unref_child(BdrvChild *child)
|
2015-06-15 13:51:04 +02:00
|
|
|
{
|
2015-10-13 14:09:44 +02:00
|
|
|
BlockDriverState *child_bs;
|
|
|
|
|
2016-03-08 13:47:46 +01:00
|
|
|
child_bs = child->bs;
|
|
|
|
bdrv_detach_child(child);
|
|
|
|
bdrv_unref(child_bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
|
|
|
|
{
|
2015-10-13 14:09:44 +02:00
|
|
|
if (child == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
2015-06-15 13:51:04 +02:00
|
|
|
|
|
|
|
if (child->bs->inherits_from == parent) {
|
2016-12-16 18:52:37 +01:00
|
|
|
BdrvChild *c;
|
|
|
|
|
|
|
|
/* Remove inherits_from only when the last reference between parent and
|
|
|
|
* child->bs goes away. */
|
|
|
|
QLIST_FOREACH(c, &parent->children, next) {
|
|
|
|
if (c != child && c->bs == child->bs) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (c == NULL) {
|
|
|
|
child->bs->inherits_from = NULL;
|
|
|
|
}
|
2015-06-15 13:51:04 +02:00
|
|
|
}
|
|
|
|
|
2016-03-08 13:47:46 +01:00
|
|
|
bdrv_root_unref_child(child);
|
2015-06-15 13:51:04 +02:00
|
|
|
}
|
|
|
|
|
2016-02-24 15:13:35 +01:00
|
|
|
|
|
|
|
static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
|
|
|
|
{
|
|
|
|
BdrvChild *c;
|
|
|
|
QLIST_FOREACH(c, &bs->parents, next_parent) {
|
|
|
|
if (c->role->change_media) {
|
|
|
|
c->role->change_media(c, load);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-14 15:33:33 +02:00
|
|
|
/*
|
|
|
|
* Sets the backing file link of a BDS. A new reference is created; callers
|
|
|
|
* which don't need their own reference any more must call bdrv_unref().
|
|
|
|
*/
|
2017-02-17 20:42:32 +01:00
|
|
|
void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
|
|
|
|
Error **errp)
|
2014-05-23 15:29:45 +02:00
|
|
|
{
|
2015-09-14 15:33:33 +02:00
|
|
|
if (backing_hd) {
|
|
|
|
bdrv_ref(backing_hd);
|
|
|
|
}
|
2014-05-23 15:29:45 +02:00
|
|
|
|
2015-06-17 14:55:21 +02:00
|
|
|
if (bs->backing) {
|
2015-09-14 15:33:33 +02:00
|
|
|
bdrv_unref_child(bs, bs->backing);
|
2014-05-23 15:29:47 +02:00
|
|
|
}
|
|
|
|
|
2014-05-23 15:29:45 +02:00
|
|
|
if (!backing_hd) {
|
2015-06-17 14:55:21 +02:00
|
|
|
bs->backing = NULL;
|
2014-05-23 15:29:45 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2017-02-17 20:42:32 +01:00
|
|
|
|
2016-12-20 22:21:17 +01:00
|
|
|
bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
|
2017-02-17 20:42:32 +01:00
|
|
|
errp);
|
|
|
|
if (!bs->backing) {
|
|
|
|
bdrv_unref(backing_hd);
|
|
|
|
}
|
2014-05-23 15:29:47 +02:00
|
|
|
|
2017-03-09 11:45:39 +01:00
|
|
|
bdrv_refresh_filename(bs);
|
|
|
|
|
2014-05-23 15:29:45 +02:00
|
|
|
out:
|
2014-07-16 17:48:16 +02:00
|
|
|
bdrv_refresh_limits(bs, NULL);
|
2014-05-23 15:29:45 +02:00
|
|
|
}
|
|
|
|
|
2013-03-28 15:29:24 +01:00
|
|
|
/*
|
|
|
|
* Opens the backing file for a BlockDriverState if not yet open
|
|
|
|
*
|
2015-01-16 18:23:41 +01:00
|
|
|
* bdref_key specifies the key for the image's BlockdevRef in the options QDict.
|
|
|
|
* That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
|
|
|
|
* itself, all options starting with "${bdref_key}." are considered part of the
|
|
|
|
* BlockdevRef.
|
|
|
|
*
|
|
|
|
* TODO Can this be unified with bdrv_open_image()?
|
2013-03-28 15:29:24 +01:00
|
|
|
*/
|
2015-01-16 18:23:41 +01:00
|
|
|
int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
|
|
|
|
const char *bdref_key, Error **errp)
|
2012-10-18 16:49:17 +02:00
|
|
|
{
|
2014-04-22 17:05:27 +02:00
|
|
|
char *backing_filename = g_malloc0(PATH_MAX);
|
2015-01-16 18:23:41 +01:00
|
|
|
char *bdref_key_dot;
|
|
|
|
const char *reference = NULL;
|
2014-04-25 13:27:34 +02:00
|
|
|
int ret = 0;
|
2014-05-23 15:29:45 +02:00
|
|
|
BlockDriverState *backing_hd;
|
2015-01-16 18:23:41 +01:00
|
|
|
QDict *options;
|
|
|
|
QDict *tmp_parent_options = NULL;
|
2013-09-05 14:45:29 +02:00
|
|
|
Error *local_err = NULL;
|
2012-10-18 16:49:17 +02:00
|
|
|
|
2015-06-17 14:55:21 +02:00
|
|
|
if (bs->backing != NULL) {
|
2014-04-22 17:05:27 +02:00
|
|
|
goto free_exit;
|
2012-10-18 16:49:17 +02:00
|
|
|
}
|
|
|
|
|
2013-03-28 15:29:24 +01:00
|
|
|
/* NULL means an empty set of options */
|
2015-01-16 18:23:41 +01:00
|
|
|
if (parent_options == NULL) {
|
|
|
|
tmp_parent_options = qdict_new();
|
|
|
|
parent_options = tmp_parent_options;
|
2013-03-28 15:29:24 +01:00
|
|
|
}
|
|
|
|
|
2012-10-18 16:49:17 +02:00
|
|
|
bs->open_flags &= ~BDRV_O_NO_BACKING;
|
2015-01-16 18:23:41 +01:00
|
|
|
|
|
|
|
bdref_key_dot = g_strdup_printf("%s.", bdref_key);
|
|
|
|
qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
|
|
|
|
g_free(bdref_key_dot);
|
|
|
|
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/*
|
|
|
|
* Caution: while qdict_get_try_str() is fine, getting non-string
|
|
|
|
* types would require more care. When @parent_options come from
|
|
|
|
* -blockdev or blockdev_add, its members are typed according to
|
|
|
|
* the QAPI schema, but when they come from -drive, they're all
|
|
|
|
* QString.
|
|
|
|
*/
|
2015-01-16 18:23:41 +01:00
|
|
|
reference = qdict_get_try_str(parent_options, bdref_key);
|
|
|
|
if (reference || qdict_haskey(options, "file.filename")) {
|
2013-04-12 20:27:07 +02:00
|
|
|
backing_filename[0] = '\0';
|
|
|
|
} else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(options);
|
2014-04-22 17:05:27 +02:00
|
|
|
goto free_exit;
|
2013-09-22 14:05:06 +02:00
|
|
|
} else {
|
2014-11-26 17:20:26 +01:00
|
|
|
bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
|
|
|
|
&local_err);
|
|
|
|
if (local_err) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
error_propagate(errp, local_err);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(options);
|
2014-11-26 17:20:26 +01:00
|
|
|
goto free_exit;
|
|
|
|
}
|
2012-10-18 16:49:17 +02:00
|
|
|
}
|
|
|
|
|
2014-06-04 15:09:35 +02:00
|
|
|
if (!bs->drv || !bs->drv->supports_backing) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
error_setg(errp, "Driver doesn't support backing files");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(options);
|
2014-06-04 15:09:35 +02:00
|
|
|
goto free_exit;
|
|
|
|
}
|
|
|
|
|
block: don't add 'driver' to options when referring to backing via node name
When referring to a backing file of an image via node name
bdrv_open_backing_file would add the 'driver' option to the option list
filling it with the backing format driver. This breaks construction of
the backing chain via -blockdev, as bdrv_open_inherit reports an error
if both 'reference' and 'options' are provided.
$ qemu-img create -f raw /tmp/backing.raw 64M
$ qemu-img create -f qcow2 -F raw -b /tmp/backing.raw /tmp/test.qcow2
$ qemu-system-x86_64 \
-blockdev driver=file,filename=/tmp/backing.raw,node-name=backing \
-blockdev driver=qcow2,file.driver=file,file.filename=/tmp/test.qcow2,node-name=root,backing=backing
qemu-system-x86_64: -blockdev driver=qcow2,file.driver=file,file.filename=/tmp/test.qcow2,node-name=root,backing=backing: Could not open backing file: Cannot reference an existing block device with additional options or a new filename
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-10-12 16:14:10 +02:00
|
|
|
if (!reference &&
|
|
|
|
bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(options, "driver", bs->backing_format);
|
2012-10-18 16:49:17 +02:00
|
|
|
}
|
|
|
|
|
2016-05-17 16:41:31 +02:00
|
|
|
backing_hd = bdrv_open_inherit(*backing_filename ? backing_filename : NULL,
|
|
|
|
reference, options, 0, bs, &child_backing,
|
|
|
|
errp);
|
|
|
|
if (!backing_hd) {
|
2012-10-18 16:49:17 +02:00
|
|
|
bs->open_flags |= BDRV_O_NO_BACKING;
|
error: Use error_prepend() where it makes obvious sense
Done with this Coccinelle semantic patch
@@
expression FMT, E1, E2;
expression list ARGS;
@@
- error_setg(E1, FMT, ARGS, error_get_pretty(E2));
+ error_propagate(E1, E2);/*###*/
+ error_prepend(E1, FMT/*@@@*/, ARGS);
followed by manual cleanup, first because I can't figure out how to
make Coccinelle transform strings, and second to get rid of now
superfluous error_propagate().
We now use or propagate the original error whole instead of just its
message obtained with error_get_pretty(). This avoids suppressing its
hint (see commit 50b7b00), but I can't see how the errors touched in
this commit could come with hints. It also improves the message
printed with &error_abort when we screw up (see commit 1e9b65b).
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2015-12-18 16:35:15 +01:00
|
|
|
error_prepend(errp, "Could not open backing file: ");
|
2016-05-17 16:41:31 +02:00
|
|
|
ret = -EINVAL;
|
2014-04-22 17:05:27 +02:00
|
|
|
goto free_exit;
|
2012-10-18 16:49:17 +02:00
|
|
|
}
|
2017-06-26 13:04:24 +02:00
|
|
|
bdrv_set_aio_context(backing_hd, bdrv_get_aio_context(bs));
|
2015-06-15 11:53:47 +02:00
|
|
|
|
2015-09-14 15:33:33 +02:00
|
|
|
/* Hook up the backing file link; drop our reference, bs owns the
|
|
|
|
* backing_hd reference now */
|
2017-02-17 20:42:32 +01:00
|
|
|
bdrv_set_backing_hd(bs, backing_hd, &local_err);
|
2015-09-14 15:33:33 +02:00
|
|
|
bdrv_unref(backing_hd);
|
2017-02-17 20:42:32 +01:00
|
|
|
if (local_err) {
|
2017-03-17 02:56:30 +01:00
|
|
|
error_propagate(errp, local_err);
|
2017-02-17 20:42:32 +01:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto free_exit;
|
|
|
|
}
|
2014-01-08 20:43:25 +01:00
|
|
|
|
2015-01-16 18:23:41 +01:00
|
|
|
qdict_del(parent_options, bdref_key);
|
|
|
|
|
2014-04-22 17:05:27 +02:00
|
|
|
free_exit:
|
|
|
|
g_free(backing_filename);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(tmp_parent_options);
|
2014-04-22 17:05:27 +02:00
|
|
|
return ret;
|
2012-10-18 16:49:17 +02:00
|
|
|
}
|
|
|
|
|
2017-02-17 17:43:59 +01:00
|
|
|
static BlockDriverState *
|
|
|
|
bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
|
|
|
|
BlockDriverState *parent, const BdrvChildRole *child_role,
|
|
|
|
bool allow_none, Error **errp)
|
2013-12-20 19:28:11 +01:00
|
|
|
{
|
2017-02-17 17:43:59 +01:00
|
|
|
BlockDriverState *bs = NULL;
|
2013-12-20 19:28:11 +01:00
|
|
|
QDict *image_options;
|
|
|
|
char *bdref_key_dot;
|
|
|
|
const char *reference;
|
|
|
|
|
2015-06-15 11:53:47 +02:00
|
|
|
assert(child_role != NULL);
|
2014-02-18 18:33:05 +01:00
|
|
|
|
2013-12-20 19:28:11 +01:00
|
|
|
bdref_key_dot = g_strdup_printf("%s.", bdref_key);
|
|
|
|
qdict_extract_subqdict(options, &image_options, bdref_key_dot);
|
|
|
|
g_free(bdref_key_dot);
|
|
|
|
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/*
|
|
|
|
* Caution: while qdict_get_try_str() is fine, getting non-string
|
|
|
|
* types would require more care. When @options come from
|
|
|
|
* -blockdev or blockdev_add, its members are typed according to
|
|
|
|
* the QAPI schema, but when they come from -drive, they're all
|
|
|
|
* QString.
|
|
|
|
*/
|
2013-12-20 19:28:11 +01:00
|
|
|
reference = qdict_get_try_str(options, bdref_key);
|
|
|
|
if (!filename && !reference && !qdict_size(image_options)) {
|
2015-06-15 13:24:19 +02:00
|
|
|
if (!allow_none) {
|
2013-12-20 19:28:11 +01:00
|
|
|
error_setg(errp, "A block device must be specified for \"%s\"",
|
|
|
|
bdref_key);
|
|
|
|
}
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(image_options);
|
2013-12-20 19:28:11 +01:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2016-05-17 16:41:31 +02:00
|
|
|
bs = bdrv_open_inherit(filename, reference, image_options, 0,
|
|
|
|
parent, child_role, errp);
|
|
|
|
if (!bs) {
|
2015-06-15 11:53:47 +02:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2013-12-20 19:28:11 +01:00
|
|
|
done:
|
|
|
|
qdict_del(options, bdref_key);
|
2017-02-17 17:43:59 +01:00
|
|
|
return bs;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Opens a disk image whose options are given as BlockdevRef in another block
|
|
|
|
* device's options.
|
|
|
|
*
|
|
|
|
* If allow_none is true, no image will be opened if filename is false and no
|
|
|
|
* BlockdevRef is given. NULL will be returned, but errp remains unset.
|
|
|
|
*
|
|
|
|
* bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
|
|
|
|
* That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
|
|
|
|
* itself, all options starting with "${bdref_key}." are considered part of the
|
|
|
|
* BlockdevRef.
|
|
|
|
*
|
|
|
|
* The BlockdevRef will be removed from the options QDict.
|
|
|
|
*/
|
|
|
|
BdrvChild *bdrv_open_child(const char *filename,
|
|
|
|
QDict *options, const char *bdref_key,
|
|
|
|
BlockDriverState *parent,
|
|
|
|
const BdrvChildRole *child_role,
|
|
|
|
bool allow_none, Error **errp)
|
|
|
|
{
|
2016-12-20 22:21:17 +01:00
|
|
|
BdrvChild *c;
|
2017-02-17 17:43:59 +01:00
|
|
|
BlockDriverState *bs;
|
|
|
|
|
|
|
|
bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,
|
|
|
|
allow_none, errp);
|
|
|
|
if (bs == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-12-20 22:21:17 +01:00
|
|
|
c = bdrv_attach_child(parent, bs, bdref_key, child_role, errp);
|
|
|
|
if (!c) {
|
|
|
|
bdrv_unref(bs);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return c;
|
2015-06-15 13:24:19 +02:00
|
|
|
}
|
|
|
|
|
2018-01-10 15:52:33 +01:00
|
|
|
/* TODO Future callers may need to specify parent/child_role in order for
|
|
|
|
* option inheritance to work. Existing callers use it for the root node. */
|
|
|
|
BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = NULL;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
QObject *obj = NULL;
|
|
|
|
QDict *qdict = NULL;
|
|
|
|
const char *reference = NULL;
|
|
|
|
Visitor *v = NULL;
|
|
|
|
|
|
|
|
if (ref->type == QTYPE_QSTRING) {
|
|
|
|
reference = ref->u.reference;
|
|
|
|
} else {
|
|
|
|
BlockdevOptions *options = &ref->u.definition;
|
|
|
|
assert(ref->type == QTYPE_QDICT);
|
|
|
|
|
|
|
|
v = qobject_output_visitor_new(&obj);
|
|
|
|
visit_type_BlockdevOptions(v, NULL, &options, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
visit_complete(v, &obj);
|
|
|
|
|
2018-02-24 16:40:29 +01:00
|
|
|
qdict = qobject_to(QDict, obj);
|
2018-01-10 15:52:33 +01:00
|
|
|
qdict_flatten(qdict);
|
|
|
|
|
|
|
|
/* bdrv_open_inherit() defaults to the values in bdrv_flags (for
|
|
|
|
* compatibility with other callers) rather than what we want as the
|
|
|
|
* real defaults. Apply the defaults here instead. */
|
|
|
|
qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
|
|
|
|
qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
|
|
|
|
qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off");
|
block: Add auto-read-only option
If a management application builds the block graph node by node, the
protocol layer doesn't inherit its read-only option from the format
layer any more, so it must be set explicitly.
Backing files should work on read-only storage, but at the same time, a
block job like commit should be able to reopen them read-write if they
are on read-write storage. However, without option inheritance, reopen
only changes the read-only option for the root node (typically the
format layer), but not the protocol layer, so reopening fails (the
format layer wants to get write permissions, but the protocol layer is
still read-only).
A simple workaround for the problem in the management tool would be to
open the protocol layer always read-write and to make only the format
layer read-only for backing files. However, sometimes the file is
actually stored on read-only storage and we don't know whether the image
can be opened read-write (for example, for NBD it depends on the server
we're trying to connect to). This adds an option that makes QEMU try to
open the image read-write, but allows it to degrade to a read-only mode
without returning an error.
The documentation for this option is consciously phrased in a way that
allows QEMU to switch to a better model eventually: Instead of trying
when the image is first opened, making the read-only flag dynamic and
changing it automatically whenever the first BLK_PERM_WRITE user is
attached or the last one is detached would be much more useful
behaviour.
Unfortunately, this more useful behaviour is also a lot harder to
implement, and libvirt needs a solution now before it can switch to
-blockdev, so let's start with this easier approach for now.
Instead of adding a new auto-read-only option, turning the existing
read-only into an enum (with a bool alternate for compatibility) was
considered, but it complicated the implementation to the point that it
didn't seem to be worth it.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2018-10-05 18:57:40 +02:00
|
|
|
qdict_set_default_str(qdict, BDRV_OPT_AUTO_READ_ONLY, "off");
|
|
|
|
|
2018-01-10 15:52:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, errp);
|
|
|
|
obj = NULL;
|
|
|
|
|
|
|
|
fail:
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(obj);
|
2018-01-10 15:52:33 +01:00
|
|
|
visit_free(v);
|
|
|
|
return bs;
|
|
|
|
}
|
|
|
|
|
block: Let bdrv_open_inherit() return the snapshot
If bdrv_open_inherit() creates a snapshot BDS and *pbs is NULL, that
snapshot BDS should be returned instead of the BDS under it.
This has worked so far because (nearly) all users of BDRV_O_SNAPSHOT use
blk_new_open() to create the BDS tree. bdrv_append() (which is called by
bdrv_append_temp_snapshot()) redirects pointers from parents (i.e. the
BB in this case) to the newly appended child (i.e. the overlay),
therefore, while bdrv_open_inherit() did not return the root BDS, the BB
still pointed to it.
The only instance where BDRV_O_SNAPSHOT is used but blk_new_open() is
not is in blockdev_init() if no BDS tree is created, and instead
blk_new() is used and the flags are stored in the BB root state.
However, qmp_blockdev_change_medium() filters the BDRV_O_SNAPSHOT flag
before invoking bdrv_open(), so it will not have any effect.
In any case, it would be nicer if bdrv_open_inherit() could just always
return the root of the BDS tree that has been created.
To this end, bdrv_append_temp_snapshot() now returns the snapshot BDS
instead of just appending it on top of the snapshotted BDS. Also, it
calls bdrv_ref() before bdrv_append() (which bdrv_open_inherit() has to
undo if not returning the overlay).
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-05-17 16:41:27 +02:00
|
|
|
static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
|
|
|
|
int flags,
|
|
|
|
QDict *snapshot_options,
|
|
|
|
Error **errp)
|
2014-04-03 12:09:34 +02:00
|
|
|
{
|
|
|
|
/* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
|
2014-04-22 17:05:27 +02:00
|
|
|
char *tmp_filename = g_malloc0(PATH_MAX + 1);
|
2014-04-03 12:09:34 +02:00
|
|
|
int64_t total_size;
|
2014-06-05 11:20:51 +02:00
|
|
|
QemuOpts *opts = NULL;
|
2017-04-27 23:58:18 +02:00
|
|
|
BlockDriverState *bs_snapshot = NULL;
|
2017-02-20 12:46:42 +01:00
|
|
|
Error *local_err = NULL;
|
2014-04-03 12:09:34 +02:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* if snapshot, we create a temporary backing file and open it
|
|
|
|
instead of opening 'filename' directly */
|
|
|
|
|
|
|
|
/* Get the required size from the image */
|
2014-04-04 17:07:19 +02:00
|
|
|
total_size = bdrv_getlength(bs);
|
|
|
|
if (total_size < 0) {
|
|
|
|
error_setg_errno(errp, -total_size, "Could not get image size");
|
2014-04-22 17:05:27 +02:00
|
|
|
goto out;
|
2014-04-04 17:07:19 +02:00
|
|
|
}
|
2014-04-03 12:09:34 +02:00
|
|
|
|
|
|
|
/* Create the temporary image */
|
2014-04-22 17:05:27 +02:00
|
|
|
ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
|
2014-04-03 12:09:34 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
error_setg_errno(errp, -ret, "Could not get temporary filename");
|
2014-04-22 17:05:27 +02:00
|
|
|
goto out;
|
2014-04-03 12:09:34 +02:00
|
|
|
}
|
|
|
|
|
2014-12-02 18:32:42 +01:00
|
|
|
opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
|
2014-06-05 11:21:11 +02:00
|
|
|
&error_abort);
|
2015-02-12 16:46:36 +01:00
|
|
|
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
|
error: Use error_prepend() where it makes obvious sense
Done with this Coccinelle semantic patch
@@
expression FMT, E1, E2;
expression list ARGS;
@@
- error_setg(E1, FMT, ARGS, error_get_pretty(E2));
+ error_propagate(E1, E2);/*###*/
+ error_prepend(E1, FMT/*@@@*/, ARGS);
followed by manual cleanup, first because I can't figure out how to
make Coccinelle transform strings, and second to get rid of now
superfluous error_propagate().
We now use or propagate the original error whole instead of just its
message obtained with error_get_pretty(). This avoids suppressing its
hint (see commit 50b7b00), but I can't see how the errors touched in
this commit could come with hints. It also improves the message
printed with &error_abort when we screw up (see commit 1e9b65b).
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2015-12-18 16:35:15 +01:00
|
|
|
ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
|
2014-06-05 11:20:51 +02:00
|
|
|
qemu_opts_del(opts);
|
2014-04-03 12:09:34 +02:00
|
|
|
if (ret < 0) {
|
error: Use error_prepend() where it makes obvious sense
Done with this Coccinelle semantic patch
@@
expression FMT, E1, E2;
expression list ARGS;
@@
- error_setg(E1, FMT, ARGS, error_get_pretty(E2));
+ error_propagate(E1, E2);/*###*/
+ error_prepend(E1, FMT/*@@@*/, ARGS);
followed by manual cleanup, first because I can't figure out how to
make Coccinelle transform strings, and second to get rid of now
superfluous error_propagate().
We now use or propagate the original error whole instead of just its
message obtained with error_get_pretty(). This avoids suppressing its
hint (see commit 50b7b00), but I can't see how the errors touched in
this commit could come with hints. It also improves the message
printed with &error_abort when we screw up (see commit 1e9b65b).
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2015-12-18 16:35:15 +01:00
|
|
|
error_prepend(errp, "Could not create temporary overlay '%s': ",
|
|
|
|
tmp_filename);
|
2014-04-22 17:05:27 +02:00
|
|
|
goto out;
|
2014-04-03 12:09:34 +02:00
|
|
|
}
|
|
|
|
|
2016-03-07 13:02:15 +01:00
|
|
|
/* Prepare options QDict for the temporary file */
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(snapshot_options, "file.driver", "file");
|
|
|
|
qdict_put_str(snapshot_options, "file.filename", tmp_filename);
|
|
|
|
qdict_put_str(snapshot_options, "driver", "qcow2");
|
2014-04-03 12:09:34 +02:00
|
|
|
|
2016-05-17 16:41:31 +02:00
|
|
|
bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
|
2016-03-07 13:02:15 +01:00
|
|
|
snapshot_options = NULL;
|
2016-05-17 16:41:31 +02:00
|
|
|
if (!bs_snapshot) {
|
2014-04-22 17:05:27 +02:00
|
|
|
goto out;
|
2014-04-03 12:09:34 +02:00
|
|
|
}
|
|
|
|
|
2017-04-27 23:58:18 +02:00
|
|
|
/* bdrv_append() consumes a strong reference to bs_snapshot
|
|
|
|
* (i.e. it will call bdrv_unref() on it) even on error, so in
|
|
|
|
* order to be able to return one, we have to increase
|
|
|
|
* bs_snapshot's refcount here */
|
block: Let bdrv_open_inherit() return the snapshot
If bdrv_open_inherit() creates a snapshot BDS and *pbs is NULL, that
snapshot BDS should be returned instead of the BDS under it.
This has worked so far because (nearly) all users of BDRV_O_SNAPSHOT use
blk_new_open() to create the BDS tree. bdrv_append() (which is called by
bdrv_append_temp_snapshot()) redirects pointers from parents (i.e. the
BB in this case) to the newly appended child (i.e. the overlay),
therefore, while bdrv_open_inherit() did not return the root BDS, the BB
still pointed to it.
The only instance where BDRV_O_SNAPSHOT is used but blk_new_open() is
not is in blockdev_init() if no BDS tree is created, and instead
blk_new() is used and the flags are stored in the BB root state.
However, qmp_blockdev_change_medium() filters the BDRV_O_SNAPSHOT flag
before invoking bdrv_open(), so it will not have any effect.
In any case, it would be nicer if bdrv_open_inherit() could just always
return the root of the BDS tree that has been created.
To this end, bdrv_append_temp_snapshot() now returns the snapshot BDS
instead of just appending it on top of the snapshotted BDS. Also, it
calls bdrv_ref() before bdrv_append() (which bdrv_open_inherit() has to
undo if not returning the overlay).
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-05-17 16:41:27 +02:00
|
|
|
bdrv_ref(bs_snapshot);
|
2017-02-20 12:46:42 +01:00
|
|
|
bdrv_append(bs_snapshot, bs, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
2017-04-27 23:58:18 +02:00
|
|
|
bs_snapshot = NULL;
|
2017-02-20 12:46:42 +01:00
|
|
|
goto out;
|
|
|
|
}
|
2014-04-22 17:05:27 +02:00
|
|
|
|
|
|
|
out:
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(snapshot_options);
|
2014-04-22 17:05:27 +02:00
|
|
|
g_free(tmp_filename);
|
2017-04-27 23:58:18 +02:00
|
|
|
return bs_snapshot;
|
2014-04-03 12:09:34 +02:00
|
|
|
}
|
|
|
|
|
2010-04-12 16:37:13 +02:00
|
|
|
/*
|
|
|
|
* Opens a disk image (raw, qcow2, vmdk, ...)
|
2013-03-15 10:35:02 +01:00
|
|
|
*
|
|
|
|
* options is a QDict of options to pass to the block drivers, or NULL for an
|
|
|
|
* empty set of options. The reference to the QDict belongs to the block layer
|
|
|
|
* after the call (even on failure), so if the caller intends to reuse the
|
2018-04-19 17:01:43 +02:00
|
|
|
* dictionary, it needs to use qobject_ref() before calling bdrv_open.
|
2014-02-18 18:33:05 +01:00
|
|
|
*
|
|
|
|
* If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
|
|
|
|
* If it is not NULL, the referenced BDS will be reused.
|
2014-02-18 18:33:06 +01:00
|
|
|
*
|
|
|
|
* The reference parameter may be used to specify an existing block device which
|
|
|
|
* should be opened. If specified, neither options nor a filename may be given,
|
|
|
|
* nor can an existing BDS be reused (that is, *pbs has to be NULL).
|
2010-04-12 16:37:13 +02:00
|
|
|
*/
|
2016-05-17 16:41:31 +02:00
|
|
|
static BlockDriverState *bdrv_open_inherit(const char *filename,
|
|
|
|
const char *reference,
|
|
|
|
QDict *options, int flags,
|
|
|
|
BlockDriverState *parent,
|
|
|
|
const BdrvChildRole *child_role,
|
|
|
|
Error **errp)
|
2004-08-01 23:59:26 +02:00
|
|
|
{
|
2010-04-12 16:37:13 +02:00
|
|
|
int ret;
|
2017-02-17 18:39:24 +01:00
|
|
|
BlockBackend *file = NULL;
|
2015-06-16 14:19:22 +02:00
|
|
|
BlockDriverState *bs;
|
2015-08-26 19:47:50 +02:00
|
|
|
BlockDriver *drv = NULL;
|
2018-06-29 13:37:00 +02:00
|
|
|
BdrvChild *child;
|
2013-07-09 11:09:02 +02:00
|
|
|
const char *drvname;
|
2015-10-26 13:27:15 +01:00
|
|
|
const char *backing;
|
2013-09-05 14:45:29 +02:00
|
|
|
Error *local_err = NULL;
|
2016-03-07 13:02:15 +01:00
|
|
|
QDict *snapshot_options = NULL;
|
2014-05-06 12:11:42 +02:00
|
|
|
int snapshot_flags = 0;
|
2005-04-28 23:09:32 +02:00
|
|
|
|
2015-04-08 13:43:47 +02:00
|
|
|
assert(!child_role || !flags);
|
|
|
|
assert(!child_role == !parent);
|
2014-02-18 18:33:05 +01:00
|
|
|
|
2014-02-18 18:33:06 +01:00
|
|
|
if (reference) {
|
|
|
|
bool options_non_empty = options ? qdict_size(options) : false;
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(options);
|
2014-02-18 18:33:06 +01:00
|
|
|
|
|
|
|
if (filename || options_non_empty) {
|
|
|
|
error_setg(errp, "Cannot reference an existing block device with "
|
|
|
|
"additional options or a new filename");
|
2016-05-17 16:41:31 +02:00
|
|
|
return NULL;
|
2014-02-18 18:33:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bs = bdrv_lookup_bs(reference, reference, errp);
|
|
|
|
if (!bs) {
|
2016-05-17 16:41:31 +02:00
|
|
|
return NULL;
|
2014-02-18 18:33:06 +01:00
|
|
|
}
|
2016-04-04 17:11:13 +02:00
|
|
|
|
2014-02-18 18:33:06 +01:00
|
|
|
bdrv_ref(bs);
|
2016-05-17 16:41:31 +02:00
|
|
|
return bs;
|
2014-02-18 18:33:06 +01:00
|
|
|
}
|
|
|
|
|
2016-05-17 16:41:31 +02:00
|
|
|
bs = bdrv_new();
|
2014-02-18 18:33:05 +01:00
|
|
|
|
2013-03-15 10:35:02 +01:00
|
|
|
/* NULL means an empty set of options */
|
|
|
|
if (options == NULL) {
|
|
|
|
options = qdict_new();
|
|
|
|
}
|
|
|
|
|
2015-05-08 16:15:03 +02:00
|
|
|
/* json: syntax counts as explicit options, as if in the QDict */
|
2015-10-29 15:24:41 +01:00
|
|
|
parse_json_protocol(options, &filename, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-05-08 16:15:03 +02:00
|
|
|
bs->explicit_options = qdict_clone_shallow(options);
|
|
|
|
|
2015-04-08 13:43:47 +02:00
|
|
|
if (child_role) {
|
2015-04-09 18:47:50 +02:00
|
|
|
bs->inherits_from = parent;
|
2015-04-29 17:29:39 +02:00
|
|
|
child_role->inherit_options(&flags, options,
|
|
|
|
parent->open_flags, parent->options);
|
2015-04-08 13:43:47 +02:00
|
|
|
}
|
|
|
|
|
2015-10-29 15:24:41 +01:00
|
|
|
ret = bdrv_fill_options(&options, filename, &flags, &local_err);
|
2014-05-26 11:39:55 +02:00
|
|
|
if (local_err) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/*
|
|
|
|
* Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags.
|
|
|
|
* Caution: getting a boolean member of @options requires care.
|
|
|
|
* When @options come from -blockdev or blockdev_add, members are
|
|
|
|
* typed according to the QAPI schema, but when they come from
|
|
|
|
* -drive, they're all QString.
|
|
|
|
*/
|
2016-09-15 16:53:02 +02:00
|
|
|
if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
|
|
|
|
!qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
|
|
|
|
flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
|
|
|
|
} else {
|
|
|
|
flags &= ~BDRV_O_RDWR;
|
2016-09-15 16:53:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & BDRV_O_SNAPSHOT) {
|
|
|
|
snapshot_options = qdict_new();
|
|
|
|
bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
|
|
|
|
flags, options);
|
2016-09-15 16:53:02 +02:00
|
|
|
/* Let bdrv_backing_options() override "read-only" */
|
|
|
|
qdict_del(options, BDRV_OPT_READ_ONLY);
|
2016-09-15 16:53:00 +02:00
|
|
|
bdrv_backing_options(&flags, options, flags, options);
|
|
|
|
}
|
|
|
|
|
2015-04-24 16:38:02 +02:00
|
|
|
bs->open_flags = flags;
|
|
|
|
bs->options = options;
|
|
|
|
options = qdict_clone_shallow(options);
|
|
|
|
|
2014-06-04 14:19:44 +02:00
|
|
|
/* Find the right image format driver */
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/* See cautionary note on accessing @options above */
|
2014-06-04 14:19:44 +02:00
|
|
|
drvname = qdict_get_try_str(options, "driver");
|
|
|
|
if (drvname) {
|
|
|
|
drv = bdrv_find_format(drvname);
|
|
|
|
if (!drv) {
|
|
|
|
error_setg(errp, "Unknown driver: '%s'", drvname);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(drvname || !(flags & BDRV_O_PROTOCOL));
|
|
|
|
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/* See cautionary note on accessing @options above */
|
2015-10-26 13:27:15 +01:00
|
|
|
backing = qdict_get_try_str(options, "backing");
|
2018-02-24 16:40:32 +01:00
|
|
|
if (qobject_to(QNull, qdict_get(options, "backing")) != NULL ||
|
|
|
|
(backing && *backing == '\0'))
|
|
|
|
{
|
2018-02-24 16:40:33 +01:00
|
|
|
if (backing) {
|
|
|
|
warn_report("Use of \"backing\": \"\" is deprecated; "
|
|
|
|
"use \"backing\": null instead");
|
|
|
|
}
|
2015-10-26 13:27:15 +01:00
|
|
|
flags |= BDRV_O_NO_BACKING;
|
|
|
|
qdict_del(options, "backing");
|
|
|
|
}
|
|
|
|
|
2017-02-17 18:39:24 +01:00
|
|
|
/* Open image file without format layer. This BlockBackend is only used for
|
2016-12-16 18:52:37 +01:00
|
|
|
* probing, the block drivers will do their own bdrv_open_child() for the
|
|
|
|
* same BDS, which is why we put the node name back into options. */
|
2014-06-03 16:44:19 +02:00
|
|
|
if ((flags & BDRV_O_PROTOCOL) == 0) {
|
2017-02-17 18:39:24 +01:00
|
|
|
BlockDriverState *file_bs;
|
|
|
|
|
|
|
|
file_bs = bdrv_open_child_bs(filename, options, "file", bs,
|
|
|
|
&child_file, true, &local_err);
|
2015-06-15 14:11:51 +02:00
|
|
|
if (local_err) {
|
2014-06-03 16:44:19 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
2017-02-17 18:39:24 +01:00
|
|
|
if (file_bs != NULL) {
|
2017-11-20 14:59:13 +01:00
|
|
|
/* Not requesting BLK_PERM_CONSISTENT_READ because we're only
|
|
|
|
* looking at the header to guess the image format. This works even
|
|
|
|
* in cases where a guest would not see a consistent state. */
|
|
|
|
file = blk_new(0, BLK_PERM_ALL);
|
2017-01-13 19:02:32 +01:00
|
|
|
blk_insert_bs(file, file_bs, &local_err);
|
2017-02-17 18:39:24 +01:00
|
|
|
bdrv_unref(file_bs);
|
2017-01-13 19:02:32 +01:00
|
|
|
if (local_err) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2017-02-17 18:39:24 +01:00
|
|
|
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
|
2016-12-16 18:52:37 +01:00
|
|
|
}
|
2012-11-12 17:35:27 +01:00
|
|
|
}
|
|
|
|
|
2014-06-04 14:19:44 +02:00
|
|
|
/* Image format probing */
|
raw: Prohibit dangerous writes for probed images
If the user neglects to specify the image format, QEMU probes the
image to guess it automatically, for convenience.
Relying on format probing is insecure for raw images (CVE-2008-2004).
If the guest writes a suitable header to the device, the next probe
will recognize a format chosen by the guest. A malicious guest can
abuse this to gain access to host files, e.g. by crafting a QCOW2
header with backing file /etc/shadow.
Commit 1e72d3b (April 2008) provided -drive parameter format to let
users disable probing. Commit f965509 (March 2009) extended QCOW2 to
optionally store the backing file format, to let users disable backing
file probing. QED has had a flag to suppress probing since the
beginning (2010), set whenever a raw backing file is assigned.
All of these additions that allow to avoid format probing have to be
specified explicitly. The default still allows the attack.
In order to fix this, commit 79368c8 (July 2010) put probed raw images
in a restricted mode, in which they wouldn't be able to overwrite the
first few bytes of the image so that they would identify as a different
image. If a write to the first sector would write one of the signatures
of another driver, qemu would instead zero out the first four bytes.
This patch was later reverted in commit 8b33d9e (September 2010) because
it didn't get the handling of unaligned qiov members right.
Today's block layer that is based on coroutines and has qiov utility
functions makes it much easier to get this functionality right, so this
patch implements it.
The other differences of this patch to the old one are that it doesn't
silently write something different than the guest requested by zeroing
out some bytes (it fails the request instead) and that it doesn't
maintain a list of signatures in the raw driver (it calls the usual
probe function instead).
Note that this change doesn't introduce new breakage for false positive
cases where the guest legitimately writes data into the first sector
that matches the signatures of an image format (e.g. for nested virt):
These cases were broken before, only the failure mode changes from
corruption after the next restart (when the wrong format is probed) to
failing the problematic write request.
Also note that like in the original patch, the restrictions only apply
if the image format has been guessed by probing. Explicitly specifying a
format allows guests to write anything they like.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1416497234-29880-8-git-send-email-kwolf@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-11-20 16:27:12 +01:00
|
|
|
bs->probed = !drv;
|
2014-06-04 14:19:44 +02:00
|
|
|
if (!drv && file) {
|
2016-06-20 18:24:02 +02:00
|
|
|
ret = find_image_format(file, filename, &drv, &local_err);
|
2014-05-27 10:50:29 +02:00
|
|
|
if (ret < 0) {
|
2014-04-11 19:16:36 +02:00
|
|
|
goto fail;
|
2013-12-20 19:28:10 +01:00
|
|
|
}
|
2015-04-24 16:38:02 +02:00
|
|
|
/*
|
|
|
|
* This option update would logically belong in bdrv_fill_options(),
|
|
|
|
* but we first need to open bs->file for the probing to work, while
|
|
|
|
* opening bs->file already requires the (mostly) final set of options
|
|
|
|
* so that cache mode etc. can be inherited.
|
|
|
|
*
|
|
|
|
* Adding the driver later is somewhat ugly, but it's not an option
|
|
|
|
* that would ever be inherited, so it's correct. We just need to make
|
|
|
|
* sure to update both bs->options (which has the full effective
|
|
|
|
* options for bs) and options (which has file.* already removed).
|
|
|
|
*/
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(bs->options, "driver", drv->format_name);
|
|
|
|
qdict_put_str(options, "driver", drv->format_name);
|
2014-06-04 14:19:44 +02:00
|
|
|
} else if (!drv) {
|
2014-05-27 10:50:29 +02:00
|
|
|
error_setg(errp, "Must specify either driver or file");
|
2014-04-11 19:16:36 +02:00
|
|
|
goto fail;
|
2004-08-01 23:59:26 +02:00
|
|
|
}
|
2010-04-12 16:37:13 +02:00
|
|
|
|
block: driver should override flags in bdrv_open()
The BDRV_O_PROTOCOL flag should have an impact only if no driver is
specified explicitly. Therefore, if bdrv_open() is called with an
explicit block driver argument (either through the options QDict or
through the drv parameter) and that block driver is a protocol block
driver, BDRV_O_PROTOCOL should be set; if it is a format block driver,
BDRV_O_PROTOCOL should be unset.
While there was code to unset the flag in case a format block driver
has been selected, it only followed the bdrv_fill_options() function
call whereas the flag in fact needs to be adjusted before it is used
there.
With that change, BDRV_O_PROTOCOL will always be set if the BDS should
be a protocol driver; if the driver has been specified explicitly, the
new code will set it; and bdrv_fill_options() will only "probe" a
protocol driver if BDRV_O_PROTOCOL is set. The probing after
bdrv_fill_options() cannot select a protocol driver.
Thus, bdrv_open_image() to open BDS.file is never called if a protocol
BDS is about to be created. With that change in turn it is impossible to
call bdrv_open_common() with a protocol drv and file != NULL, which
allows us to remove the bdrv_swap() call.
This change breaks a test case in qemu-iotest 051:
"-drive file=t.qcow2,file.driver=qcow2" now works because the explicitly
specified "qcow2" overrides the BDRV_O_PROTOCOL which is automatically
set for the "file" BDS (and the filename is just passed down).
Therefore, this patch removes that test case.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-03-19 19:53:16 +01:00
|
|
|
/* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
|
|
|
|
assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
|
|
|
|
/* file must be NULL if a protocol BDS is about to be created
|
|
|
|
* (the inverse results in an error message from bdrv_open_common()) */
|
|
|
|
assert(!(flags & BDRV_O_PROTOCOL) || !file);
|
|
|
|
|
2010-04-12 16:37:13 +02:00
|
|
|
/* Open the image */
|
2016-01-11 19:07:50 +01:00
|
|
|
ret = bdrv_open_common(bs, file, options, &local_err);
|
2010-04-12 16:37:13 +02:00
|
|
|
if (ret < 0) {
|
2014-04-11 19:16:36 +02:00
|
|
|
goto fail;
|
2010-01-20 18:13:25 +01:00
|
|
|
}
|
|
|
|
|
2016-12-16 18:52:37 +01:00
|
|
|
if (file) {
|
2017-02-17 18:39:24 +01:00
|
|
|
blk_unref(file);
|
2012-11-12 17:35:27 +01:00
|
|
|
file = NULL;
|
|
|
|
}
|
|
|
|
|
2010-04-12 16:37:13 +02:00
|
|
|
/* If there is a backing file, use it */
|
2012-10-18 16:49:17 +02:00
|
|
|
if ((flags & BDRV_O_NO_BACKING) == 0) {
|
2015-01-16 18:23:41 +01:00
|
|
|
ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
|
2010-04-12 16:37:13 +02:00
|
|
|
if (ret < 0) {
|
2013-03-15 10:35:04 +01:00
|
|
|
goto close_and_fail;
|
2010-04-12 16:37:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
block: Remove child references from bs->{options,explicit_options}
Block drivers allow opening their children using a reference to an
existing BlockDriverState. These references remain stored in the
'options' and 'explicit_options' QDicts, but we don't need to keep
them once everything is open.
What is more important, these values can become wrong if the children
change:
$ qemu-img create -f qcow2 hd0.qcow2 10M
$ qemu-img create -f qcow2 hd1.qcow2 10M
$ qemu-img create -f qcow2 hd2.qcow2 10M
$ $QEMU -drive if=none,file=hd0.qcow2,node-name=hd0 \
-drive if=none,file=hd1.qcow2,node-name=hd1,backing=hd0 \
-drive file=hd2.qcow2,node-name=hd2,backing=hd1
After this hd2 has hd1 as its backing file. Now let's remove it using
block_stream:
(qemu) block_stream hd2 0 hd0.qcow2
Now hd0 is the backing file of hd2, but hd2's options QDicts still
contain backing=hd1.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-09-06 11:37:03 +02:00
|
|
|
/* Remove all children options and references
|
|
|
|
* from bs->options and bs->explicit_options */
|
2018-06-29 13:37:00 +02:00
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
char *child_key_dot;
|
|
|
|
child_key_dot = g_strdup_printf("%s.", child->name);
|
|
|
|
qdict_extract_subqdict(bs->explicit_options, NULL, child_key_dot);
|
|
|
|
qdict_extract_subqdict(bs->options, NULL, child_key_dot);
|
block: Remove child references from bs->{options,explicit_options}
Block drivers allow opening their children using a reference to an
existing BlockDriverState. These references remain stored in the
'options' and 'explicit_options' QDicts, but we don't need to keep
them once everything is open.
What is more important, these values can become wrong if the children
change:
$ qemu-img create -f qcow2 hd0.qcow2 10M
$ qemu-img create -f qcow2 hd1.qcow2 10M
$ qemu-img create -f qcow2 hd2.qcow2 10M
$ $QEMU -drive if=none,file=hd0.qcow2,node-name=hd0 \
-drive if=none,file=hd1.qcow2,node-name=hd1,backing=hd0 \
-drive file=hd2.qcow2,node-name=hd2,backing=hd1
After this hd2 has hd1 as its backing file. Now let's remove it using
block_stream:
(qemu) block_stream hd2 0 hd0.qcow2
Now hd0 is the backing file of hd2, but hd2's options QDicts still
contain backing=hd1.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-09-06 11:37:03 +02:00
|
|
|
qdict_del(bs->explicit_options, child->name);
|
|
|
|
qdict_del(bs->options, child->name);
|
2018-06-29 13:37:00 +02:00
|
|
|
g_free(child_key_dot);
|
|
|
|
}
|
|
|
|
|
2014-07-18 20:24:56 +02:00
|
|
|
bdrv_refresh_filename(bs);
|
|
|
|
|
2013-03-15 10:35:04 +01:00
|
|
|
/* Check if any unknown options were used */
|
2017-01-04 15:59:14 +01:00
|
|
|
if (qdict_size(options) != 0) {
|
2013-03-15 10:35:04 +01:00
|
|
|
const QDictEntry *entry = qdict_first(options);
|
2014-02-18 18:33:11 +01:00
|
|
|
if (flags & BDRV_O_PROTOCOL) {
|
|
|
|
error_setg(errp, "Block protocol '%s' doesn't support the option "
|
|
|
|
"'%s'", drv->format_name, entry->key);
|
|
|
|
} else {
|
2016-03-16 19:54:34 +01:00
|
|
|
error_setg(errp,
|
|
|
|
"Block format '%s' does not support the option '%s'",
|
|
|
|
drv->format_name, entry->key);
|
2014-02-18 18:33:11 +01:00
|
|
|
}
|
2013-03-15 10:35:04 +01:00
|
|
|
|
|
|
|
goto close_and_fail;
|
|
|
|
}
|
|
|
|
|
2017-06-23 18:24:16 +02:00
|
|
|
bdrv_parent_cb_change_media(bs, true);
|
2010-04-12 16:37:13 +02:00
|
|
|
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(options);
|
2018-09-06 16:25:41 +02:00
|
|
|
options = NULL;
|
2015-06-18 14:09:57 +02:00
|
|
|
|
|
|
|
/* For snapshot=on, create a temporary qcow2 overlay. bs points to the
|
|
|
|
* temporary snapshot afterwards. */
|
|
|
|
if (snapshot_flags) {
|
block: Let bdrv_open_inherit() return the snapshot
If bdrv_open_inherit() creates a snapshot BDS and *pbs is NULL, that
snapshot BDS should be returned instead of the BDS under it.
This has worked so far because (nearly) all users of BDRV_O_SNAPSHOT use
blk_new_open() to create the BDS tree. bdrv_append() (which is called by
bdrv_append_temp_snapshot()) redirects pointers from parents (i.e. the
BB in this case) to the newly appended child (i.e. the overlay),
therefore, while bdrv_open_inherit() did not return the root BDS, the BB
still pointed to it.
The only instance where BDRV_O_SNAPSHOT is used but blk_new_open() is
not is in blockdev_init() if no BDS tree is created, and instead
blk_new() is used and the flags are stored in the BB root state.
However, qmp_blockdev_change_medium() filters the BDRV_O_SNAPSHOT flag
before invoking bdrv_open(), so it will not have any effect.
In any case, it would be nicer if bdrv_open_inherit() could just always
return the root of the BDS tree that has been created.
To this end, bdrv_append_temp_snapshot() now returns the snapshot BDS
instead of just appending it on top of the snapshotted BDS. Also, it
calls bdrv_ref() before bdrv_append() (which bdrv_open_inherit() has to
undo if not returning the overlay).
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-05-17 16:41:27 +02:00
|
|
|
BlockDriverState *snapshot_bs;
|
|
|
|
snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
|
|
|
|
snapshot_options, &local_err);
|
2016-03-07 13:02:15 +01:00
|
|
|
snapshot_options = NULL;
|
2015-06-18 14:09:57 +02:00
|
|
|
if (local_err) {
|
|
|
|
goto close_and_fail;
|
|
|
|
}
|
2016-05-17 16:41:31 +02:00
|
|
|
/* We are not going to return bs but the overlay on top of it
|
|
|
|
* (snapshot_bs); thus, we have to drop the strong reference to bs
|
|
|
|
* (which we obtained by calling bdrv_new()). bs will not be deleted,
|
|
|
|
* though, because the overlay still has a reference to it. */
|
|
|
|
bdrv_unref(bs);
|
|
|
|
bs = snapshot_bs;
|
2015-06-18 14:09:57 +02:00
|
|
|
}
|
|
|
|
|
2016-05-17 16:41:31 +02:00
|
|
|
return bs;
|
2010-04-12 16:37:13 +02:00
|
|
|
|
2014-04-11 19:16:36 +02:00
|
|
|
fail:
|
2017-02-17 18:39:24 +01:00
|
|
|
blk_unref(file);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(snapshot_options);
|
|
|
|
qobject_unref(bs->explicit_options);
|
|
|
|
qobject_unref(bs->options);
|
|
|
|
qobject_unref(options);
|
2013-03-15 10:35:02 +01:00
|
|
|
bs->options = NULL;
|
2017-07-14 16:35:47 +02:00
|
|
|
bs->explicit_options = NULL;
|
2016-05-17 16:41:31 +02:00
|
|
|
bdrv_unref(bs);
|
2016-06-13 23:57:56 +02:00
|
|
|
error_propagate(errp, local_err);
|
2016-05-17 16:41:31 +02:00
|
|
|
return NULL;
|
2013-03-15 10:35:02 +01:00
|
|
|
|
2013-03-15 10:35:04 +01:00
|
|
|
close_and_fail:
|
2016-05-17 16:41:31 +02:00
|
|
|
bdrv_unref(bs);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(snapshot_options);
|
|
|
|
qobject_unref(options);
|
2016-06-13 23:57:56 +02:00
|
|
|
error_propagate(errp, local_err);
|
2016-05-17 16:41:31 +02:00
|
|
|
return NULL;
|
2010-04-12 16:37:13 +02:00
|
|
|
}
|
|
|
|
|
2016-05-17 16:41:31 +02:00
|
|
|
BlockDriverState *bdrv_open(const char *filename, const char *reference,
|
|
|
|
QDict *options, int flags, Error **errp)
|
2015-04-08 13:43:47 +02:00
|
|
|
{
|
2016-05-17 16:41:31 +02:00
|
|
|
return bdrv_open_inherit(filename, reference, options, flags, NULL,
|
2015-08-26 19:47:50 +02:00
|
|
|
NULL, errp);
|
2015-04-08 13:43:47 +02:00
|
|
|
}
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
/*
|
|
|
|
* Adds a BlockDriverState to a simple queue for an atomic, transactional
|
|
|
|
* reopen of multiple devices.
|
|
|
|
*
|
|
|
|
* bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
|
|
|
|
* already performed, or alternatively may be NULL a new BlockReopenQueue will
|
|
|
|
* be created and initialized. This newly created BlockReopenQueue should be
|
|
|
|
* passed back in for subsequent calls that are intended to be of the same
|
|
|
|
* atomic 'set'.
|
|
|
|
*
|
|
|
|
* bs is the BlockDriverState to add to the reopen queue.
|
|
|
|
*
|
2015-04-10 17:50:50 +02:00
|
|
|
* options contains the changed options for the associated bs
|
|
|
|
* (the BlockReopenQueue takes ownership)
|
|
|
|
*
|
2012-09-20 21:13:19 +02:00
|
|
|
* flags contains the open flags for the associated bs
|
|
|
|
*
|
|
|
|
* returns a pointer to bs_queue, which is either the newly allocated
|
|
|
|
* bs_queue, or the existing bs_queue being used.
|
|
|
|
*
|
2017-12-06 20:24:44 +01:00
|
|
|
* bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple().
|
2012-09-20 21:13:19 +02:00
|
|
|
*/
|
2015-05-08 17:07:31 +02:00
|
|
|
static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
|
|
|
|
BlockDriverState *bs,
|
|
|
|
QDict *options,
|
|
|
|
int flags,
|
|
|
|
const BdrvChildRole *role,
|
|
|
|
QDict *parent_options,
|
|
|
|
int parent_flags)
|
2012-09-20 21:13:19 +02:00
|
|
|
{
|
|
|
|
assert(bs != NULL);
|
|
|
|
|
|
|
|
BlockReopenQueueEntry *bs_entry;
|
2015-04-09 18:54:04 +02:00
|
|
|
BdrvChild *child;
|
2015-05-08 16:15:03 +02:00
|
|
|
QDict *old_options, *explicit_options;
|
2015-04-09 18:54:04 +02:00
|
|
|
|
2017-12-06 20:24:44 +01:00
|
|
|
/* Make sure that the caller remembered to use a drained section. This is
|
|
|
|
* important to avoid graph changes between the recursive queuing here and
|
|
|
|
* bdrv_reopen_multiple(). */
|
|
|
|
assert(bs->quiesce_counter > 0);
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
if (bs_queue == NULL) {
|
|
|
|
bs_queue = g_new0(BlockReopenQueue, 1);
|
|
|
|
QSIMPLEQ_INIT(bs_queue);
|
|
|
|
}
|
|
|
|
|
2015-04-10 17:50:50 +02:00
|
|
|
if (!options) {
|
|
|
|
options = qdict_new();
|
|
|
|
}
|
|
|
|
|
2016-09-15 16:53:03 +02:00
|
|
|
/* Check if this BlockDriverState is already in the queue */
|
|
|
|
QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
|
|
|
|
if (bs == bs_entry->state.bs) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-08 17:07:31 +02:00
|
|
|
/*
|
|
|
|
* Precedence of options:
|
|
|
|
* 1. Explicitly passed in options (highest)
|
2015-05-08 17:49:53 +02:00
|
|
|
* 2. Set in flags (only for top level)
|
2015-05-08 16:15:03 +02:00
|
|
|
* 3. Retained from explicitly set options of bs
|
2015-04-29 17:29:39 +02:00
|
|
|
* 4. Inherited from parent node
|
2015-05-08 17:07:31 +02:00
|
|
|
* 5. Retained from effective options of bs
|
|
|
|
*/
|
|
|
|
|
2015-05-08 17:49:53 +02:00
|
|
|
if (!parent_options) {
|
|
|
|
/*
|
|
|
|
* Any setting represented by flags is always updated. If the
|
|
|
|
* corresponding QDict option is set, it takes precedence. Otherwise
|
|
|
|
* the flag is translated into a QDict option. The old setting of bs is
|
|
|
|
* not considered.
|
|
|
|
*/
|
|
|
|
update_options_from_flags(options, flags);
|
|
|
|
}
|
|
|
|
|
2015-05-08 16:15:03 +02:00
|
|
|
/* Old explicitly set values (don't overwrite by inherited value) */
|
2016-09-15 16:53:03 +02:00
|
|
|
if (bs_entry) {
|
|
|
|
old_options = qdict_clone_shallow(bs_entry->state.explicit_options);
|
|
|
|
} else {
|
|
|
|
old_options = qdict_clone_shallow(bs->explicit_options);
|
|
|
|
}
|
2015-05-08 16:15:03 +02:00
|
|
|
bdrv_join_options(bs, options, old_options);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(old_options);
|
2015-05-08 16:15:03 +02:00
|
|
|
|
|
|
|
explicit_options = qdict_clone_shallow(options);
|
|
|
|
|
2015-05-08 17:07:31 +02:00
|
|
|
/* Inherit from parent node */
|
|
|
|
if (parent_options) {
|
2018-03-13 15:20:02 +01:00
|
|
|
QemuOpts *opts;
|
|
|
|
QDict *options_copy;
|
2015-05-08 17:07:31 +02:00
|
|
|
assert(!flags);
|
2015-04-29 17:29:39 +02:00
|
|
|
role->inherit_options(&flags, options, parent_flags, parent_options);
|
2018-03-13 15:20:02 +01:00
|
|
|
options_copy = qdict_clone_shallow(options);
|
|
|
|
opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
|
|
|
|
qemu_opts_absorb_qdict(opts, options_copy, NULL);
|
|
|
|
update_flags_from_options(&flags, opts);
|
|
|
|
qemu_opts_del(opts);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(options_copy);
|
2015-05-08 17:07:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Old values are used for options that aren't set yet */
|
2015-04-10 17:50:50 +02:00
|
|
|
old_options = qdict_clone_shallow(bs->options);
|
2015-11-16 16:43:27 +01:00
|
|
|
bdrv_join_options(bs, options, old_options);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(old_options);
|
2015-04-10 17:50:50 +02:00
|
|
|
|
2017-08-03 17:02:59 +02:00
|
|
|
/* bdrv_open_inherit() sets and clears some additional flags internally */
|
2014-04-25 19:04:55 +02:00
|
|
|
flags &= ~BDRV_O_PROTOCOL;
|
2017-08-03 17:02:59 +02:00
|
|
|
if (flags & BDRV_O_RDWR) {
|
|
|
|
flags |= BDRV_O_ALLOW_RDWR;
|
|
|
|
}
|
2014-04-25 19:04:55 +02:00
|
|
|
|
2017-09-14 14:53:46 +02:00
|
|
|
if (!bs_entry) {
|
|
|
|
bs_entry = g_new0(BlockReopenQueueEntry, 1);
|
|
|
|
QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
|
|
|
|
} else {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs_entry->state.options);
|
|
|
|
qobject_unref(bs_entry->state.explicit_options);
|
2017-09-14 14:53:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bs_entry->state.bs = bs;
|
|
|
|
bs_entry->state.options = options;
|
|
|
|
bs_entry->state.explicit_options = explicit_options;
|
|
|
|
bs_entry->state.flags = flags;
|
|
|
|
|
2017-07-03 17:07:35 +02:00
|
|
|
/* This needs to be overwritten in bdrv_reopen_prepare() */
|
|
|
|
bs_entry->state.perm = UINT64_MAX;
|
|
|
|
bs_entry->state.shared_perm = 0;
|
|
|
|
|
2015-04-09 18:54:04 +02:00
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
2015-05-08 15:14:15 +02:00
|
|
|
QDict *new_child_options;
|
|
|
|
char *child_key_dot;
|
2015-04-09 18:54:04 +02:00
|
|
|
|
2015-05-08 15:14:15 +02:00
|
|
|
/* reopen can only change the options of block devices that were
|
|
|
|
* implicitly created and inherited options. For other (referenced)
|
|
|
|
* block devices, a syntax like "backing.foo" results in an error. */
|
2015-04-09 18:54:04 +02:00
|
|
|
if (child->bs->inherits_from != bs) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-05-08 15:14:15 +02:00
|
|
|
child_key_dot = g_strdup_printf("%s.", child->name);
|
2018-06-29 13:37:00 +02:00
|
|
|
qdict_extract_subqdict(explicit_options, NULL, child_key_dot);
|
2015-05-08 15:14:15 +02:00
|
|
|
qdict_extract_subqdict(options, &new_child_options, child_key_dot);
|
|
|
|
g_free(child_key_dot);
|
|
|
|
|
2015-05-08 17:07:31 +02:00
|
|
|
bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
|
|
|
|
child->role, options, flags);
|
2012-09-20 21:13:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return bs_queue;
|
|
|
|
}
|
|
|
|
|
2015-05-08 17:07:31 +02:00
|
|
|
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
|
|
|
|
BlockDriverState *bs,
|
|
|
|
QDict *options, int flags)
|
|
|
|
{
|
|
|
|
return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
|
|
|
|
NULL, NULL, 0);
|
|
|
|
}
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
/*
|
|
|
|
* Reopen multiple BlockDriverStates atomically & transactionally.
|
|
|
|
*
|
|
|
|
* The queue passed in (bs_queue) must have been built up previous
|
|
|
|
* via bdrv_reopen_queue().
|
|
|
|
*
|
|
|
|
* Reopens all BDS specified in the queue, with the appropriate
|
|
|
|
* flags. All devices are prepared for reopen, and failure of any
|
2018-07-12 21:51:20 +02:00
|
|
|
* device will cause all device changes to be abandoned, and intermediate
|
2012-09-20 21:13:19 +02:00
|
|
|
* data cleaned up.
|
|
|
|
*
|
|
|
|
* If all devices prepare successfully, then the changes are committed
|
|
|
|
* to all devices.
|
|
|
|
*
|
2017-12-06 20:24:44 +01:00
|
|
|
* All affected nodes must be drained between bdrv_reopen_queue() and
|
|
|
|
* bdrv_reopen_multiple().
|
2012-09-20 21:13:19 +02:00
|
|
|
*/
|
2016-10-27 12:49:02 +02:00
|
|
|
int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp)
|
2012-09-20 21:13:19 +02:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
BlockReopenQueueEntry *bs_entry, *next;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
assert(bs_queue != NULL);
|
|
|
|
|
|
|
|
QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
|
2017-12-06 20:24:44 +01:00
|
|
|
assert(bs_entry->state.bs->quiesce_counter > 0);
|
2012-09-20 21:13:19 +02:00
|
|
|
if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
bs_entry->prepared = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we reach this point, we have success and just need to apply the
|
|
|
|
* changes
|
|
|
|
*/
|
|
|
|
QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
|
|
|
|
bdrv_reopen_commit(&bs_entry->state);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
|
2018-06-29 13:37:01 +02:00
|
|
|
if (ret) {
|
|
|
|
if (bs_entry->prepared) {
|
|
|
|
bdrv_reopen_abort(&bs_entry->state);
|
|
|
|
}
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs_entry->state.explicit_options);
|
2018-06-29 13:37:02 +02:00
|
|
|
qobject_unref(bs_entry->state.options);
|
2012-09-20 21:13:19 +02:00
|
|
|
}
|
|
|
|
g_free(bs_entry);
|
|
|
|
}
|
|
|
|
g_free(bs_queue);
|
2016-10-28 09:08:03 +02:00
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Reopen a single BlockDriverState with the specified flags. */
|
|
|
|
int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
Error *local_err = NULL;
|
2017-12-06 20:24:44 +01:00
|
|
|
BlockReopenQueue *queue;
|
2012-09-20 21:13:19 +02:00
|
|
|
|
2017-12-06 20:24:44 +01:00
|
|
|
bdrv_subtree_drained_begin(bs);
|
|
|
|
|
|
|
|
queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
|
2016-10-27 12:49:02 +02:00
|
|
|
ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, &local_err);
|
2012-09-20 21:13:19 +02:00
|
|
|
if (local_err != NULL) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
}
|
2017-12-06 20:24:44 +01:00
|
|
|
|
|
|
|
bdrv_subtree_drained_end(bs);
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-07-03 17:07:35 +02:00
|
|
|
static BlockReopenQueueEntry *find_parent_in_reopen_queue(BlockReopenQueue *q,
|
|
|
|
BdrvChild *c)
|
|
|
|
{
|
|
|
|
BlockReopenQueueEntry *entry;
|
|
|
|
|
|
|
|
QSIMPLEQ_FOREACH(entry, q, entry) {
|
|
|
|
BlockDriverState *bs = entry->state.bs;
|
|
|
|
BdrvChild *child;
|
|
|
|
|
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
if (child == c) {
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
|
|
|
|
uint64_t *perm, uint64_t *shared)
|
|
|
|
{
|
|
|
|
BdrvChild *c;
|
|
|
|
BlockReopenQueueEntry *parent;
|
|
|
|
uint64_t cumulative_perms = 0;
|
|
|
|
uint64_t cumulative_shared_perms = BLK_PERM_ALL;
|
|
|
|
|
|
|
|
QLIST_FOREACH(c, &bs->parents, next_parent) {
|
|
|
|
parent = find_parent_in_reopen_queue(q, c);
|
|
|
|
if (!parent) {
|
|
|
|
cumulative_perms |= c->perm;
|
|
|
|
cumulative_shared_perms &= c->shared_perm;
|
|
|
|
} else {
|
|
|
|
uint64_t nperm, nshared;
|
|
|
|
|
|
|
|
bdrv_child_perm(parent->state.bs, bs, c, c->role, q,
|
|
|
|
parent->state.perm, parent->state.shared_perm,
|
|
|
|
&nperm, &nshared);
|
|
|
|
|
|
|
|
cumulative_perms |= nperm;
|
|
|
|
cumulative_shared_perms &= nshared;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*perm = cumulative_perms;
|
|
|
|
*shared = cumulative_shared_perms;
|
|
|
|
}
|
2012-09-20 21:13:19 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepares a BlockDriverState for reopen. All changes are staged in the
|
|
|
|
* 'opaque' field of the BDRVReopenState, which is used and allocated by
|
|
|
|
* the block driver layer .bdrv_reopen_prepare()
|
|
|
|
*
|
|
|
|
* bs is the BlockDriverState to reopen
|
|
|
|
* flags are the new open flags
|
|
|
|
* queue is the reopen queue
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero on error. On error errp will be set
|
|
|
|
* as well.
|
|
|
|
*
|
|
|
|
* On failure, bdrv_reopen_abort() will be called to clean up any data.
|
|
|
|
* It is the responsibility of the caller to then call the abort() or
|
|
|
|
* commit() for any other BDS that have been left in a prepare() state
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
BlockDriver *drv;
|
2015-05-08 17:24:56 +02:00
|
|
|
QemuOpts *opts;
|
2018-06-29 13:37:02 +02:00
|
|
|
QDict *orig_reopen_opts;
|
2018-09-06 11:37:08 +02:00
|
|
|
char *discard = NULL;
|
2017-04-07 22:55:30 +02:00
|
|
|
bool read_only;
|
2012-09-20 21:13:19 +02:00
|
|
|
|
|
|
|
assert(reopen_state != NULL);
|
|
|
|
assert(reopen_state->bs->drv != NULL);
|
|
|
|
drv = reopen_state->bs->drv;
|
|
|
|
|
2018-06-29 13:37:02 +02:00
|
|
|
/* This function and each driver's bdrv_reopen_prepare() remove
|
|
|
|
* entries from reopen_state->options as they are processed, so
|
|
|
|
* we need to make a copy of the original QDict. */
|
|
|
|
orig_reopen_opts = qdict_clone_shallow(reopen_state->options);
|
|
|
|
|
2015-05-08 17:24:56 +02:00
|
|
|
/* Process generic block layer options */
|
|
|
|
opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
|
|
|
|
qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2015-05-08 17:49:53 +02:00
|
|
|
update_flags_from_options(&reopen_state->flags, opts);
|
|
|
|
|
2018-10-03 12:23:13 +02:00
|
|
|
discard = qemu_opt_get_del(opts, BDRV_OPT_DISCARD);
|
2018-09-06 11:37:08 +02:00
|
|
|
if (discard != NULL) {
|
|
|
|
if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) {
|
|
|
|
error_setg(errp, "Invalid discard option");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-06 11:37:09 +02:00
|
|
|
reopen_state->detect_zeroes =
|
|
|
|
bdrv_parse_detect_zeroes(opts, reopen_state->flags, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2018-09-06 11:37:06 +02:00
|
|
|
/* All other options (including node-name and driver) must be unchanged.
|
|
|
|
* Put them back into the QDict, so that they are checked at the end
|
|
|
|
* of this function. */
|
|
|
|
qemu_opts_to_qdict(opts, reopen_state->options);
|
2015-05-08 17:24:56 +02:00
|
|
|
|
2017-04-07 22:55:30 +02:00
|
|
|
/* If we are to stay read-only, do not allow permission change
|
|
|
|
* to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
|
|
|
|
* not set, or if the BDS still has copy_on_read enabled */
|
|
|
|
read_only = !(reopen_state->flags & BDRV_O_RDWR);
|
2017-08-03 17:02:58 +02:00
|
|
|
ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);
|
2017-04-07 22:55:30 +02:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
2012-09-20 21:13:19 +02:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2017-07-03 17:07:35 +02:00
|
|
|
/* Calculate required permissions after reopening */
|
|
|
|
bdrv_reopen_perm(queue, reopen_state->bs,
|
|
|
|
&reopen_state->perm, &reopen_state->shared_perm);
|
2012-09-20 21:13:19 +02:00
|
|
|
|
|
|
|
ret = bdrv_flush(reopen_state->bs);
|
|
|
|
if (ret) {
|
2015-11-11 07:51:20 +01:00
|
|
|
error_setg_errno(errp, -ret, "Error flushing drive");
|
2012-09-20 21:13:19 +02:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (drv->bdrv_reopen_prepare) {
|
|
|
|
ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
|
|
|
|
if (ret) {
|
|
|
|
if (local_err != NULL) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
} else {
|
2013-06-10 17:29:27 +02:00
|
|
|
error_setg(errp, "failed while preparing to reopen image '%s'",
|
|
|
|
reopen_state->bs->filename);
|
2012-09-20 21:13:19 +02:00
|
|
|
}
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* It is currently mandatory to have a bdrv_reopen_prepare()
|
|
|
|
* handler for each supported drv. */
|
2015-04-08 11:29:19 +02:00
|
|
|
error_setg(errp, "Block format '%s' used by node '%s' "
|
|
|
|
"does not support reopening files", drv->format_name,
|
|
|
|
bdrv_get_device_or_node_name(reopen_state->bs));
|
2012-09-20 21:13:19 +02:00
|
|
|
ret = -1;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2015-04-10 17:50:50 +02:00
|
|
|
/* Options that are not handled are only okay if they are unchanged
|
|
|
|
* compared to the old state. It is expected that some options are only
|
|
|
|
* used for the initial open, but not reopen (e.g. filename) */
|
|
|
|
if (qdict_size(reopen_state->options)) {
|
|
|
|
const QDictEntry *entry = qdict_first(reopen_state->options);
|
|
|
|
|
|
|
|
do {
|
2017-11-14 19:01:26 +01:00
|
|
|
QObject *new = entry->value;
|
|
|
|
QObject *old = qdict_get(reopen_state->bs->options, entry->key);
|
|
|
|
|
2018-09-06 11:37:05 +02:00
|
|
|
/* Allow child references (child_name=node_name) as long as they
|
|
|
|
* point to the current child (i.e. everything stays the same). */
|
|
|
|
if (qobject_type(new) == QTYPE_QSTRING) {
|
|
|
|
BdrvChild *child;
|
|
|
|
QLIST_FOREACH(child, &reopen_state->bs->children, next) {
|
|
|
|
if (!strcmp(child->name, entry->key)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (child) {
|
|
|
|
const char *str = qobject_get_try_str(new);
|
|
|
|
if (!strcmp(child->bs->node_name, str)) {
|
|
|
|
continue; /* Found child with this name, skip option */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
/*
|
2017-11-14 19:01:26 +01:00
|
|
|
* TODO: When using -drive to specify blockdev options, all values
|
|
|
|
* will be strings; however, when using -blockdev, blockdev-add or
|
|
|
|
* filenames using the json:{} pseudo-protocol, they will be
|
|
|
|
* correctly typed.
|
|
|
|
* In contrast, reopening options are (currently) always strings
|
|
|
|
* (because you can only specify them through qemu-io; all other
|
|
|
|
* callers do not specify any options).
|
|
|
|
* Therefore, when using anything other than -drive to create a BDS,
|
|
|
|
* this cannot detect non-string options as unchanged, because
|
|
|
|
* qobject_is_equal() always returns false for objects of different
|
|
|
|
* type. In the future, this should be remedied by correctly typing
|
|
|
|
* all options. For now, this is not too big of an issue because
|
|
|
|
* the user can simply omit options which cannot be changed anyway,
|
|
|
|
* so they will stay unchanged.
|
block: Document -drive problematic code and bugs
-blockdev and blockdev_add convert their arguments via QObject to
BlockdevOptions for qmp_blockdev_add(), which converts them back to
QObject, then to a flattened QDict. The QDict's members are typed
according to the QAPI schema.
-drive converts its argument via QemuOpts to a (flat) QDict. This
QDict's members are all QString.
Thus, the QType of a flat QDict member depends on whether it comes
from -drive or -blockdev/blockdev_add, except when the QAPI type maps
to QString, which is the case for 'str' and enumeration types.
The block layer core extracts generic configuration from the flat
QDict, and the block driver extracts driver-specific configuration.
Both commonly do so by converting (parts of) the flat QDict to
QemuOpts, which turns all values into strings. Not exactly elegant,
but correct.
However, A few places access the flat QDict directly:
* Most of them access members that are always QString. Correct.
* bdrv_open_inherit() accesses a boolean, carefully. Correct.
* nfs_config() uses a QObject input visitor. Correct only because the
visited type contains nothing but QStrings.
* nbd_config() and ssh_config() use a QObject input visitor, and the
visited types contain non-QStrings: InetSocketAddress members
@numeric, @to, @ipv4, @ipv6. -drive works as long as you don't try
to use them (they're all optional). @to is ignored anyway.
Reproducer:
-drive driver=ssh,server.host=h,server.port=22,server.ipv4,path=p
-drive driver=nbd,server.type=inet,server.data.host=h,server.data.port=22,server.data.ipv4
both fail with "Invalid parameter type for 'data.ipv4', expected: boolean"
Add suitable comments to all these places. Mark the buggy ones FIXME.
"Fortunately", -drive's driver-specific options are entirely
undocumented.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1490895797-29094-5-git-send-email-armbru@redhat.com
[mreitz: Fixed two typos]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2017-03-30 19:43:12 +02:00
|
|
|
*/
|
2017-11-14 19:01:26 +01:00
|
|
|
if (!qobject_is_equal(new, old)) {
|
2015-04-10 17:50:50 +02:00
|
|
|
error_setg(errp, "Cannot change the option '%s'", entry->key);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} while ((entry = qdict_next(reopen_state->options, entry)));
|
|
|
|
}
|
|
|
|
|
2017-07-03 17:07:35 +02:00
|
|
|
ret = bdrv_check_perm(reopen_state->bs, queue, reopen_state->perm,
|
|
|
|
reopen_state->shared_perm, NULL, errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
ret = 0;
|
|
|
|
|
2018-06-29 13:37:02 +02:00
|
|
|
/* Restore the original reopen_state->options QDict */
|
|
|
|
qobject_unref(reopen_state->options);
|
|
|
|
reopen_state->options = qobject_ref(orig_reopen_opts);
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
error:
|
2015-05-08 17:24:56 +02:00
|
|
|
qemu_opts_del(opts);
|
2018-06-29 13:37:02 +02:00
|
|
|
qobject_unref(orig_reopen_opts);
|
2018-09-06 11:37:08 +02:00
|
|
|
g_free(discard);
|
2012-09-20 21:13:19 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
|
|
|
|
* makes them final by swapping the staging BlockDriverState contents into
|
|
|
|
* the active BlockDriverState contents.
|
|
|
|
*/
|
|
|
|
void bdrv_reopen_commit(BDRVReopenState *reopen_state)
|
|
|
|
{
|
|
|
|
BlockDriver *drv;
|
2017-06-28 14:05:12 +02:00
|
|
|
BlockDriverState *bs;
|
block: Remove child references from bs->{options,explicit_options}
Block drivers allow opening their children using a reference to an
existing BlockDriverState. These references remain stored in the
'options' and 'explicit_options' QDicts, but we don't need to keep
them once everything is open.
What is more important, these values can become wrong if the children
change:
$ qemu-img create -f qcow2 hd0.qcow2 10M
$ qemu-img create -f qcow2 hd1.qcow2 10M
$ qemu-img create -f qcow2 hd2.qcow2 10M
$ $QEMU -drive if=none,file=hd0.qcow2,node-name=hd0 \
-drive if=none,file=hd1.qcow2,node-name=hd1,backing=hd0 \
-drive file=hd2.qcow2,node-name=hd2,backing=hd1
After this hd2 has hd1 as its backing file. Now let's remove it using
block_stream:
(qemu) block_stream hd2 0 hd0.qcow2
Now hd0 is the backing file of hd2, but hd2's options QDicts still
contain backing=hd1.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-09-06 11:37:03 +02:00
|
|
|
BdrvChild *child;
|
2017-06-28 14:05:13 +02:00
|
|
|
bool old_can_write, new_can_write;
|
2012-09-20 21:13:19 +02:00
|
|
|
|
|
|
|
assert(reopen_state != NULL);
|
2017-06-28 14:05:12 +02:00
|
|
|
bs = reopen_state->bs;
|
|
|
|
drv = bs->drv;
|
2012-09-20 21:13:19 +02:00
|
|
|
assert(drv != NULL);
|
|
|
|
|
2017-06-28 14:05:13 +02:00
|
|
|
old_can_write =
|
|
|
|
!bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
/* If there are any driver level actions to take */
|
|
|
|
if (drv->bdrv_reopen_commit) {
|
|
|
|
drv->bdrv_reopen_commit(reopen_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set BDS specific flags now */
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs->explicit_options);
|
2018-06-29 13:37:02 +02:00
|
|
|
qobject_unref(bs->options);
|
2015-05-08 16:15:03 +02:00
|
|
|
|
2017-06-28 14:05:12 +02:00
|
|
|
bs->explicit_options = reopen_state->explicit_options;
|
2018-06-29 13:37:02 +02:00
|
|
|
bs->options = reopen_state->options;
|
2017-06-28 14:05:12 +02:00
|
|
|
bs->open_flags = reopen_state->flags;
|
|
|
|
bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
|
2018-09-06 11:37:09 +02:00
|
|
|
bs->detect_zeroes = reopen_state->detect_zeroes;
|
2013-12-11 20:14:09 +01:00
|
|
|
|
block: Remove child references from bs->{options,explicit_options}
Block drivers allow opening their children using a reference to an
existing BlockDriverState. These references remain stored in the
'options' and 'explicit_options' QDicts, but we don't need to keep
them once everything is open.
What is more important, these values can become wrong if the children
change:
$ qemu-img create -f qcow2 hd0.qcow2 10M
$ qemu-img create -f qcow2 hd1.qcow2 10M
$ qemu-img create -f qcow2 hd2.qcow2 10M
$ $QEMU -drive if=none,file=hd0.qcow2,node-name=hd0 \
-drive if=none,file=hd1.qcow2,node-name=hd1,backing=hd0 \
-drive file=hd2.qcow2,node-name=hd2,backing=hd1
After this hd2 has hd1 as its backing file. Now let's remove it using
block_stream:
(qemu) block_stream hd2 0 hd0.qcow2
Now hd0 is the backing file of hd2, but hd2's options QDicts still
contain backing=hd1.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-09-06 11:37:03 +02:00
|
|
|
/* Remove child references from bs->options and bs->explicit_options.
|
|
|
|
* Child options were already removed in bdrv_reopen_queue_child() */
|
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
qdict_del(bs->explicit_options, child->name);
|
|
|
|
qdict_del(bs->options, child->name);
|
|
|
|
}
|
|
|
|
|
2017-06-28 14:05:12 +02:00
|
|
|
bdrv_refresh_limits(bs, NULL);
|
2017-06-28 14:05:13 +02:00
|
|
|
|
2017-07-03 17:07:35 +02:00
|
|
|
bdrv_set_perm(reopen_state->bs, reopen_state->perm,
|
|
|
|
reopen_state->shared_perm);
|
|
|
|
|
2017-06-28 14:05:13 +02:00
|
|
|
new_can_write =
|
|
|
|
!bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
|
|
|
|
if (!old_can_write && new_can_write && drv->bdrv_reopen_bitmaps_rw) {
|
|
|
|
Error *local_err = NULL;
|
|
|
|
if (drv->bdrv_reopen_bitmaps_rw(bs, &local_err) < 0) {
|
|
|
|
/* This is not fatal, bitmaps just left read-only, so all following
|
|
|
|
* writes will fail. User can remove read-only bitmaps to unblock
|
|
|
|
* writes.
|
|
|
|
*/
|
|
|
|
error_reportf_err(local_err,
|
|
|
|
"%s: Failed to make dirty bitmaps writable: ",
|
|
|
|
bdrv_get_node_name(bs));
|
|
|
|
}
|
|
|
|
}
|
2012-09-20 21:13:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Abort the reopen, and delete and free the staged changes in
|
|
|
|
* reopen_state
|
|
|
|
*/
|
|
|
|
void bdrv_reopen_abort(BDRVReopenState *reopen_state)
|
|
|
|
{
|
|
|
|
BlockDriver *drv;
|
|
|
|
|
|
|
|
assert(reopen_state != NULL);
|
|
|
|
drv = reopen_state->bs->drv;
|
|
|
|
assert(drv != NULL);
|
|
|
|
|
|
|
|
if (drv->bdrv_reopen_abort) {
|
|
|
|
drv->bdrv_reopen_abort(reopen_state);
|
|
|
|
}
|
2015-05-08 16:15:03 +02:00
|
|
|
|
2017-07-03 17:07:35 +02:00
|
|
|
bdrv_abort_perm_update(reopen_state->bs);
|
2012-09-20 21:13:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-29 16:36:10 +01:00
|
|
|
static void bdrv_close(BlockDriverState *bs)
|
2003-06-30 12:03:06 +02:00
|
|
|
{
|
2014-06-20 21:57:33 +02:00
|
|
|
BdrvAioNotifier *ban, *ban_next;
|
2017-11-06 15:53:45 +01:00
|
|
|
BdrvChild *child, *next;
|
2014-06-20 21:57:33 +02:00
|
|
|
|
2016-01-29 16:36:14 +01:00
|
|
|
assert(!bs->job);
|
2016-05-17 16:41:32 +02:00
|
|
|
assert(!bs->refcnt);
|
2015-09-25 15:41:44 +02:00
|
|
|
|
2015-12-23 11:48:24 +01:00
|
|
|
bdrv_drained_begin(bs); /* complete I/O */
|
2013-07-02 15:36:25 +02:00
|
|
|
bdrv_flush(bs);
|
2015-05-29 12:53:14 +02:00
|
|
|
bdrv_drain(bs); /* in case flush left pending I/O */
|
2015-12-23 11:48:24 +01:00
|
|
|
|
2012-10-19 11:36:48 +02:00
|
|
|
if (bs->drv) {
|
2018-08-14 14:43:19 +02:00
|
|
|
if (bs->drv->bdrv_close) {
|
|
|
|
bs->drv->bdrv_close(bs);
|
|
|
|
}
|
2015-06-16 14:19:22 +02:00
|
|
|
bs->drv = NULL;
|
2017-11-06 15:53:45 +01:00
|
|
|
}
|
2015-06-16 10:58:20 +02:00
|
|
|
|
2017-11-06 15:53:45 +01:00
|
|
|
bdrv_set_backing_hd(bs, NULL, &error_abort);
|
2015-06-16 10:58:20 +02:00
|
|
|
|
2017-11-06 15:53:45 +01:00
|
|
|
if (bs->file != NULL) {
|
|
|
|
bdrv_unref_child(bs, bs->file);
|
|
|
|
bs->file = NULL;
|
|
|
|
}
|
2015-06-16 14:19:22 +02:00
|
|
|
|
2017-11-06 15:53:45 +01:00
|
|
|
QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
|
|
|
|
/* TODO Remove bdrv_unref() from drivers' close function and use
|
|
|
|
* bdrv_unref_child() here */
|
|
|
|
if (child->bs->inherits_from == bs) {
|
|
|
|
child->bs->inherits_from = NULL;
|
2015-04-08 13:49:41 +02:00
|
|
|
}
|
2017-11-06 15:53:45 +01:00
|
|
|
bdrv_detach_child(child);
|
2004-03-14 22:38:54 +01:00
|
|
|
}
|
2011-11-08 06:00:14 +01:00
|
|
|
|
2017-11-06 15:53:45 +01:00
|
|
|
g_free(bs->opaque);
|
|
|
|
bs->opaque = NULL;
|
|
|
|
atomic_set(&bs->copy_on_read, 0);
|
|
|
|
bs->backing_file[0] = '\0';
|
|
|
|
bs->backing_format[0] = '\0';
|
|
|
|
bs->total_sectors = 0;
|
|
|
|
bs->encrypted = false;
|
|
|
|
bs->sg = false;
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs->options);
|
|
|
|
qobject_unref(bs->explicit_options);
|
2017-11-06 15:53:45 +01:00
|
|
|
bs->options = NULL;
|
|
|
|
bs->explicit_options = NULL;
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs->full_open_options);
|
2017-11-06 15:53:45 +01:00
|
|
|
bs->full_open_options = NULL;
|
|
|
|
|
2017-06-28 14:05:16 +02:00
|
|
|
bdrv_release_named_dirty_bitmaps(bs);
|
|
|
|
assert(QLIST_EMPTY(&bs->dirty_bitmaps));
|
|
|
|
|
2014-06-20 21:57:33 +02:00
|
|
|
QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
|
|
|
|
g_free(ban);
|
|
|
|
}
|
|
|
|
QLIST_INIT(&bs->aio_notifiers);
|
2015-12-23 11:48:24 +01:00
|
|
|
bdrv_drained_end(bs);
|
2004-03-14 22:38:54 +01:00
|
|
|
}
|
|
|
|
|
2010-05-28 04:44:57 +02:00
|
|
|
void bdrv_close_all(void)
|
|
|
|
{
|
2018-05-16 13:46:37 +02:00
|
|
|
assert(job_next(NULL) == NULL);
|
2016-07-06 11:22:39 +02:00
|
|
|
nbd_export_close_all();
|
2016-01-29 16:36:14 +01:00
|
|
|
|
|
|
|
/* Drop references from requests still in flight, such as canceled block
|
|
|
|
* jobs whose AIO context has not been polled yet */
|
|
|
|
bdrv_drain_all();
|
2010-05-28 04:44:57 +02:00
|
|
|
|
2016-01-29 16:36:14 +01:00
|
|
|
blk_remove_all_bs();
|
|
|
|
blockdev_close_all_bdrv_states();
|
2014-05-08 16:34:35 +02:00
|
|
|
|
2016-04-08 18:26:37 +02:00
|
|
|
assert(QTAILQ_EMPTY(&all_bdrv_states));
|
2010-05-28 04:44:57 +02:00
|
|
|
}
|
|
|
|
|
2017-03-01 17:30:41 +01:00
|
|
|
static bool should_update_child(BdrvChild *c, BlockDriverState *to)
|
|
|
|
{
|
|
|
|
BdrvChild *to_c;
|
|
|
|
|
|
|
|
if (c->role->stay_at_node) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-06-13 20:18:15 +02:00
|
|
|
/* If the child @c belongs to the BDS @to, replacing the current
|
|
|
|
* c->bs by @to would mean to create a loop.
|
|
|
|
*
|
|
|
|
* Such a case occurs when appending a BDS to a backing chain.
|
|
|
|
* For instance, imagine the following chain:
|
|
|
|
*
|
|
|
|
* guest device -> node A -> further backing chain...
|
|
|
|
*
|
|
|
|
* Now we create a new BDS B which we want to put on top of this
|
|
|
|
* chain, so we first attach A as its backing node:
|
|
|
|
*
|
|
|
|
* node B
|
|
|
|
* |
|
|
|
|
* v
|
|
|
|
* guest device -> node A -> further backing chain...
|
|
|
|
*
|
|
|
|
* Finally we want to replace A by B. When doing that, we want to
|
|
|
|
* replace all pointers to A by pointers to B -- except for the
|
|
|
|
* pointer from B because (1) that would create a loop, and (2)
|
|
|
|
* that pointer should simply stay intact:
|
|
|
|
*
|
|
|
|
* guest device -> node B
|
|
|
|
* |
|
|
|
|
* v
|
|
|
|
* node A -> further backing chain...
|
|
|
|
*
|
|
|
|
* In general, when replacing a node A (c->bs) by a node B (@to),
|
|
|
|
* if A is a child of B, that means we cannot replace A by B there
|
|
|
|
* because that would create a loop. Silently detaching A from B
|
|
|
|
* is also not really an option. So overall just leaving A in
|
|
|
|
* place there is the most sensible choice. */
|
|
|
|
QLIST_FOREACH(to_c, &to->children, next) {
|
|
|
|
if (to_c == c) {
|
2017-03-01 17:30:41 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-03-06 16:20:51 +01:00
|
|
|
void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
|
|
|
|
Error **errp)
|
2015-06-18 14:09:57 +02:00
|
|
|
{
|
2017-03-01 17:30:41 +01:00
|
|
|
BdrvChild *c, *next;
|
2017-03-02 18:43:00 +01:00
|
|
|
GSList *list = NULL, *p;
|
|
|
|
uint64_t old_perm, old_shared;
|
|
|
|
uint64_t perm = 0, shared = BLK_PERM_ALL;
|
|
|
|
int ret;
|
|
|
|
|
2017-03-06 16:20:51 +01:00
|
|
|
assert(!atomic_read(&from->in_flight));
|
|
|
|
assert(!atomic_read(&to->in_flight));
|
2015-06-18 14:09:57 +02:00
|
|
|
|
2017-03-02 18:43:00 +01:00
|
|
|
/* Make sure that @from doesn't go away until we have successfully attached
|
|
|
|
* all of its parents to @to. */
|
|
|
|
bdrv_ref(from);
|
2015-06-18 14:09:57 +02:00
|
|
|
|
2017-03-02 18:43:00 +01:00
|
|
|
/* Put all parents into @list and calculate their cumulative permissions */
|
2015-06-18 14:09:57 +02:00
|
|
|
QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
|
2018-06-13 20:18:15 +02:00
|
|
|
assert(c->bs == from);
|
2017-03-01 17:30:41 +01:00
|
|
|
if (!should_update_child(c, to)) {
|
2017-01-17 13:39:34 +01:00
|
|
|
continue;
|
|
|
|
}
|
2017-03-02 18:43:00 +01:00
|
|
|
list = g_slist_prepend(list, c);
|
|
|
|
perm |= c->perm;
|
|
|
|
shared &= c->shared_perm;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check whether the required permissions can be granted on @to, ignoring
|
|
|
|
* all BdrvChild in @list so that they can't block themselves. */
|
2017-09-14 14:42:12 +02:00
|
|
|
ret = bdrv_check_update_perm(to, NULL, perm, shared, list, errp);
|
2017-03-02 18:43:00 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
bdrv_abort_perm_update(to);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now actually perform the change. We performed the permission check for
|
|
|
|
* all elements of @list at once, so set the permissions all at once at the
|
|
|
|
* very end. */
|
|
|
|
for (p = list; p != NULL; p = p->next) {
|
|
|
|
c = p->data;
|
2016-06-10 20:57:46 +02:00
|
|
|
|
2015-06-18 14:09:57 +02:00
|
|
|
bdrv_ref(to);
|
2017-03-02 18:43:00 +01:00
|
|
|
bdrv_replace_child_noperm(c, to);
|
2015-06-18 14:09:57 +02:00
|
|
|
bdrv_unref(from);
|
|
|
|
}
|
2017-03-02 18:43:00 +01:00
|
|
|
|
|
|
|
bdrv_get_cumulative_perm(to, &old_perm, &old_shared);
|
|
|
|
bdrv_set_perm(to, old_perm | perm, old_shared | shared);
|
|
|
|
|
|
|
|
out:
|
|
|
|
g_slist_free(list);
|
|
|
|
bdrv_unref(from);
|
2015-06-18 14:09:57 +02:00
|
|
|
}
|
|
|
|
|
2012-06-14 16:55:02 +02:00
|
|
|
/*
|
|
|
|
* Add new bs contents at the top of an image chain while the chain is
|
|
|
|
* live, while keeping required fields on the top layer.
|
|
|
|
*
|
|
|
|
* This will modify the BlockDriverState fields, and swap contents
|
|
|
|
* between bs_new and bs_top. Both bs_new and bs_top are modified.
|
|
|
|
*
|
2014-10-07 13:59:11 +02:00
|
|
|
* bs_new must not be attached to a BlockBackend.
|
2012-06-14 16:55:02 +02:00
|
|
|
*
|
|
|
|
* This function does not create any image files.
|
2015-06-18 14:09:57 +02:00
|
|
|
*
|
|
|
|
* bdrv_append() takes ownership of a bs_new reference and unrefs it because
|
|
|
|
* that's what the callers commonly need. bs_new will be referenced by the old
|
|
|
|
* parents of bs_top after bdrv_append() returns. If the caller needs to keep a
|
|
|
|
* reference of its own, it must call bdrv_ref().
|
2012-06-14 16:55:02 +02:00
|
|
|
*/
|
2017-02-20 12:46:42 +01:00
|
|
|
void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
|
|
|
|
Error **errp)
|
2012-06-14 16:55:02 +02:00
|
|
|
{
|
2017-02-20 12:46:42 +01:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
bdrv_set_backing_hd(bs_new, bs_top, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
goto out;
|
|
|
|
}
|
2015-06-18 14:09:57 +02:00
|
|
|
|
2017-03-06 16:20:51 +01:00
|
|
|
bdrv_replace_node(bs_top, bs_new, &local_err);
|
2017-03-02 18:43:00 +01:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
bdrv_set_backing_hd(bs_new, NULL, &error_abort);
|
|
|
|
goto out;
|
|
|
|
}
|
2012-06-14 16:55:02 +02:00
|
|
|
|
2015-06-18 14:09:57 +02:00
|
|
|
/* bs_new is now referenced by its new parents, we don't need the
|
|
|
|
* additional reference any more. */
|
2017-02-20 12:46:42 +01:00
|
|
|
out:
|
2015-06-18 14:09:57 +02:00
|
|
|
bdrv_unref(bs_new);
|
2012-02-28 21:54:06 +01:00
|
|
|
}
|
|
|
|
|
2013-08-23 03:14:47 +02:00
|
|
|
static void bdrv_delete(BlockDriverState *bs)
|
2004-03-14 22:38:54 +01:00
|
|
|
{
|
2012-03-30 13:17:11 +02:00
|
|
|
assert(!bs->job);
|
2014-05-23 15:29:43 +02:00
|
|
|
assert(bdrv_op_blocker_is_empty(bs));
|
2013-08-23 03:14:47 +02:00
|
|
|
assert(!bs->refcnt);
|
2010-06-29 16:58:30 +02:00
|
|
|
|
2013-06-27 15:32:26 +02:00
|
|
|
bdrv_close(bs);
|
|
|
|
|
2010-04-10 08:02:42 +02:00
|
|
|
/* remove from list, if necessary */
|
2016-03-18 10:46:57 +01:00
|
|
|
if (bs->node_name[0] != '\0') {
|
|
|
|
QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
|
|
|
|
}
|
2016-01-29 16:36:11 +01:00
|
|
|
QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(bs);
|
2003-06-30 12:03:06 +02:00
|
|
|
}
|
|
|
|
|
2009-04-22 01:11:50 +02:00
|
|
|
/*
|
|
|
|
* Run consistency checks on an image
|
|
|
|
*
|
2010-06-29 11:43:13 +02:00
|
|
|
* Returns 0 if the check could be completed (it doesn't mean that the image is
|
2011-04-28 17:20:38 +02:00
|
|
|
* free of errors) or -errno when an internal error occurred. The results of the
|
2010-06-29 11:43:13 +02:00
|
|
|
* check are stored in res.
|
2009-04-22 01:11:50 +02:00
|
|
|
*/
|
2018-03-01 17:36:19 +01:00
|
|
|
static int coroutine_fn bdrv_co_check(BlockDriverState *bs,
|
|
|
|
BdrvCheckResult *res, BdrvCheckMode fix)
|
2009-04-22 01:11:50 +02:00
|
|
|
{
|
2014-08-07 22:47:55 +02:00
|
|
|
if (bs->drv == NULL) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
2018-03-01 17:36:19 +01:00
|
|
|
if (bs->drv->bdrv_co_check == NULL) {
|
2009-04-22 01:11:50 +02:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
2010-06-29 11:43:13 +02:00
|
|
|
memset(res, 0, sizeof(*res));
|
2018-03-01 17:36:19 +01:00
|
|
|
return bs->drv->bdrv_co_check(bs, res, fix);
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct CheckCo {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
BdrvCheckResult *res;
|
|
|
|
BdrvCheckMode fix;
|
|
|
|
int ret;
|
|
|
|
} CheckCo;
|
|
|
|
|
|
|
|
static void bdrv_check_co_entry(void *opaque)
|
|
|
|
{
|
|
|
|
CheckCo *cco = opaque;
|
|
|
|
cco->ret = bdrv_co_check(cco->bs, cco->res, cco->fix);
|
|
|
|
}
|
|
|
|
|
|
|
|
int bdrv_check(BlockDriverState *bs,
|
|
|
|
BdrvCheckResult *res, BdrvCheckMode fix)
|
|
|
|
{
|
|
|
|
Coroutine *co;
|
|
|
|
CheckCo cco = {
|
|
|
|
.bs = bs,
|
|
|
|
.res = res,
|
|
|
|
.ret = -EINPROGRESS,
|
|
|
|
.fix = fix,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
/* Fast-path if already in coroutine context */
|
|
|
|
bdrv_check_co_entry(&cco);
|
|
|
|
} else {
|
|
|
|
co = qemu_coroutine_create(bdrv_check_co_entry, &cco);
|
|
|
|
qemu_coroutine_enter(co);
|
|
|
|
BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
return cco.ret;
|
2009-04-22 01:11:50 +02:00
|
|
|
}
|
|
|
|
|
2010-01-12 12:55:17 +01:00
|
|
|
/*
|
|
|
|
* Return values:
|
|
|
|
* 0 - success
|
|
|
|
* -EINVAL - backing format specified, but no file
|
|
|
|
* -ENOSPC - can't update the backing file because no space is left in the
|
|
|
|
* image file header
|
|
|
|
* -ENOTSUP - format driver doesn't support changing the backing file
|
|
|
|
*/
|
|
|
|
int bdrv_change_backing_file(BlockDriverState *bs,
|
|
|
|
const char *backing_file, const char *backing_fmt)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
2012-04-12 14:01:02 +02:00
|
|
|
int ret;
|
2010-01-12 12:55:17 +01:00
|
|
|
|
2017-11-10 21:31:09 +01:00
|
|
|
if (!drv) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
|
2012-04-12 14:01:01 +02:00
|
|
|
/* Backing file format doesn't make sense without a backing file */
|
|
|
|
if (backing_fmt && !backing_file) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-01-12 12:55:17 +01:00
|
|
|
if (drv->bdrv_change_backing_file != NULL) {
|
2012-04-12 14:01:02 +02:00
|
|
|
ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
|
2010-01-12 12:55:17 +01:00
|
|
|
} else {
|
2012-04-12 14:01:02 +02:00
|
|
|
ret = -ENOTSUP;
|
2010-01-12 12:55:17 +01:00
|
|
|
}
|
2012-04-12 14:01:02 +02:00
|
|
|
|
|
|
|
if (ret == 0) {
|
|
|
|
pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
|
|
|
|
pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
|
|
|
|
}
|
|
|
|
return ret;
|
2010-01-12 12:55:17 +01:00
|
|
|
}
|
|
|
|
|
2012-09-27 19:29:12 +02:00
|
|
|
/*
|
|
|
|
* Finds the image layer in the chain that has 'bs' as its backing file.
|
|
|
|
*
|
|
|
|
* active is the current topmost image.
|
|
|
|
*
|
|
|
|
* Returns NULL if bs is not found in active's image chain,
|
|
|
|
* or if active == bs.
|
2014-06-25 21:35:26 +02:00
|
|
|
*
|
|
|
|
* Returns the bottommost base image if bs == NULL.
|
2012-09-27 19:29:12 +02:00
|
|
|
*/
|
|
|
|
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
|
|
|
|
BlockDriverState *bs)
|
|
|
|
{
|
2015-06-17 14:55:21 +02:00
|
|
|
while (active && bs != backing_bs(active)) {
|
|
|
|
active = backing_bs(active);
|
2012-09-27 19:29:12 +02:00
|
|
|
}
|
|
|
|
|
2014-06-25 21:35:26 +02:00
|
|
|
return active;
|
|
|
|
}
|
2012-09-27 19:29:12 +02:00
|
|
|
|
2014-06-25 21:35:26 +02:00
|
|
|
/* Given a BDS, searches for the base layer. */
|
|
|
|
BlockDriverState *bdrv_find_base(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
return bdrv_find_overlay(bs, NULL);
|
2012-09-27 19:29:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drops images above 'base' up to and including 'top', and sets the image
|
|
|
|
* above 'top' to have base as its backing file.
|
|
|
|
*
|
|
|
|
* Requires that the overlay to 'top' is opened r/w, so that the backing file
|
|
|
|
* information in 'bs' can be properly updated.
|
|
|
|
*
|
|
|
|
* E.g., this will convert the following chain:
|
|
|
|
* bottom <- base <- intermediate <- top <- active
|
|
|
|
*
|
|
|
|
* to
|
|
|
|
*
|
|
|
|
* bottom <- base <- active
|
|
|
|
*
|
|
|
|
* It is allowed for bottom==base, in which case it converts:
|
|
|
|
*
|
|
|
|
* base <- intermediate <- top <- active
|
|
|
|
*
|
|
|
|
* to
|
|
|
|
*
|
|
|
|
* base <- active
|
|
|
|
*
|
block: extend block-commit to accept a string for the backing file
On some image chains, QEMU may not always be able to resolve the
filenames properly, when updating the backing file of an image
after a block commit.
For instance, certain relative pathnames may fail, or drives may
have been specified originally by file descriptor (e.g. /dev/fd/???),
or a relative protocol pathname may have been used.
In these instances, QEMU may lack the information to be able to make
the correct choice, but the user or management layer most likely does
have that knowledge.
With this extension to the block-commit api, the user is able to change
the backing file of the overlay image as part of the block-commit
operation.
This allows the change to be 'safe', in the sense that if the attempt
to write the overlay image metadata fails, then the block-commit
operation returns failure, without disrupting the guest.
If the commit top is the active layer, then specifying the backing
file string will be treated as an error (there is no overlay image
to modify in that case).
If a backing file string is not specified in the command, the backing
file string to use is determined in the same manner as it was
previously.
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-25 21:40:10 +02:00
|
|
|
* If backing_file_str is non-NULL, it will be used when modifying top's
|
|
|
|
* overlay image metadata.
|
|
|
|
*
|
2012-09-27 19:29:12 +02:00
|
|
|
* Error conditions:
|
|
|
|
* if active == top, that is considered an error
|
|
|
|
*
|
|
|
|
*/
|
2017-06-27 20:36:18 +02:00
|
|
|
int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
|
|
|
|
const char *backing_file_str)
|
2012-09-27 19:29:12 +02:00
|
|
|
{
|
2017-09-19 16:22:54 +02:00
|
|
|
BdrvChild *c, *next;
|
2017-02-17 20:42:32 +01:00
|
|
|
Error *local_err = NULL;
|
2012-09-27 19:29:12 +02:00
|
|
|
int ret = -EIO;
|
|
|
|
|
2017-06-29 19:32:21 +02:00
|
|
|
bdrv_ref(top);
|
|
|
|
|
2012-09-27 19:29:12 +02:00
|
|
|
if (!top->drv || !base->drv) {
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2015-09-14 15:33:33 +02:00
|
|
|
/* Make sure that base is in the backing chain of top */
|
|
|
|
if (!bdrv_chain_contains(top, base)) {
|
2012-09-27 19:29:12 +02:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* success - we can delete the intermediate states, and link top->base */
|
2017-06-27 20:36:18 +02:00
|
|
|
/* TODO Check graph modification op blockers (BLK_PERM_GRAPH_MOD) once
|
|
|
|
* we've figured out how they should work. */
|
2017-09-19 16:22:54 +02:00
|
|
|
backing_file_str = backing_file_str ? backing_file_str : base->filename;
|
|
|
|
|
|
|
|
QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) {
|
|
|
|
/* Check whether we are allowed to switch c from top to base */
|
|
|
|
GSList *ignore_children = g_slist_prepend(NULL, c);
|
|
|
|
bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm,
|
|
|
|
ignore_children, &local_err);
|
2018-03-15 04:51:57 +01:00
|
|
|
g_slist_free(ignore_children);
|
2017-09-19 16:22:54 +02:00
|
|
|
if (local_err) {
|
|
|
|
ret = -EPERM;
|
|
|
|
error_report_err(local_err);
|
2017-06-29 19:32:21 +02:00
|
|
|
goto exit;
|
|
|
|
}
|
2017-02-17 20:42:32 +01:00
|
|
|
|
2017-09-19 16:22:54 +02:00
|
|
|
/* If so, update the backing file path in the image file */
|
|
|
|
if (c->role->update_filename) {
|
|
|
|
ret = c->role->update_filename(c, base, backing_file_str,
|
|
|
|
&local_err);
|
|
|
|
if (ret < 0) {
|
|
|
|
bdrv_abort_perm_update(base);
|
|
|
|
error_report_err(local_err);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do the actual switch in the in-memory graph.
|
|
|
|
* Completes bdrv_check_update_perm() transaction internally. */
|
|
|
|
bdrv_ref(base);
|
|
|
|
bdrv_replace_child(c, base);
|
|
|
|
bdrv_unref(top);
|
2017-02-17 20:42:32 +01:00
|
|
|
}
|
2012-09-27 19:29:12 +02:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
exit:
|
2017-06-29 19:32:21 +02:00
|
|
|
bdrv_unref(top);
|
2012-09-27 19:29:12 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/**
|
|
|
|
* Length of a allocated file in bytes. Sparse files are counted by actual
|
|
|
|
* allocated space. Return < 0 if error or unknown.
|
|
|
|
*/
|
|
|
|
int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
|
2009-03-03 18:37:16 +01:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
if (!drv) {
|
|
|
|
return -ENOMEDIUM;
|
2014-03-26 13:06:02 +01:00
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
if (drv->bdrv_get_allocated_file_size) {
|
|
|
|
return drv->bdrv_get_allocated_file_size(bs);
|
|
|
|
}
|
|
|
|
if (bs->file) {
|
2015-06-16 14:19:22 +02:00
|
|
|
return bdrv_get_allocated_file_size(bs->file->bs);
|
2011-10-13 14:08:22 +02:00
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
return -ENOTSUP;
|
2011-10-13 14:08:22 +02:00
|
|
|
}
|
2011-07-15 16:05:00 +02:00
|
|
|
|
2017-07-05 14:57:30 +02:00
|
|
|
/*
|
|
|
|
* bdrv_measure:
|
|
|
|
* @drv: Format driver
|
|
|
|
* @opts: Creation options for new image
|
|
|
|
* @in_bs: Existing image containing data for new image (may be NULL)
|
|
|
|
* @errp: Error object
|
|
|
|
* Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo())
|
|
|
|
* or NULL on error
|
|
|
|
*
|
|
|
|
* Calculate file size required to create a new image.
|
|
|
|
*
|
|
|
|
* If @in_bs is given then space for allocated clusters and zero clusters
|
|
|
|
* from that image are included in the calculation. If @opts contains a
|
|
|
|
* backing file that is shared by @in_bs then backing clusters may be omitted
|
|
|
|
* from the calculation.
|
|
|
|
*
|
|
|
|
* If @in_bs is NULL then the calculation includes no allocated clusters
|
|
|
|
* unless a preallocation option is given in @opts.
|
|
|
|
*
|
|
|
|
* Note that @in_bs may use a different BlockDriver from @drv.
|
|
|
|
*
|
|
|
|
* If an error occurs the @errp pointer is set.
|
|
|
|
*/
|
|
|
|
BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
|
|
|
|
BlockDriverState *in_bs, Error **errp)
|
|
|
|
{
|
|
|
|
if (!drv->bdrv_measure) {
|
|
|
|
error_setg(errp, "Block driver '%s' does not support size measurement",
|
|
|
|
drv->format_name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return drv->bdrv_measure(opts, in_bs, errp);
|
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/**
|
|
|
|
* Return number of sectors on success, -errno on error.
|
2011-10-13 14:08:22 +02:00
|
|
|
*/
|
2015-04-28 15:27:52 +02:00
|
|
|
int64_t bdrv_nb_sectors(BlockDriverState *bs)
|
2011-10-13 14:08:22 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
BlockDriver *drv = bs->drv;
|
2012-04-02 12:59:34 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (!drv)
|
|
|
|
return -ENOMEDIUM;
|
2014-05-08 16:34:34 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (drv->has_variable_length) {
|
|
|
|
int ret = refresh_total_sectors(bs, bs->total_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
2011-10-13 14:08:22 +02:00
|
|
|
}
|
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
return bs->total_sectors;
|
2011-10-13 14:08:22 +02:00
|
|
|
}
|
2004-03-14 22:38:54 +01:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/**
|
|
|
|
* Return length in bytes on success, -errno on error.
|
|
|
|
* The length is always a multiple of BDRV_SECTOR_SIZE.
|
2013-04-05 21:27:55 +02:00
|
|
|
*/
|
2015-04-28 15:27:52 +02:00
|
|
|
int64_t bdrv_getlength(BlockDriverState *bs)
|
2013-04-05 21:27:55 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
int64_t ret = bdrv_nb_sectors(bs);
|
2013-04-05 21:27:55 +02:00
|
|
|
|
2015-05-15 10:36:05 +02:00
|
|
|
ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
|
2015-04-28 15:27:52 +02:00
|
|
|
return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
|
2003-06-30 12:03:06 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* return 0 as number of sectors if no device present or error */
|
|
|
|
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
|
2012-06-29 17:34:29 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
int64_t nb_sectors = bdrv_nb_sectors(bs);
|
2012-06-29 17:34:29 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
*nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
|
2012-06-29 17:34:29 +02:00
|
|
|
}
|
|
|
|
|
2016-06-24 00:37:26 +02:00
|
|
|
bool bdrv_is_sg(BlockDriverState *bs)
|
2010-06-16 16:38:15 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
return bs->sg;
|
2010-06-16 16:38:15 +02:00
|
|
|
}
|
|
|
|
|
2016-06-24 00:37:26 +02:00
|
|
|
bool bdrv_is_encrypted(BlockDriverState *bs)
|
2015-03-24 02:23:49 +01:00
|
|
|
{
|
2015-06-17 14:55:21 +02:00
|
|
|
if (bs->backing && bs->backing->bs->encrypted) {
|
2016-06-24 00:37:26 +02:00
|
|
|
return true;
|
2015-06-17 14:55:21 +02:00
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
return bs->encrypted;
|
2015-03-24 02:23:49 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
const char *bdrv_get_format_name(BlockDriverState *bs)
|
2009-09-09 17:53:37 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
return bs->drv ? bs->drv->format_name : NULL;
|
2009-09-09 17:53:37 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
static int qsort_strcmp(const void *a, const void *b)
|
2009-09-09 17:53:37 +02:00
|
|
|
{
|
2016-10-12 22:49:05 +02:00
|
|
|
return strcmp(*(char *const *)a, *(char *const *)b);
|
2009-09-09 17:53:37 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
|
|
|
|
void *opaque)
|
2009-09-09 17:53:37 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
BlockDriver *drv;
|
|
|
|
int count = 0;
|
|
|
|
int i;
|
|
|
|
const char **formats = NULL;
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
QLIST_FOREACH(drv, &bdrv_drivers, list) {
|
|
|
|
if (drv->format_name) {
|
|
|
|
bool found = false;
|
|
|
|
int i = count;
|
|
|
|
while (formats && i && !found) {
|
|
|
|
found = !strcmp(formats[--i], drv->format_name);
|
|
|
|
}
|
2010-01-26 14:49:08 +01:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (!found) {
|
|
|
|
formats = g_renew(const char *, formats, count + 1);
|
|
|
|
formats[count++] = drv->format_name;
|
|
|
|
}
|
2014-10-27 10:18:46 +01:00
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
}
|
2014-10-27 10:18:46 +01:00
|
|
|
|
2016-10-12 22:49:06 +02:00
|
|
|
for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
|
|
|
|
const char *format_name = block_driver_modules[i].format_name;
|
|
|
|
|
|
|
|
if (format_name) {
|
|
|
|
bool found = false;
|
|
|
|
int j = count;
|
|
|
|
|
|
|
|
while (formats && j && !found) {
|
|
|
|
found = !strcmp(formats[--j], format_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
formats = g_renew(const char *, formats, count + 1);
|
|
|
|
formats[count++] = format_name;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
it(opaque, formats[i]);
|
|
|
|
}
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
g_free(formats);
|
|
|
|
}
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* This function is to find a node in the bs graph */
|
|
|
|
BlockDriverState *bdrv_find_node(const char *node_name)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs;
|
2014-07-30 10:53:30 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
assert(node_name);
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
|
|
|
|
if (!strcmp(node_name, bs->node_name)) {
|
|
|
|
return bs;
|
2009-09-09 17:53:37 +02:00
|
|
|
}
|
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
return NULL;
|
2009-09-09 17:53:37 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* Put this QMP function here so it can access the static graph_bdrv_states. */
|
|
|
|
BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
|
2009-09-09 17:53:37 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
BlockDeviceInfoList *list, *entry;
|
|
|
|
BlockDriverState *bs;
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
list = NULL;
|
|
|
|
QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
|
2016-03-03 11:37:48 +01:00
|
|
|
BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
|
2015-04-28 15:27:52 +02:00
|
|
|
if (!info) {
|
|
|
|
qapi_free_BlockDeviceInfoList(list);
|
|
|
|
return NULL;
|
2011-03-07 17:01:04 +01:00
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
entry = g_malloc0(sizeof(*entry));
|
|
|
|
entry->value = info;
|
|
|
|
entry->next = list;
|
|
|
|
list = entry;
|
2011-03-07 17:01:04 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
return list;
|
|
|
|
}
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
BlockDriverState *bdrv_lookup_bs(const char *device,
|
|
|
|
const char *node_name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
BlockBackend *blk;
|
|
|
|
BlockDriverState *bs;
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (device) {
|
|
|
|
blk = blk_by_name(device);
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (blk) {
|
2015-10-26 15:46:49 +01:00
|
|
|
bs = blk_bs(blk);
|
|
|
|
if (!bs) {
|
2015-10-19 17:53:29 +02:00
|
|
|
error_setg(errp, "Device '%s' has no medium", device);
|
|
|
|
}
|
|
|
|
|
2015-10-26 15:46:49 +01:00
|
|
|
return bs;
|
2015-04-28 15:27:52 +02:00
|
|
|
}
|
|
|
|
}
|
2009-09-09 17:53:37 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (node_name) {
|
|
|
|
bs = bdrv_find_node(node_name);
|
2010-05-22 19:15:08 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (bs) {
|
|
|
|
return bs;
|
|
|
|
}
|
2009-09-09 17:53:37 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
error_setg(errp, "Cannot find device=%s nor node_name=%s",
|
|
|
|
device ? device : "",
|
|
|
|
node_name ? node_name : "");
|
|
|
|
return NULL;
|
2009-09-09 17:53:37 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* If 'base' is in the same chain as 'top', return true. Otherwise,
|
|
|
|
* return false. If either argument is NULL, return false. */
|
|
|
|
bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
|
2006-08-01 18:21:11 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
while (top && top != base) {
|
2015-06-17 14:55:21 +02:00
|
|
|
top = backing_bs(top);
|
2014-09-11 07:41:09 +02:00
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
|
|
|
|
return top != NULL;
|
2014-09-11 07:41:09 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
BlockDriverState *bdrv_next_node(BlockDriverState *bs)
|
2014-09-11 07:41:09 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
if (!bs) {
|
|
|
|
return QTAILQ_FIRST(&graph_bdrv_states);
|
2014-09-11 07:41:09 +02:00
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
return QTAILQ_NEXT(bs, node_list);
|
2006-08-01 18:21:11 +02:00
|
|
|
}
|
|
|
|
|
2018-03-28 18:29:18 +02:00
|
|
|
BlockDriverState *bdrv_next_all_states(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
if (!bs) {
|
|
|
|
return QTAILQ_FIRST(&all_bdrv_states);
|
|
|
|
}
|
|
|
|
return QTAILQ_NEXT(bs, bs_list);
|
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
const char *bdrv_get_node_name(const BlockDriverState *bs)
|
2006-08-01 18:21:11 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
return bs->node_name;
|
2006-06-26 22:08:57 +02:00
|
|
|
}
|
|
|
|
|
2016-03-22 18:38:44 +01:00
|
|
|
const char *bdrv_get_parent_name(const BlockDriverState *bs)
|
2016-02-26 10:22:16 +01:00
|
|
|
{
|
|
|
|
BdrvChild *c;
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
/* If multiple parents have a name, just pick the first one. */
|
|
|
|
QLIST_FOREACH(c, &bs->parents, next_parent) {
|
|
|
|
if (c->role->get_name) {
|
|
|
|
name = c->role->get_name(c);
|
|
|
|
if (name && *name) {
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* TODO check what callers really want: bs->node_name or blk_name() */
|
|
|
|
const char *bdrv_get_device_name(const BlockDriverState *bs)
|
2006-06-26 22:08:57 +02:00
|
|
|
{
|
2016-02-26 10:22:16 +01:00
|
|
|
return bdrv_get_parent_name(bs) ?: "";
|
2009-04-07 20:43:24 +02:00
|
|
|
}
|
2006-08-01 18:21:11 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* This can be used to identify nodes that might not have a device
|
|
|
|
* name associated. Since node and device names live in the same
|
|
|
|
* namespace, the result is unambiguous. The exception is if both are
|
|
|
|
* absent, then this returns an empty (non-null) string. */
|
|
|
|
const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
|
2009-04-07 20:43:24 +02:00
|
|
|
{
|
2016-02-26 10:22:16 +01:00
|
|
|
return bdrv_get_parent_name(bs) ?: bs->node_name;
|
2006-06-26 22:08:57 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
int bdrv_get_flags(BlockDriverState *bs)
|
2015-03-28 07:37:18 +01:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
return bs->open_flags;
|
2015-03-28 07:37:18 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
int bdrv_has_zero_init_1(BlockDriverState *bs)
|
2011-06-30 10:05:46 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
return 1;
|
2015-03-28 07:37:18 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
int bdrv_has_zero_init(BlockDriverState *bs)
|
2015-03-28 07:37:18 +01:00
|
|
|
{
|
2017-11-10 21:31:09 +01:00
|
|
|
if (!bs->drv) {
|
|
|
|
return 0;
|
|
|
|
}
|
2015-03-28 07:37:18 +01:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* If BS is a copy on write image, it is initialized to
|
|
|
|
the contents of the base image, which may not be zeroes. */
|
2015-06-17 14:55:21 +02:00
|
|
|
if (bs->backing) {
|
2015-04-28 15:27:52 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (bs->drv->bdrv_has_zero_init) {
|
|
|
|
return bs->drv->bdrv_has_zero_init(bs);
|
2015-03-28 07:37:18 +01:00
|
|
|
}
|
2017-07-13 17:30:25 +02:00
|
|
|
if (bs->file && bs->drv->is_filter) {
|
|
|
|
return bdrv_has_zero_init(bs->file->bs);
|
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
|
|
|
|
/* safe default */
|
|
|
|
return 0;
|
2011-06-30 10:05:46 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
|
2011-10-13 14:08:23 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
BlockDriverInfo bdi;
|
2011-10-13 14:08:23 +02:00
|
|
|
|
2015-06-17 14:55:21 +02:00
|
|
|
if (bs->backing) {
|
2015-04-28 15:27:52 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bdrv_get_info(bs, &bdi) == 0) {
|
|
|
|
return bdi.unallocated_blocks_are_zero;
|
2011-10-13 14:08:23 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
return false;
|
2011-10-13 14:08:23 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
|
2011-06-30 10:05:46 +02:00
|
|
|
{
|
2016-07-14 15:33:26 +02:00
|
|
|
if (!(bs->open_flags & BDRV_O_UNMAP)) {
|
2015-04-28 15:27:52 +02:00
|
|
|
return false;
|
|
|
|
}
|
2011-06-30 10:05:46 +02:00
|
|
|
|
block: Simplify bdrv_can_write_zeroes_with_unmap()
We don't need the can_write_zeroes_with_unmap field in
BlockDriverInfo, because it is redundant information with
supported_zero_flags & BDRV_REQ_MAY_UNMAP. Note that
BlockDriverInfo and supported_zero_flags are both per-device
settings, rather than global state about the driver as a
whole, which means one or both of these bits of information
can already be conditional. Let's audit how they were set:
crypto: always setting can_write_ to false is pointless (the
struct starts life zero-initialized), no use of supported_
nbd: just recently fixed to set can_write_ if supported_
includes MAY_UNMAP (thus this commit effectively reverts
bca80059e and solves the problem mentioned there in a more
global way)
file-posix, iscsi, qcow2: can_write_ is conditional, while
supported_ was unconditional; but passing MAY_UNMAP would
fail with ENOTSUP if the condition wasn't met
qed: can_write_ is unconditional, but pwrite_zeroes lacks
support for MAY_UNMAP and supported_ is not set. Perhaps
support can be added later (since it would be similar to
qcow2), but for now claiming false is no real loss
all other drivers: can_write_ is not set, and supported_ is
either unset or a passthrough
Simplify the code by moving the conditional into
supported_zero_flags for all drivers, then dropping the
now-unused BDI field. For callers that relied on
bdrv_can_write_zeroes_with_unmap(), we return the same
per-device settings for drivers that had conditions (no
observable change in behavior there); and can now return
true (instead of false) for drivers that support passthrough
(for example, the commit driver) which gives those drivers
the same fix as nbd just got in bca80059e. For callers that
relied on supported_zero_flags, we now have a few more places
that can avoid a wasted call to pwrite_zeroes() that will
just fail with ENOTSUP.
Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20180126193439.20219-1-eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
2018-01-26 20:34:39 +01:00
|
|
|
return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP;
|
2011-06-30 10:05:46 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
|
2009-09-04 19:01:49 +02:00
|
|
|
{
|
2015-06-17 14:55:21 +02:00
|
|
|
if (bs->backing && bs->backing->bs->encrypted)
|
2015-04-28 15:27:52 +02:00
|
|
|
return bs->backing_file;
|
|
|
|
else if (bs->encrypted)
|
|
|
|
return bs->filename;
|
|
|
|
else
|
|
|
|
return NULL;
|
2009-09-04 19:01:49 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
void bdrv_get_backing_filename(BlockDriverState *bs,
|
|
|
|
char *filename, int filename_size)
|
2010-05-26 17:51:49 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
pstrcpy(filename, filename_size, bs->backing_file);
|
|
|
|
}
|
2012-11-13 16:35:08 +01:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
2017-07-13 17:30:25 +02:00
|
|
|
/* if bs->drv == NULL, bs is closed, so there's nothing to do here */
|
|
|
|
if (!drv) {
|
2015-04-28 15:27:52 +02:00
|
|
|
return -ENOMEDIUM;
|
2017-07-13 17:30:25 +02:00
|
|
|
}
|
|
|
|
if (!drv->bdrv_get_info) {
|
|
|
|
if (bs->file && drv->is_filter) {
|
|
|
|
return bdrv_get_info(bs->file->bs, bdi);
|
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
return -ENOTSUP;
|
2017-07-13 17:30:25 +02:00
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
memset(bdi, 0, sizeof(*bdi));
|
|
|
|
return drv->bdrv_get_info(bs, bdi);
|
|
|
|
}
|
2010-05-26 17:51:49 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
if (drv && drv->bdrv_get_specific_info) {
|
|
|
|
return drv->bdrv_get_specific_info(bs);
|
|
|
|
}
|
|
|
|
return NULL;
|
2010-05-26 17:51:49 +02:00
|
|
|
}
|
|
|
|
|
2015-11-18 09:52:54 +01:00
|
|
|
void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
|
2011-10-17 12:32:14 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
|
|
|
|
return;
|
|
|
|
}
|
2011-10-17 12:32:14 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
bs->drv->bdrv_debug_event(bs, event);
|
2011-10-17 12:32:14 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
|
|
|
|
const char *tag)
|
2011-10-17 12:32:14 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
|
2015-06-16 14:19:22 +02:00
|
|
|
bs = bs->file ? bs->file->bs : NULL;
|
2015-04-28 15:27:52 +02:00
|
|
|
}
|
2011-10-17 12:32:14 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
|
|
|
|
return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
|
|
|
|
}
|
2011-10-17 12:32:14 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
return -ENOTSUP;
|
2011-10-17 12:32:14 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
|
2004-08-01 23:59:26 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
|
2015-06-16 14:19:22 +02:00
|
|
|
bs = bs->file ? bs->file->bs : NULL;
|
2015-04-28 15:27:52 +02:00
|
|
|
}
|
2006-08-07 04:38:06 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
|
|
|
|
return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOTSUP;
|
2009-10-27 18:41:44 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
|
2006-08-07 04:38:06 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
|
2015-06-16 14:19:22 +02:00
|
|
|
bs = bs->file ? bs->file->bs : NULL;
|
2015-04-28 15:27:52 +02:00
|
|
|
}
|
2006-08-07 04:38:06 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
|
|
|
|
return bs->drv->bdrv_debug_resume(bs, tag);
|
|
|
|
}
|
2006-08-07 04:38:06 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
return -ENOTSUP;
|
2014-09-11 07:41:08 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
|
2006-08-07 04:38:06 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
|
2015-06-16 14:19:22 +02:00
|
|
|
bs = bs->file ? bs->file->bs : NULL;
|
2014-09-11 07:41:08 +02:00
|
|
|
}
|
2006-08-19 13:45:59 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
|
|
|
|
return bs->drv->bdrv_debug_is_suspended(bs, tag);
|
|
|
|
}
|
2011-07-15 13:50:26 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
return false;
|
|
|
|
}
|
2011-07-15 13:50:26 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* backing_file can either be relative, or absolute, or a protocol. If it is
|
|
|
|
* relative, it must be relative to the chain. So, passing in bs->filename
|
|
|
|
* from a BDS as backing_file should not be done, as that may be relative to
|
|
|
|
* the CWD rather than the chain. */
|
|
|
|
BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
|
|
|
|
const char *backing_file)
|
2011-07-15 13:50:26 +02:00
|
|
|
{
|
2015-04-28 15:27:52 +02:00
|
|
|
char *filename_full = NULL;
|
|
|
|
char *backing_file_full = NULL;
|
|
|
|
char *filename_tmp = NULL;
|
|
|
|
int is_protocol = 0;
|
|
|
|
BlockDriverState *curr_bs = NULL;
|
|
|
|
BlockDriverState *retval = NULL;
|
2017-01-26 02:08:20 +01:00
|
|
|
Error *local_error = NULL;
|
2011-07-15 13:50:26 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (!bs || !bs->drv || !backing_file) {
|
|
|
|
return NULL;
|
2011-07-15 13:50:26 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
filename_full = g_malloc(PATH_MAX);
|
|
|
|
backing_file_full = g_malloc(PATH_MAX);
|
|
|
|
filename_tmp = g_malloc(PATH_MAX);
|
2011-07-15 13:50:26 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
is_protocol = path_has_protocol(backing_file);
|
2011-07-15 13:50:26 +02:00
|
|
|
|
2015-06-17 14:55:21 +02:00
|
|
|
for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
|
2011-07-15 13:50:26 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* If either of the filename paths is actually a protocol, then
|
|
|
|
* compare unmodified paths; otherwise make paths relative */
|
|
|
|
if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
|
|
|
|
if (strcmp(backing_file, curr_bs->backing_file) == 0) {
|
2015-06-17 14:55:21 +02:00
|
|
|
retval = curr_bs->backing->bs;
|
2015-04-28 15:27:52 +02:00
|
|
|
break;
|
|
|
|
}
|
2017-01-26 02:08:20 +01:00
|
|
|
/* Also check against the full backing filename for the image */
|
|
|
|
bdrv_get_full_backing_filename(curr_bs, backing_file_full, PATH_MAX,
|
|
|
|
&local_error);
|
|
|
|
if (local_error == NULL) {
|
|
|
|
if (strcmp(backing_file, backing_file_full) == 0) {
|
|
|
|
retval = curr_bs->backing->bs;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
error_free(local_error);
|
|
|
|
local_error = NULL;
|
|
|
|
}
|
2015-04-28 15:27:52 +02:00
|
|
|
} else {
|
|
|
|
/* If not an absolute filename path, make it relative to the current
|
|
|
|
* image's filename path */
|
|
|
|
path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
|
|
|
|
backing_file);
|
2011-07-15 13:50:26 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* We are going to compare absolute pathnames */
|
|
|
|
if (!realpath(filename_tmp, filename_full)) {
|
|
|
|
continue;
|
|
|
|
}
|
2011-10-17 12:32:12 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
/* We need to make sure the backing filename we are comparing against
|
|
|
|
* is relative to the current image filename (or absolute) */
|
|
|
|
path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
|
|
|
|
curr_bs->backing_file);
|
2011-10-17 12:32:12 +02:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (!realpath(filename_tmp, backing_file_full)) {
|
|
|
|
continue;
|
|
|
|
}
|
2011-11-10 18:10:11 +01:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
if (strcmp(backing_file_full, filename_full) == 0) {
|
2015-06-17 14:55:21 +02:00
|
|
|
retval = curr_bs->backing->bs;
|
2015-04-28 15:27:52 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-11-10 18:10:11 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
g_free(filename_full);
|
|
|
|
g_free(backing_file_full);
|
|
|
|
g_free(filename_tmp);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_init(void)
|
|
|
|
{
|
|
|
|
module_call_init(MODULE_INIT_BLOCK);
|
|
|
|
}
|
2012-03-12 18:26:01 +01:00
|
|
|
|
2015-04-28 15:27:52 +02:00
|
|
|
void bdrv_init_with_whitelist(void)
|
|
|
|
{
|
|
|
|
use_bdrv_whitelist = 1;
|
|
|
|
bdrv_init();
|
2011-10-17 12:32:12 +02:00
|
|
|
}
|
|
|
|
|
2018-03-01 17:36:18 +01:00
|
|
|
static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
|
|
|
|
Error **errp)
|
2011-11-14 22:09:45 +01:00
|
|
|
{
|
2017-05-04 18:52:37 +02:00
|
|
|
BdrvChild *child, *parent;
|
2017-05-04 18:52:40 +02:00
|
|
|
uint64_t perm, shared_perm;
|
2014-03-12 15:59:16 +01:00
|
|
|
Error *local_err = NULL;
|
|
|
|
int ret;
|
dirty-bitmaps: clean-up bitmaps loading and migration logic
This patch aims to bring the following behavior:
1. We don't load bitmaps, when started in inactive mode. It's the case
of incoming migration. In this case we wait for bitmaps migration
through migration channel (if 'dirty-bitmaps' capability is enabled) or
for invalidation (to load bitmaps from the image).
2. We don't remove persistent bitmaps on inactivation. Instead, we only
remove bitmaps after storing. This is the only way to restore bitmaps,
if we decided to resume source after [failed] migration with
'dirty-bitmaps' capability enabled (which means, that bitmaps were not
stored).
3. We load bitmaps on open and any invalidation, it's ok for all cases:
- normal open
- migration target invalidation with dirty-bitmaps capability
(bitmaps are migrating through migration channel, the are not
stored, so they should have IN_USE flag set and will be skipped
when loading. However, it would fail if bitmaps are read-only[1])
- migration target invalidation without dirty-bitmaps capability
(normal load of the bitmaps, if migrated with shared storage)
- source invalidation with dirty-bitmaps capability
(skip because IN_USE)
- source invalidation without dirty-bitmaps capability
(bitmaps were dropped, reload them)
[1]: to accurately handle this, migration of read-only bitmaps is
explicitly forbidden in this patch.
New mechanism for not storing bitmaps when migrate with dirty-bitmaps
capability is introduced: migration filed in BdrvDirtyBitmap.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: John Snow <jsnow@redhat.com>
2018-10-29 21:23:17 +01:00
|
|
|
BdrvDirtyBitmap *bm;
|
2014-03-12 15:59:16 +01:00
|
|
|
|
2014-03-11 10:58:39 +01:00
|
|
|
if (!bs->drv) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-01-13 15:56:06 +01:00
|
|
|
if (!(bs->open_flags & BDRV_O_INACTIVE)) {
|
2014-10-09 04:50:46 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-01-31 12:23:08 +01:00
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
2018-03-01 17:36:18 +01:00
|
|
|
bdrv_co_invalidate_cache(child->bs, &local_err);
|
2016-05-11 04:45:33 +02:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2014-03-12 15:59:16 +01:00
|
|
|
}
|
2016-05-11 04:45:33 +02:00
|
|
|
|
2017-11-16 13:00:01 +01:00
|
|
|
/*
|
|
|
|
* Update permissions, they may differ for inactive nodes.
|
|
|
|
*
|
|
|
|
* Note that the required permissions of inactive images are always a
|
|
|
|
* subset of the permissions required after activating the image. This
|
|
|
|
* allows us to just get the permissions upfront without restricting
|
|
|
|
* drv->bdrv_invalidate_cache().
|
|
|
|
*
|
|
|
|
* It also means that in error cases, we don't have to try and revert to
|
|
|
|
* the old permissions (which is an operation that could fail, too). We can
|
|
|
|
* just keep the extended permissions for the next time that an activation
|
|
|
|
* of the image is tried.
|
|
|
|
*/
|
2017-01-31 12:23:08 +01:00
|
|
|
bs->open_flags &= ~BDRV_O_INACTIVE;
|
2017-11-16 13:00:01 +01:00
|
|
|
bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
|
|
|
|
ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err);
|
|
|
|
if (ret < 0) {
|
|
|
|
bs->open_flags |= BDRV_O_INACTIVE;
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
bdrv_set_perm(bs, perm, shared_perm);
|
|
|
|
|
2018-03-01 17:36:18 +01:00
|
|
|
if (bs->drv->bdrv_co_invalidate_cache) {
|
|
|
|
bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
|
2016-05-11 04:45:33 +02:00
|
|
|
if (local_err) {
|
|
|
|
bs->open_flags |= BDRV_O_INACTIVE;
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2011-11-14 22:09:45 +01:00
|
|
|
}
|
2014-03-11 10:58:39 +01:00
|
|
|
|
dirty-bitmaps: clean-up bitmaps loading and migration logic
This patch aims to bring the following behavior:
1. We don't load bitmaps, when started in inactive mode. It's the case
of incoming migration. In this case we wait for bitmaps migration
through migration channel (if 'dirty-bitmaps' capability is enabled) or
for invalidation (to load bitmaps from the image).
2. We don't remove persistent bitmaps on inactivation. Instead, we only
remove bitmaps after storing. This is the only way to restore bitmaps,
if we decided to resume source after [failed] migration with
'dirty-bitmaps' capability enabled (which means, that bitmaps were not
stored).
3. We load bitmaps on open and any invalidation, it's ok for all cases:
- normal open
- migration target invalidation with dirty-bitmaps capability
(bitmaps are migrating through migration channel, the are not
stored, so they should have IN_USE flag set and will be skipped
when loading. However, it would fail if bitmaps are read-only[1])
- migration target invalidation without dirty-bitmaps capability
(normal load of the bitmaps, if migrated with shared storage)
- source invalidation with dirty-bitmaps capability
(skip because IN_USE)
- source invalidation without dirty-bitmaps capability
(bitmaps were dropped, reload them)
[1]: to accurately handle this, migration of read-only bitmaps is
explicitly forbidden in this patch.
New mechanism for not storing bitmaps when migrate with dirty-bitmaps
capability is introduced: migration filed in BdrvDirtyBitmap.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: John Snow <jsnow@redhat.com>
2018-10-29 21:23:17 +01:00
|
|
|
for (bm = bdrv_dirty_bitmap_next(bs, NULL); bm;
|
|
|
|
bm = bdrv_dirty_bitmap_next(bs, bm))
|
|
|
|
{
|
|
|
|
bdrv_dirty_bitmap_set_migration(bm, false);
|
|
|
|
}
|
|
|
|
|
2014-03-12 15:59:16 +01:00
|
|
|
ret = refresh_total_sectors(bs, bs->total_sectors);
|
|
|
|
if (ret < 0) {
|
2016-01-13 15:56:06 +01:00
|
|
|
bs->open_flags |= BDRV_O_INACTIVE;
|
2014-03-12 15:59:16 +01:00
|
|
|
error_setg_errno(errp, -ret, "Could not refresh total sector count");
|
|
|
|
return;
|
|
|
|
}
|
2017-05-04 18:52:37 +02:00
|
|
|
|
|
|
|
QLIST_FOREACH(parent, &bs->parents, next_parent) {
|
|
|
|
if (parent->role->activate) {
|
|
|
|
parent->role->activate(parent, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-11-14 22:09:45 +01:00
|
|
|
}
|
|
|
|
|
2018-03-01 17:36:18 +01:00
|
|
|
typedef struct InvalidateCacheCo {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
Error **errp;
|
|
|
|
bool done;
|
|
|
|
} InvalidateCacheCo;
|
|
|
|
|
|
|
|
static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque)
|
|
|
|
{
|
|
|
|
InvalidateCacheCo *ico = opaque;
|
|
|
|
bdrv_co_invalidate_cache(ico->bs, ico->errp);
|
|
|
|
ico->done = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
|
|
|
|
{
|
|
|
|
Coroutine *co;
|
|
|
|
InvalidateCacheCo ico = {
|
|
|
|
.bs = bs,
|
|
|
|
.done = false,
|
|
|
|
.errp = errp
|
|
|
|
};
|
|
|
|
|
|
|
|
if (qemu_in_coroutine()) {
|
|
|
|
/* Fast-path if already in coroutine context */
|
|
|
|
bdrv_invalidate_cache_co_entry(&ico);
|
|
|
|
} else {
|
|
|
|
co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico);
|
|
|
|
qemu_coroutine_enter(co);
|
|
|
|
BDRV_POLL_WHILE(bs, !ico.done);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-12 15:59:16 +01:00
|
|
|
void bdrv_invalidate_cache_all(Error **errp)
|
2011-11-14 22:09:45 +01:00
|
|
|
{
|
2016-03-22 18:58:50 +01:00
|
|
|
BlockDriverState *bs;
|
2014-03-12 15:59:16 +01:00
|
|
|
Error *local_err = NULL;
|
2016-05-20 18:49:07 +02:00
|
|
|
BdrvNextIterator it;
|
2011-11-14 22:09:45 +01:00
|
|
|
|
2016-05-20 18:49:07 +02:00
|
|
|
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
|
2014-05-08 16:34:35 +02:00
|
|
|
AioContext *aio_context = bdrv_get_aio_context(bs);
|
|
|
|
|
|
|
|
aio_context_acquire(aio_context);
|
2014-03-12 15:59:16 +01:00
|
|
|
bdrv_invalidate_cache(bs, &local_err);
|
2014-05-08 16:34:35 +02:00
|
|
|
aio_context_release(aio_context);
|
2014-03-12 15:59:16 +01:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
2017-11-10 18:25:45 +01:00
|
|
|
bdrv_next_cleanup(&it);
|
2014-03-12 15:59:16 +01:00
|
|
|
return;
|
|
|
|
}
|
2011-11-14 22:09:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-11 04:45:35 +02:00
|
|
|
static int bdrv_inactivate_recurse(BlockDriverState *bs,
|
|
|
|
bool setting_flag)
|
2015-12-22 14:07:08 +01:00
|
|
|
{
|
2017-05-04 18:52:38 +02:00
|
|
|
BdrvChild *child, *parent;
|
2015-12-22 14:07:08 +01:00
|
|
|
int ret;
|
|
|
|
|
2017-11-10 21:31:09 +01:00
|
|
|
if (!bs->drv) {
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
|
2016-05-11 04:45:35 +02:00
|
|
|
if (!setting_flag && bs->drv->bdrv_inactivate) {
|
2015-12-22 14:07:08 +01:00
|
|
|
ret = bs->drv->bdrv_inactivate(bs);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-23 15:42:42 +02:00
|
|
|
if (setting_flag && !(bs->open_flags & BDRV_O_INACTIVE)) {
|
2017-05-04 18:52:40 +02:00
|
|
|
uint64_t perm, shared_perm;
|
|
|
|
|
2017-05-04 18:52:38 +02:00
|
|
|
QLIST_FOREACH(parent, &bs->parents, next_parent) {
|
|
|
|
if (parent->role->inactivate) {
|
|
|
|
ret = parent->role->inactivate(parent);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-05-04 18:52:40 +02:00
|
|
|
|
2017-08-23 15:42:42 +02:00
|
|
|
bs->open_flags |= BDRV_O_INACTIVE;
|
|
|
|
|
2017-05-04 18:52:40 +02:00
|
|
|
/* Update permissions, they may differ for inactive nodes */
|
|
|
|
bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
|
2017-09-14 14:42:12 +02:00
|
|
|
bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &error_abort);
|
2017-05-04 18:52:40 +02:00
|
|
|
bdrv_set_perm(bs, perm, shared_perm);
|
2016-05-11 04:45:35 +02:00
|
|
|
}
|
2017-05-04 18:52:39 +02:00
|
|
|
|
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
ret = bdrv_inactivate_recurse(child->bs, setting_flag);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-22 14:07:08 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bdrv_inactivate_all(void)
|
|
|
|
{
|
2016-03-16 19:54:44 +01:00
|
|
|
BlockDriverState *bs = NULL;
|
2016-05-20 18:49:07 +02:00
|
|
|
BdrvNextIterator it;
|
2016-05-11 04:45:35 +02:00
|
|
|
int ret = 0;
|
|
|
|
int pass;
|
block: avoid recursive AioContext acquire in bdrv_inactivate_all()
BDRV_POLL_WHILE() does not support recursive AioContext locking. It
only releases the AioContext lock once regardless of how many times the
caller has acquired it. This results in a hang since the IOThread does
not make progress while the AioContext is still locked.
The following steps trigger the hang:
$ qemu-system-x86_64 -M accel=kvm -m 1G -cpu host \
-object iothread,id=iothread0 \
-device virtio-scsi-pci,iothread=iothread0 \
-drive if=none,id=drive0,file=test.img,format=raw \
-device scsi-hd,drive=drive0 \
-drive if=none,id=drive1,file=test.img,format=raw \
-device scsi-hd,drive=drive1
$ qemu-system-x86_64 ...same options... \
-incoming tcp::1234
(qemu) migrate tcp:127.0.0.1:1234
...hang...
Tested-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20171207201320.19284-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-12-07 21:13:15 +01:00
|
|
|
GSList *aio_ctxs = NULL, *ctx;
|
2015-12-22 14:07:08 +01:00
|
|
|
|
2016-05-20 18:49:07 +02:00
|
|
|
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
|
block: avoid recursive AioContext acquire in bdrv_inactivate_all()
BDRV_POLL_WHILE() does not support recursive AioContext locking. It
only releases the AioContext lock once regardless of how many times the
caller has acquired it. This results in a hang since the IOThread does
not make progress while the AioContext is still locked.
The following steps trigger the hang:
$ qemu-system-x86_64 -M accel=kvm -m 1G -cpu host \
-object iothread,id=iothread0 \
-device virtio-scsi-pci,iothread=iothread0 \
-drive if=none,id=drive0,file=test.img,format=raw \
-device scsi-hd,drive=drive0 \
-drive if=none,id=drive1,file=test.img,format=raw \
-device scsi-hd,drive=drive1
$ qemu-system-x86_64 ...same options... \
-incoming tcp::1234
(qemu) migrate tcp:127.0.0.1:1234
...hang...
Tested-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20171207201320.19284-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-12-07 21:13:15 +01:00
|
|
|
AioContext *aio_context = bdrv_get_aio_context(bs);
|
|
|
|
|
|
|
|
if (!g_slist_find(aio_ctxs, aio_context)) {
|
|
|
|
aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
|
|
|
|
aio_context_acquire(aio_context);
|
|
|
|
}
|
2016-05-11 04:45:35 +02:00
|
|
|
}
|
2015-12-22 14:07:08 +01:00
|
|
|
|
2016-05-11 04:45:35 +02:00
|
|
|
/* We do two passes of inactivation. The first pass calls to drivers'
|
|
|
|
* .bdrv_inactivate callbacks recursively so all cache is flushed to disk;
|
|
|
|
* the second pass sets the BDRV_O_INACTIVE flag so that no further write
|
|
|
|
* is allowed. */
|
|
|
|
for (pass = 0; pass < 2; pass++) {
|
2016-05-20 18:49:07 +02:00
|
|
|
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
|
2016-05-11 04:45:35 +02:00
|
|
|
ret = bdrv_inactivate_recurse(bs, pass);
|
|
|
|
if (ret < 0) {
|
2017-11-10 18:25:45 +01:00
|
|
|
bdrv_next_cleanup(&it);
|
2016-05-11 04:45:35 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2015-12-22 14:07:08 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-11 04:45:35 +02:00
|
|
|
out:
|
block: avoid recursive AioContext acquire in bdrv_inactivate_all()
BDRV_POLL_WHILE() does not support recursive AioContext locking. It
only releases the AioContext lock once regardless of how many times the
caller has acquired it. This results in a hang since the IOThread does
not make progress while the AioContext is still locked.
The following steps trigger the hang:
$ qemu-system-x86_64 -M accel=kvm -m 1G -cpu host \
-object iothread,id=iothread0 \
-device virtio-scsi-pci,iothread=iothread0 \
-drive if=none,id=drive0,file=test.img,format=raw \
-device scsi-hd,drive=drive0 \
-drive if=none,id=drive1,file=test.img,format=raw \
-device scsi-hd,drive=drive1
$ qemu-system-x86_64 ...same options... \
-incoming tcp::1234
(qemu) migrate tcp:127.0.0.1:1234
...hang...
Tested-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20171207201320.19284-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-12-07 21:13:15 +01:00
|
|
|
for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
|
|
|
|
AioContext *aio_context = ctx->data;
|
|
|
|
aio_context_release(aio_context);
|
2016-05-11 04:45:35 +02:00
|
|
|
}
|
block: avoid recursive AioContext acquire in bdrv_inactivate_all()
BDRV_POLL_WHILE() does not support recursive AioContext locking. It
only releases the AioContext lock once regardless of how many times the
caller has acquired it. This results in a hang since the IOThread does
not make progress while the AioContext is still locked.
The following steps trigger the hang:
$ qemu-system-x86_64 -M accel=kvm -m 1G -cpu host \
-object iothread,id=iothread0 \
-device virtio-scsi-pci,iothread=iothread0 \
-drive if=none,id=drive0,file=test.img,format=raw \
-device scsi-hd,drive=drive0 \
-drive if=none,id=drive1,file=test.img,format=raw \
-device scsi-hd,drive=drive1
$ qemu-system-x86_64 ...same options... \
-incoming tcp::1234
(qemu) migrate tcp:127.0.0.1:1234
...hang...
Tested-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20171207201320.19284-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2017-12-07 21:13:15 +01:00
|
|
|
g_slist_free(aio_ctxs);
|
2016-05-11 04:45:35 +02:00
|
|
|
|
|
|
|
return ret;
|
2015-12-22 14:07:08 +01:00
|
|
|
}
|
|
|
|
|
2006-08-19 13:45:59 +02:00
|
|
|
/**************************************************************/
|
|
|
|
/* removable device support */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return TRUE if the media is present
|
|
|
|
*/
|
2015-10-19 17:53:11 +02:00
|
|
|
bool bdrv_is_inserted(BlockDriverState *bs)
|
2006-08-19 13:45:59 +02:00
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
2015-10-19 17:53:13 +02:00
|
|
|
BdrvChild *child;
|
2011-09-06 18:58:41 +02:00
|
|
|
|
2015-10-19 17:53:11 +02:00
|
|
|
if (!drv) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-10-19 17:53:13 +02:00
|
|
|
if (drv->bdrv_is_inserted) {
|
|
|
|
return drv->bdrv_is_inserted(bs);
|
|
|
|
}
|
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
if (!bdrv_is_inserted(child->bs)) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-10-19 17:53:11 +02:00
|
|
|
}
|
2015-10-19 17:53:13 +02:00
|
|
|
return true;
|
2006-08-19 13:45:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* If eject_flag is TRUE, eject the media. Otherwise, close the tray
|
|
|
|
*/
|
2012-02-03 19:24:53 +01:00
|
|
|
void bdrv_eject(BlockDriverState *bs, bool eject_flag)
|
2006-08-19 13:45:59 +02:00
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
|
2011-07-20 18:23:42 +02:00
|
|
|
if (drv && drv->bdrv_eject) {
|
|
|
|
drv->bdrv_eject(bs, eject_flag);
|
2006-08-19 13:45:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Lock or unlock the media (if it is locked, the user won't be able
|
|
|
|
* to eject it manually).
|
|
|
|
*/
|
2011-09-06 18:58:47 +02:00
|
|
|
void bdrv_lock_medium(BlockDriverState *bs, bool locked)
|
2006-08-19 13:45:59 +02:00
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
|
2011-09-06 18:58:47 +02:00
|
|
|
trace_bdrv_lock_medium(bs, locked);
|
2011-03-29 21:04:40 +02:00
|
|
|
|
2011-09-06 18:58:47 +02:00
|
|
|
if (drv && drv->bdrv_lock_medium) {
|
|
|
|
drv->bdrv_lock_medium(bs, locked);
|
2006-08-19 13:45:59 +02:00
|
|
|
}
|
|
|
|
}
|
2007-12-24 17:10:43 +01:00
|
|
|
|
2013-08-23 03:14:46 +02:00
|
|
|
/* Get a reference to bs */
|
|
|
|
void bdrv_ref(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
bs->refcnt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Release a previously grabbed reference to bs.
|
|
|
|
* If after releasing, reference count is zero, the BlockDriverState is
|
|
|
|
* deleted. */
|
|
|
|
void bdrv_unref(BlockDriverState *bs)
|
|
|
|
{
|
2014-07-23 23:22:57 +02:00
|
|
|
if (!bs) {
|
|
|
|
return;
|
|
|
|
}
|
2013-08-23 03:14:46 +02:00
|
|
|
assert(bs->refcnt > 0);
|
|
|
|
if (--bs->refcnt == 0) {
|
|
|
|
bdrv_delete(bs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-23 15:29:42 +02:00
|
|
|
struct BdrvOpBlocker {
|
|
|
|
Error *reason;
|
|
|
|
QLIST_ENTRY(BdrvOpBlocker) list;
|
|
|
|
};
|
|
|
|
|
|
|
|
bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
|
|
|
|
{
|
|
|
|
BdrvOpBlocker *blocker;
|
|
|
|
assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
|
|
|
|
if (!QLIST_EMPTY(&bs->op_blockers[op])) {
|
|
|
|
blocker = QLIST_FIRST(&bs->op_blockers[op]);
|
2018-10-17 10:26:25 +02:00
|
|
|
error_propagate_prepend(errp, error_copy(blocker->reason),
|
|
|
|
"Node '%s' is busy: ",
|
|
|
|
bdrv_get_device_or_node_name(bs));
|
2014-05-23 15:29:42 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
|
|
|
|
{
|
|
|
|
BdrvOpBlocker *blocker;
|
|
|
|
assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
|
|
|
|
|
block: Use g_new() & friends where that makes obvious sense
g_new(T, n) is neater than g_malloc(sizeof(T) * n). It's also safer,
for two reasons. One, it catches multiplication overflowing size_t.
Two, it returns T * rather than void *, which lets the compiler catch
more type errors.
Patch created with Coccinelle, with two manual changes on top:
* Add const to bdrv_iterate_format() to keep the types straight
* Convert the allocation in bdrv_drop_intermediate(), which Coccinelle
inexplicably misses
Coccinelle semantic patch:
@@
type T;
@@
-g_malloc(sizeof(T))
+g_new(T, 1)
@@
type T;
@@
-g_try_malloc(sizeof(T))
+g_try_new(T, 1)
@@
type T;
@@
-g_malloc0(sizeof(T))
+g_new0(T, 1)
@@
type T;
@@
-g_try_malloc0(sizeof(T))
+g_try_new0(T, 1)
@@
type T;
expression n;
@@
-g_malloc(sizeof(T) * (n))
+g_new(T, n)
@@
type T;
expression n;
@@
-g_try_malloc(sizeof(T) * (n))
+g_try_new(T, n)
@@
type T;
expression n;
@@
-g_malloc0(sizeof(T) * (n))
+g_new0(T, n)
@@
type T;
expression n;
@@
-g_try_malloc0(sizeof(T) * (n))
+g_try_new0(T, n)
@@
type T;
expression p, n;
@@
-g_realloc(p, sizeof(T) * (n))
+g_renew(T, p, n)
@@
type T;
expression p, n;
@@
-g_try_realloc(p, sizeof(T) * (n))
+g_try_renew(T, p, n)
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-08-19 10:31:08 +02:00
|
|
|
blocker = g_new0(BdrvOpBlocker, 1);
|
2014-05-23 15:29:42 +02:00
|
|
|
blocker->reason = reason;
|
|
|
|
QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
|
|
|
|
{
|
|
|
|
BdrvOpBlocker *blocker, *next;
|
|
|
|
assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
|
|
|
|
QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
|
|
|
|
if (blocker->reason == reason) {
|
|
|
|
QLIST_REMOVE(blocker, list);
|
|
|
|
g_free(blocker);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
|
|
|
|
bdrv_op_block(bs, i, reason);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
|
|
|
|
bdrv_op_unblock(bs, i, reason);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
|
|
|
|
if (!QLIST_EMPTY(&bs->op_blockers[i])) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-11-30 13:52:09 +01:00
|
|
|
void bdrv_img_create(const char *filename, const char *fmt,
|
|
|
|
const char *base_filename, const char *base_fmt,
|
2017-04-21 14:27:01 +02:00
|
|
|
char *options, uint64_t img_size, int flags, bool quiet,
|
|
|
|
Error **errp)
|
2010-12-16 13:52:15 +01:00
|
|
|
{
|
2014-06-05 11:20:51 +02:00
|
|
|
QemuOptsList *create_opts = NULL;
|
|
|
|
QemuOpts *opts = NULL;
|
|
|
|
const char *backing_fmt, *backing_file;
|
|
|
|
int64_t size;
|
2010-12-16 13:52:15 +01:00
|
|
|
BlockDriver *drv, *proto_drv;
|
2013-09-06 17:14:26 +02:00
|
|
|
Error *local_err = NULL;
|
2010-12-16 13:52:15 +01:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* Find driver and parse its options */
|
|
|
|
drv = bdrv_find_format(fmt);
|
|
|
|
if (!drv) {
|
2012-11-30 13:52:04 +01:00
|
|
|
error_setg(errp, "Unknown file format '%s'", fmt);
|
2012-11-30 13:52:09 +01:00
|
|
|
return;
|
2010-12-16 13:52:15 +01:00
|
|
|
}
|
|
|
|
|
2015-02-05 19:58:12 +01:00
|
|
|
proto_drv = bdrv_find_protocol(filename, true, errp);
|
2010-12-16 13:52:15 +01:00
|
|
|
if (!proto_drv) {
|
2012-11-30 13:52:09 +01:00
|
|
|
return;
|
2010-12-16 13:52:15 +01:00
|
|
|
}
|
|
|
|
|
2014-12-02 18:32:45 +01:00
|
|
|
if (!drv->create_opts) {
|
|
|
|
error_setg(errp, "Format driver '%s' does not support image creation",
|
|
|
|
drv->format_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!proto_drv->create_opts) {
|
|
|
|
error_setg(errp, "Protocol driver '%s' does not support image creation",
|
|
|
|
proto_drv->format_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-06-05 11:21:11 +02:00
|
|
|
create_opts = qemu_opts_append(create_opts, drv->create_opts);
|
|
|
|
create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
|
2010-12-16 13:52:15 +01:00
|
|
|
|
|
|
|
/* Create parameter list with default values */
|
2014-06-05 11:20:51 +02:00
|
|
|
opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
|
2015-02-12 16:46:36 +01:00
|
|
|
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
|
2010-12-16 13:52:15 +01:00
|
|
|
|
|
|
|
/* Parse -o options */
|
|
|
|
if (options) {
|
2015-02-12 18:37:11 +01:00
|
|
|
qemu_opts_do_parse(opts, options, NULL, &local_err);
|
|
|
|
if (local_err) {
|
2010-12-16 13:52:15 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (base_filename) {
|
2015-02-12 17:52:20 +01:00
|
|
|
qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
|
2015-02-12 17:49:02 +01:00
|
|
|
if (local_err) {
|
2012-11-30 13:52:04 +01:00
|
|
|
error_setg(errp, "Backing file not supported for file format '%s'",
|
|
|
|
fmt);
|
2010-12-16 13:52:15 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (base_fmt) {
|
2015-02-12 17:52:20 +01:00
|
|
|
qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
|
2015-02-12 17:49:02 +01:00
|
|
|
if (local_err) {
|
2012-11-30 13:52:04 +01:00
|
|
|
error_setg(errp, "Backing file format not supported for file "
|
|
|
|
"format '%s'", fmt);
|
2010-12-16 13:52:15 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-05 11:20:51 +02:00
|
|
|
backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
|
|
|
|
if (backing_file) {
|
|
|
|
if (!strcmp(filename, backing_file)) {
|
2012-11-30 13:52:04 +01:00
|
|
|
error_setg(errp, "Error: Trying to create an image with the "
|
|
|
|
"same filename as the backing file");
|
2010-12-16 13:52:17 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-05 11:20:51 +02:00
|
|
|
backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
|
2010-12-16 13:52:15 +01:00
|
|
|
|
2017-07-18 02:34:22 +02:00
|
|
|
/* The size for the image must always be specified, unless we have a backing
|
|
|
|
* file and we have not been forbidden from opening it. */
|
2017-09-25 16:55:07 +02:00
|
|
|
size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
|
2017-07-18 02:34:22 +02:00
|
|
|
if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
char *full_backing = g_new0(char, PATH_MAX);
|
|
|
|
int back_flags;
|
|
|
|
QDict *backing_options = NULL;
|
|
|
|
|
|
|
|
bdrv_get_full_backing_filename_from_filename(filename, backing_file,
|
|
|
|
full_backing, PATH_MAX,
|
|
|
|
&local_err);
|
|
|
|
if (local_err) {
|
|
|
|
g_free(full_backing);
|
|
|
|
goto out;
|
|
|
|
}
|
2014-11-26 17:20:27 +01:00
|
|
|
|
2017-07-18 02:34:22 +02:00
|
|
|
/* backing files always opened read-only */
|
|
|
|
back_flags = flags;
|
|
|
|
back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
|
2010-12-16 13:52:15 +01:00
|
|
|
|
2017-12-15 09:04:45 +01:00
|
|
|
backing_options = qdict_new();
|
2017-07-18 02:34:22 +02:00
|
|
|
if (backing_fmt) {
|
|
|
|
qdict_put_str(backing_options, "driver", backing_fmt);
|
|
|
|
}
|
2017-12-15 09:04:45 +01:00
|
|
|
qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
|
2015-08-26 19:47:48 +02:00
|
|
|
|
2017-07-18 02:34:22 +02:00
|
|
|
bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
|
|
|
|
&local_err);
|
|
|
|
g_free(full_backing);
|
|
|
|
if (!bs && size != -1) {
|
|
|
|
/* Couldn't open BS, but we have a size, so it's nonfatal */
|
|
|
|
warn_reportf_err(local_err,
|
|
|
|
"Could not verify backing image. "
|
|
|
|
"This may become an error in future versions.\n");
|
|
|
|
local_err = NULL;
|
|
|
|
} else if (!bs) {
|
|
|
|
/* Couldn't open bs, do not have size */
|
|
|
|
error_append_hint(&local_err,
|
|
|
|
"Could not open backing image to determine size.\n");
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
if (size == -1) {
|
|
|
|
/* Opened BS, have no size */
|
|
|
|
size = bdrv_getlength(bs);
|
|
|
|
if (size < 0) {
|
|
|
|
error_setg_errno(errp, -size, "Could not get size of '%s'",
|
|
|
|
backing_file);
|
|
|
|
bdrv_unref(bs);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
|
2014-06-26 13:23:25 +02:00
|
|
|
}
|
2013-12-03 14:57:52 +01:00
|
|
|
bdrv_unref(bs);
|
2010-12-16 13:52:15 +01:00
|
|
|
}
|
2017-07-18 02:34:22 +02:00
|
|
|
} /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */
|
|
|
|
|
|
|
|
if (size == -1) {
|
|
|
|
error_setg(errp, "Image creation needs a size parameter");
|
|
|
|
goto out;
|
2010-12-16 13:52:15 +01:00
|
|
|
}
|
|
|
|
|
2013-02-13 09:09:40 +01:00
|
|
|
if (!quiet) {
|
2015-07-07 16:42:10 +02:00
|
|
|
printf("Formatting '%s', fmt=%s ", filename, fmt);
|
2014-12-09 08:38:04 +01:00
|
|
|
qemu_opts_print(opts, " ");
|
2013-02-13 09:09:40 +01:00
|
|
|
puts("");
|
|
|
|
}
|
2014-06-05 11:20:51 +02:00
|
|
|
|
2014-06-05 11:21:11 +02:00
|
|
|
ret = bdrv_create(drv, filename, opts, &local_err);
|
2014-06-05 11:20:51 +02:00
|
|
|
|
2013-09-06 17:14:26 +02:00
|
|
|
if (ret == -EFBIG) {
|
|
|
|
/* This is generally a better message than whatever the driver would
|
|
|
|
* deliver (especially because of the cluster_size_hint), since that
|
|
|
|
* is most probably not much different from "image too large". */
|
|
|
|
const char *cluster_size_hint = "";
|
2014-06-05 11:20:51 +02:00
|
|
|
if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
|
2013-09-06 17:14:26 +02:00
|
|
|
cluster_size_hint = " (try using a larger cluster size)";
|
2010-12-16 13:52:15 +01:00
|
|
|
}
|
2013-09-06 17:14:26 +02:00
|
|
|
error_setg(errp, "The image size is too large for file format '%s'"
|
|
|
|
"%s", fmt, cluster_size_hint);
|
|
|
|
error_free(local_err);
|
|
|
|
local_err = NULL;
|
2010-12-16 13:52:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2014-06-05 11:20:51 +02:00
|
|
|
qemu_opts_del(opts);
|
|
|
|
qemu_opts_free(create_opts);
|
2016-06-13 23:57:56 +02:00
|
|
|
error_propagate(errp, local_err);
|
2010-12-16 13:52:15 +01:00
|
|
|
}
|
2013-03-07 13:41:48 +01:00
|
|
|
|
|
|
|
AioContext *bdrv_get_aio_context(BlockDriverState *bs)
|
|
|
|
{
|
2018-02-16 17:50:13 +01:00
|
|
|
return bs ? bs->aio_context : qemu_get_aio_context();
|
2014-05-08 16:34:37 +02:00
|
|
|
}
|
|
|
|
|
2017-04-10 14:09:25 +02:00
|
|
|
void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)
|
|
|
|
{
|
|
|
|
aio_co_enter(bdrv_get_aio_context(bs), co);
|
|
|
|
}
|
|
|
|
|
2016-06-16 18:56:26 +02:00
|
|
|
static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
|
|
|
|
{
|
|
|
|
QLIST_REMOVE(ban, list);
|
|
|
|
g_free(ban);
|
|
|
|
}
|
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
void bdrv_detach_aio_context(BlockDriverState *bs)
|
|
|
|
{
|
2016-06-16 18:56:26 +02:00
|
|
|
BdrvAioNotifier *baf, *baf_tmp;
|
2016-05-17 13:38:04 +02:00
|
|
|
BdrvChild *child;
|
2014-06-20 21:57:33 +02:00
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
if (!bs->drv) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-16 18:56:26 +02:00
|
|
|
assert(!bs->walking_aio_notifiers);
|
|
|
|
bs->walking_aio_notifiers = true;
|
|
|
|
QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
|
|
|
|
if (baf->deleted) {
|
|
|
|
bdrv_do_remove_aio_context_notifier(baf);
|
|
|
|
} else {
|
|
|
|
baf->detach_aio_context(baf->opaque);
|
|
|
|
}
|
2014-06-20 21:57:33 +02:00
|
|
|
}
|
2016-06-16 18:56:26 +02:00
|
|
|
/* Never mind iterating again to check for ->deleted. bdrv_close() will
|
|
|
|
* remove remaining aio notifiers if we aren't called again.
|
|
|
|
*/
|
|
|
|
bs->walking_aio_notifiers = false;
|
2014-06-20 21:57:33 +02:00
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
if (bs->drv->bdrv_detach_aio_context) {
|
|
|
|
bs->drv->bdrv_detach_aio_context(bs);
|
|
|
|
}
|
2016-05-17 13:38:04 +02:00
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
bdrv_detach_aio_context(child->bs);
|
2014-05-08 16:34:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bs->aio_context = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_attach_aio_context(BlockDriverState *bs,
|
|
|
|
AioContext *new_context)
|
|
|
|
{
|
2016-06-16 18:56:26 +02:00
|
|
|
BdrvAioNotifier *ban, *ban_tmp;
|
2016-05-17 13:38:04 +02:00
|
|
|
BdrvChild *child;
|
2014-06-20 21:57:33 +02:00
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
if (!bs->drv) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bs->aio_context = new_context;
|
|
|
|
|
2016-05-17 13:38:04 +02:00
|
|
|
QLIST_FOREACH(child, &bs->children, next) {
|
|
|
|
bdrv_attach_aio_context(child->bs, new_context);
|
2014-05-08 16:34:37 +02:00
|
|
|
}
|
|
|
|
if (bs->drv->bdrv_attach_aio_context) {
|
|
|
|
bs->drv->bdrv_attach_aio_context(bs, new_context);
|
|
|
|
}
|
2014-06-20 21:57:33 +02:00
|
|
|
|
2016-06-16 18:56:26 +02:00
|
|
|
assert(!bs->walking_aio_notifiers);
|
|
|
|
bs->walking_aio_notifiers = true;
|
|
|
|
QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
|
|
|
|
if (ban->deleted) {
|
|
|
|
bdrv_do_remove_aio_context_notifier(ban);
|
|
|
|
} else {
|
|
|
|
ban->attached_aio_context(new_context, ban->opaque);
|
|
|
|
}
|
2014-06-20 21:57:33 +02:00
|
|
|
}
|
2016-06-16 18:56:26 +02:00
|
|
|
bs->walking_aio_notifiers = false;
|
2014-05-08 16:34:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
|
|
|
|
{
|
2017-04-05 08:44:24 +02:00
|
|
|
AioContext *ctx = bdrv_get_aio_context(bs);
|
2017-03-14 12:11:57 +01:00
|
|
|
|
2017-04-05 08:44:24 +02:00
|
|
|
aio_disable_external(ctx);
|
2018-05-29 17:17:45 +02:00
|
|
|
bdrv_parent_drained_begin(bs, NULL, false);
|
2015-05-29 12:53:14 +02:00
|
|
|
bdrv_drain(bs); /* ensure there are no in-flight requests */
|
2014-05-08 16:34:37 +02:00
|
|
|
|
2017-03-14 12:11:57 +01:00
|
|
|
while (aio_poll(ctx, false)) {
|
|
|
|
/* wait for all bottom halves to execute */
|
|
|
|
}
|
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
bdrv_detach_aio_context(bs);
|
|
|
|
|
|
|
|
/* This function executes in the old AioContext so acquire the new one in
|
|
|
|
* case it runs in a different thread.
|
|
|
|
*/
|
|
|
|
aio_context_acquire(new_context);
|
|
|
|
bdrv_attach_aio_context(bs, new_context);
|
2018-05-29 17:17:45 +02:00
|
|
|
bdrv_parent_drained_end(bs, NULL, false);
|
2017-04-05 08:44:24 +02:00
|
|
|
aio_enable_external(ctx);
|
2014-05-08 16:34:37 +02:00
|
|
|
aio_context_release(new_context);
|
2013-03-07 13:41:48 +01:00
|
|
|
}
|
2013-06-24 17:13:10 +02:00
|
|
|
|
2014-06-20 21:57:33 +02:00
|
|
|
void bdrv_add_aio_context_notifier(BlockDriverState *bs,
|
|
|
|
void (*attached_aio_context)(AioContext *new_context, void *opaque),
|
|
|
|
void (*detach_aio_context)(void *opaque), void *opaque)
|
|
|
|
{
|
|
|
|
BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
|
|
|
|
*ban = (BdrvAioNotifier){
|
|
|
|
.attached_aio_context = attached_aio_context,
|
|
|
|
.detach_aio_context = detach_aio_context,
|
|
|
|
.opaque = opaque
|
|
|
|
};
|
|
|
|
|
|
|
|
QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
|
|
|
|
void (*attached_aio_context)(AioContext *,
|
|
|
|
void *),
|
|
|
|
void (*detach_aio_context)(void *),
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
BdrvAioNotifier *ban, *ban_next;
|
|
|
|
|
|
|
|
QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
|
|
|
|
if (ban->attached_aio_context == attached_aio_context &&
|
|
|
|
ban->detach_aio_context == detach_aio_context &&
|
2016-06-16 18:56:26 +02:00
|
|
|
ban->opaque == opaque &&
|
|
|
|
ban->deleted == false)
|
2014-06-20 21:57:33 +02:00
|
|
|
{
|
2016-06-16 18:56:26 +02:00
|
|
|
if (bs->walking_aio_notifiers) {
|
|
|
|
ban->deleted = true;
|
|
|
|
} else {
|
|
|
|
bdrv_do_remove_aio_context_notifier(ban);
|
|
|
|
}
|
2014-06-20 21:57:33 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2014-10-27 11:12:50 +01:00
|
|
|
int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
|
2018-05-09 23:00:18 +02:00
|
|
|
BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
|
|
|
|
Error **errp)
|
2013-09-03 10:09:50 +02:00
|
|
|
{
|
2017-11-10 21:31:09 +01:00
|
|
|
if (!bs->drv) {
|
2018-05-09 23:00:18 +02:00
|
|
|
error_setg(errp, "Node is ejected");
|
2017-11-10 21:31:09 +01:00
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
2014-06-05 11:21:11 +02:00
|
|
|
if (!bs->drv->bdrv_amend_options) {
|
2018-05-09 23:00:18 +02:00
|
|
|
error_setg(errp, "Block driver '%s' does not support option amendment",
|
|
|
|
bs->drv->format_name);
|
2013-09-03 10:09:50 +02:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2018-05-09 23:00:18 +02:00
|
|
|
return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque, errp);
|
2013-09-03 10:09:50 +02:00
|
|
|
}
|
2013-10-02 14:33:48 +02:00
|
|
|
|
2014-03-03 19:11:34 +01:00
|
|
|
/* This function will be called by the bdrv_recurse_is_first_non_filter method
|
|
|
|
* of block filter and by bdrv_is_first_non_filter.
|
|
|
|
* It is used to test if the given bs is the candidate or recurse more in the
|
|
|
|
* node graph.
|
2014-01-23 21:31:36 +01:00
|
|
|
*/
|
2014-03-03 19:11:34 +01:00
|
|
|
bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
|
2014-01-23 21:31:36 +01:00
|
|
|
BlockDriverState *candidate)
|
2013-10-02 14:33:48 +02:00
|
|
|
{
|
2014-03-03 19:11:34 +01:00
|
|
|
/* return false if basic checks fails */
|
|
|
|
if (!bs || !bs->drv) {
|
2014-01-23 21:31:36 +01:00
|
|
|
return false;
|
2013-10-02 14:33:48 +02:00
|
|
|
}
|
|
|
|
|
2014-03-03 19:11:34 +01:00
|
|
|
/* the code reached a non block filter driver -> check if the bs is
|
|
|
|
* the same as the candidate. It's the recursion termination condition.
|
|
|
|
*/
|
|
|
|
if (!bs->drv->is_filter) {
|
|
|
|
return bs == candidate;
|
2014-01-23 21:31:36 +01:00
|
|
|
}
|
2014-03-03 19:11:34 +01:00
|
|
|
/* Down this path the driver is a block filter driver */
|
2014-01-23 21:31:36 +01:00
|
|
|
|
2014-03-03 19:11:34 +01:00
|
|
|
/* If the block filter recursion method is defined use it to recurse down
|
|
|
|
* the node graph.
|
|
|
|
*/
|
|
|
|
if (bs->drv->bdrv_recurse_is_first_non_filter) {
|
2014-01-23 21:31:36 +01:00
|
|
|
return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
|
2013-10-02 14:33:48 +02:00
|
|
|
}
|
|
|
|
|
2014-03-03 19:11:34 +01:00
|
|
|
/* the driver is a block filter but don't allow to recurse -> return false
|
|
|
|
*/
|
|
|
|
return false;
|
2013-10-02 14:33:48 +02:00
|
|
|
}
|
|
|
|
|
2014-01-23 21:31:36 +01:00
|
|
|
/* This function checks if the candidate is the first non filter bs down it's
|
|
|
|
* bs chain. Since we don't have pointers to parents it explore all bs chains
|
|
|
|
* from the top. Some filters can choose not to pass down the recursion.
|
|
|
|
*/
|
|
|
|
bool bdrv_is_first_non_filter(BlockDriverState *candidate)
|
2013-10-02 14:33:48 +02:00
|
|
|
{
|
2016-03-22 18:58:50 +01:00
|
|
|
BlockDriverState *bs;
|
2016-05-20 18:49:07 +02:00
|
|
|
BdrvNextIterator it;
|
2014-01-23 21:31:36 +01:00
|
|
|
|
|
|
|
/* walk down the bs forest recursively */
|
2016-05-20 18:49:07 +02:00
|
|
|
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
|
2014-01-23 21:31:36 +01:00
|
|
|
bool perm;
|
|
|
|
|
2014-03-03 19:11:34 +01:00
|
|
|
/* try to recurse in this top level bs */
|
2014-02-04 11:45:31 +01:00
|
|
|
perm = bdrv_recurse_is_first_non_filter(bs, candidate);
|
2014-01-23 21:31:36 +01:00
|
|
|
|
|
|
|
/* candidate is the first non filter */
|
|
|
|
if (perm) {
|
2017-11-10 18:25:45 +01:00
|
|
|
bdrv_next_cleanup(&it);
|
2014-01-23 21:31:36 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2013-10-02 14:33:48 +02:00
|
|
|
}
|
2014-06-27 18:25:25 +02:00
|
|
|
|
2015-07-17 04:12:22 +02:00
|
|
|
BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
|
|
|
|
const char *node_name, Error **errp)
|
2014-06-27 18:25:25 +02:00
|
|
|
{
|
|
|
|
BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
|
2014-10-21 13:03:58 +02:00
|
|
|
AioContext *aio_context;
|
|
|
|
|
2014-06-27 18:25:25 +02:00
|
|
|
if (!to_replace_bs) {
|
|
|
|
error_setg(errp, "Node name '%s' not found", node_name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-10-21 13:03:58 +02:00
|
|
|
aio_context = bdrv_get_aio_context(to_replace_bs);
|
|
|
|
aio_context_acquire(aio_context);
|
|
|
|
|
2014-06-27 18:25:25 +02:00
|
|
|
if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
|
2014-10-21 13:03:58 +02:00
|
|
|
to_replace_bs = NULL;
|
|
|
|
goto out;
|
2014-06-27 18:25:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* We don't want arbitrary node of the BDS chain to be replaced only the top
|
|
|
|
* most non filter in order to prevent data corruption.
|
|
|
|
* Another benefit is that this tests exclude backing files which are
|
|
|
|
* blocked by the backing blockers.
|
|
|
|
*/
|
2015-07-17 04:12:22 +02:00
|
|
|
if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
|
2014-06-27 18:25:25 +02:00
|
|
|
error_setg(errp, "Only top most non filter can be replaced");
|
2014-10-21 13:03:58 +02:00
|
|
|
to_replace_bs = NULL;
|
|
|
|
goto out;
|
2014-06-27 18:25:25 +02:00
|
|
|
}
|
|
|
|
|
2014-10-21 13:03:58 +02:00
|
|
|
out:
|
|
|
|
aio_context_release(aio_context);
|
2014-06-27 18:25:25 +02:00
|
|
|
return to_replace_bs;
|
|
|
|
}
|
2014-07-04 12:04:33 +02:00
|
|
|
|
2014-07-18 20:24:56 +02:00
|
|
|
static bool append_open_options(QDict *d, BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
const QDictEntry *entry;
|
2015-04-24 15:20:28 +02:00
|
|
|
QemuOptDesc *desc;
|
2014-07-18 20:24:56 +02:00
|
|
|
bool found_any = false;
|
|
|
|
|
|
|
|
for (entry = qdict_first(bs->options); entry;
|
|
|
|
entry = qdict_next(bs->options, entry))
|
|
|
|
{
|
2018-09-06 11:37:04 +02:00
|
|
|
/* Exclude all non-driver-specific options */
|
2015-04-24 15:20:28 +02:00
|
|
|
for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
|
|
|
|
if (!strcmp(qdict_entry_key(entry), desc->name)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (desc->name) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-04-19 17:01:44 +02:00
|
|
|
qdict_put_obj(d, qdict_entry_key(entry),
|
|
|
|
qobject_ref(qdict_entry_value(entry)));
|
2015-04-24 15:20:28 +02:00
|
|
|
found_any = true;
|
2014-07-18 20:24:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return found_any;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Updates the following BDS fields:
|
|
|
|
* - exact_filename: A filename which may be used for opening a block device
|
|
|
|
* which (mostly) equals the given BDS (even without any
|
|
|
|
* other options; so reading and writing must return the same
|
|
|
|
* results, but caching etc. may be different)
|
|
|
|
* - full_open_options: Options which, when given when opening a block device
|
|
|
|
* (without a filename), result in a BDS (mostly)
|
|
|
|
* equalling the given one
|
|
|
|
* - filename: If exact_filename is set, it is copied here. Otherwise,
|
|
|
|
* full_open_options is converted to a JSON object, prefixed with
|
|
|
|
* "json:" (for use through the JSON pseudo protocol) and put here.
|
|
|
|
*/
|
|
|
|
void bdrv_refresh_filename(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
QDict *opts;
|
|
|
|
|
|
|
|
if (!drv) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This BDS's file name will most probably depend on its file's name, so
|
|
|
|
* refresh that first */
|
|
|
|
if (bs->file) {
|
2015-06-16 14:19:22 +02:00
|
|
|
bdrv_refresh_filename(bs->file->bs);
|
2014-07-18 20:24:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (drv->bdrv_refresh_filename) {
|
|
|
|
/* Obsolete information is of no use here, so drop the old file name
|
|
|
|
* information before refreshing it */
|
|
|
|
bs->exact_filename[0] = '\0';
|
|
|
|
if (bs->full_open_options) {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs->full_open_options);
|
2014-07-18 20:24:56 +02:00
|
|
|
bs->full_open_options = NULL;
|
|
|
|
}
|
|
|
|
|
2015-04-27 13:50:54 +02:00
|
|
|
opts = qdict_new();
|
|
|
|
append_open_options(opts, bs);
|
|
|
|
drv->bdrv_refresh_filename(bs, opts);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(opts);
|
2014-07-18 20:24:56 +02:00
|
|
|
} else if (bs->file) {
|
|
|
|
/* Try to reconstruct valid information from the underlying file */
|
|
|
|
bool has_open_options;
|
|
|
|
|
|
|
|
bs->exact_filename[0] = '\0';
|
|
|
|
if (bs->full_open_options) {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(bs->full_open_options);
|
2014-07-18 20:24:56 +02:00
|
|
|
bs->full_open_options = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
opts = qdict_new();
|
|
|
|
has_open_options = append_open_options(opts, bs);
|
|
|
|
|
|
|
|
/* If no specific options have been given for this BDS, the filename of
|
|
|
|
* the underlying file should suffice for this one as well */
|
2015-06-16 14:19:22 +02:00
|
|
|
if (bs->file->bs->exact_filename[0] && !has_open_options) {
|
|
|
|
strcpy(bs->exact_filename, bs->file->bs->exact_filename);
|
2014-07-18 20:24:56 +02:00
|
|
|
}
|
|
|
|
/* Reconstructing the full options QDict is simple for most format block
|
|
|
|
* drivers, as long as the full options are known for the underlying
|
|
|
|
* file BDS. The full options QDict of that file BDS should somehow
|
|
|
|
* contain a representation of the filename, therefore the following
|
|
|
|
* suffices without querying the (exact_)filename of this BDS. */
|
2015-06-16 14:19:22 +02:00
|
|
|
if (bs->file->bs->full_open_options) {
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(opts, "driver", drv->format_name);
|
2018-04-19 17:01:44 +02:00
|
|
|
qdict_put(opts, "file",
|
|
|
|
qobject_ref(bs->file->bs->full_open_options));
|
2014-07-18 20:24:56 +02:00
|
|
|
|
|
|
|
bs->full_open_options = opts;
|
|
|
|
} else {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(opts);
|
2014-07-18 20:24:56 +02:00
|
|
|
}
|
|
|
|
} else if (!bs->full_open_options && qdict_size(bs->options)) {
|
|
|
|
/* There is no underlying file BDS (at least referenced by BDS.file),
|
|
|
|
* so the full options QDict should be equal to the options given
|
|
|
|
* specifically for this block device when it was opened (plus the
|
|
|
|
* driver specification).
|
|
|
|
* Because those options don't change, there is no need to update
|
|
|
|
* full_open_options when it's already set. */
|
|
|
|
|
|
|
|
opts = qdict_new();
|
|
|
|
append_open_options(opts, bs);
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(opts, "driver", drv->format_name);
|
2014-07-18 20:24:56 +02:00
|
|
|
|
|
|
|
if (bs->exact_filename[0]) {
|
|
|
|
/* This may not work for all block protocol drivers (some may
|
|
|
|
* require this filename to be parsed), but we have to find some
|
|
|
|
* default solution here, so just include it. If some block driver
|
|
|
|
* does not support pure options without any filename at all or
|
|
|
|
* needs some special format of the options QDict, it needs to
|
|
|
|
* implement the driver-specific bdrv_refresh_filename() function.
|
|
|
|
*/
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(opts, "filename", bs->exact_filename);
|
2014-07-18 20:24:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bs->full_open_options = opts;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bs->exact_filename[0]) {
|
|
|
|
pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
|
|
|
|
} else if (bs->full_open_options) {
|
|
|
|
QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
|
|
|
|
snprintf(bs->filename, sizeof(bs->filename), "json:%s",
|
|
|
|
qstring_get_str(json));
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(json);
|
2014-07-18 20:24:56 +02:00
|
|
|
}
|
|
|
|
}
|
2016-05-10 09:36:37 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Hot add/remove a BDS's child. So the user can take a child offline when
|
|
|
|
* it is broken and take a new child online
|
|
|
|
*/
|
|
|
|
void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
|
|
|
|
error_setg(errp, "The node %s does not support adding a child",
|
|
|
|
bdrv_get_device_or_node_name(parent_bs));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!QLIST_EMPTY(&child_bs->parents)) {
|
|
|
|
error_setg(errp, "The node %s already has a parent",
|
|
|
|
child_bs->node_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
|
|
|
|
{
|
|
|
|
BdrvChild *tmp;
|
|
|
|
|
|
|
|
if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
|
|
|
|
error_setg(errp, "The node %s does not support removing a child",
|
|
|
|
bdrv_get_device_or_node_name(parent_bs));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
QLIST_FOREACH(tmp, &parent_bs->children, next) {
|
|
|
|
if (tmp == child) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!tmp) {
|
|
|
|
error_setg(errp, "The node %s does not have a child named %s",
|
|
|
|
bdrv_get_device_or_node_name(parent_bs),
|
|
|
|
bdrv_get_device_or_node_name(child->bs));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
|
|
|
|
}
|
2017-06-28 14:05:21 +02:00
|
|
|
|
|
|
|
bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
|
|
|
|
uint32_t granularity, Error **errp)
|
|
|
|
{
|
|
|
|
BlockDriver *drv = bs->drv;
|
|
|
|
|
|
|
|
if (!drv) {
|
|
|
|
error_setg_errno(errp, ENOMEDIUM,
|
|
|
|
"Can't store persistent bitmaps to %s",
|
|
|
|
bdrv_get_device_or_node_name(bs));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!drv->bdrv_can_store_new_dirty_bitmap) {
|
|
|
|
error_setg_errno(errp, ENOTSUP,
|
|
|
|
"Can't store persistent bitmaps to %s",
|
|
|
|
bdrv_get_device_or_node_name(bs));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return drv->bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp);
|
|
|
|
}
|