@@ -181,6 +181,12 @@ QemuOpts *drive_def(const char *optstr)
return qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr, false);
}
+QemuOpts *dirty_bitmap_def(const char *optstr)
+{
+ return qemu_opts_parse_noisily(qemu_find_opts("dirty-bitmap"), optstr,
+ false);
+}
+
QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
const char *optstr)
{
@@ -3953,6 +3959,36 @@ BlockJobInfoList *qmp_query_block_jobs(Error **errp)
return head;
}
+QemuOptsList qemu_dirty_bitmap_opts = {
+ .name = "dirty-bitmap",
+ .head = QTAILQ_HEAD_INITIALIZER(qemu_dirty_bitmap_opts.head),
+ .desc = {
+ {
+ .name = "name",
+ .type = QEMU_OPT_STRING,
+ .help = "Name of the dirty bitmap",
+ },{
+ .name = "node",
+ .type = QEMU_OPT_STRING,
+ .help = "node name to bind the bitmap to (and load it from it)",
+ },{
+ .name = "granularity",
+ .type = QEMU_OPT_NUMBER,
+ .help = "granularity",
+ },{
+ .name = "enabled",
+ .type = QEMU_OPT_BOOL,
+ .help = "enabled flag (default is 'on')",
+ },{
+ .name = "create",
+ .type = QEMU_OPT_BOOL,
+ .help = "create flag (default is 'off'), "
+ "if on, new dirty bitmap will be created, "
+ "else the existing one will be loaded"
+ }
+ }
+};
+
QemuOptsList qemu_common_drive_opts = {
.name = "drive",
.head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head),
@@ -57,6 +57,7 @@ int drive_get_max_devs(BlockInterfaceType type);
DriveInfo *drive_get_next(BlockInterfaceType type);
QemuOpts *drive_def(const char *optstr);
+QemuOpts *dirty_bitmap_def(const char *optstr);
QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
const char *optstr);
DriveInfo *drive_new(QemuOpts *arg, BlockInterfaceType block_default_type);
@@ -248,6 +248,7 @@ bool usb_enabled(void);
extern QemuOptsList qemu_legacy_drive_opts;
extern QemuOptsList qemu_common_drive_opts;
+extern QemuOptsList qemu_dirty_bitmap_opts;
extern QemuOptsList qemu_drive_opts;
extern QemuOptsList qemu_chardev_opts;
extern QemuOptsList qemu_device_opts;
@@ -679,6 +679,41 @@ qemu-system-i386 -hda a -hdb b
@end example
ETEXI
+DEF("dirty-bitmap", HAS_ARG, QEMU_OPTION_dirty_bitmap,
+ "-dirty-bitmap name=name,node=@var{id}\n"
+ " [,granularity=granularity][,enabled=on|off][,create=on|off]\n",
+ QEMU_ARCH_ALL)
+STEXI
+@item -dirty-bitmap @var{option}[,@var{option}[,@var{option}[,...]]]
+@findex -dirty-bitmap
+
+Define a dirty-bitmap. Valid options are:
+
+@table @option
+@item name=@var{name}
+The name of the bitmap. Should be unique per @var{file}/@var{node} and per
+@var{for_node}.
+@item node=@var{node}
+The node to load and bind the bitmap. It should be specified as @var{id} suboption
+of one of @option{-node} options.
+@item granularity=@var{granularity}
+Granularity (in bytes) for created dirty bitmap. If the bitmap is already
+exists in specified @var{file}/@var{file_id}/@var{device} it's granularity will
+not be changed but only checked (an error will be generated if this check
+fails).
+@item enabled=@var{enabled}
+Enabled flag for the bitmap. By default the bitmap will be enabled.
+@item create=@var{create}
+By default is off.
+If on, then new bitmap will be created in the image, if the bitmap with same
+name is already exists an error will be generated.
+If off, then the bitmap will be loaded from the image, if there is no one an
+error will be generated.
+If create=off and granularity is specified then granularity will be checked for
+loaded bitmap and if not match an error will be generated.
+@end table
+ETEXI
+
DEF("mtdblock", HAS_ARG, QEMU_OPTION_mtdblock,
"-mtdblock file use 'file' as on-board Flash memory image\n",
QEMU_ARCH_ALL)
@@ -1144,6 +1144,70 @@ static int cleanup_add_fd(void *opaque, QemuOpts *opts, Error **errp)
#define MTD_OPTS ""
#define SD_OPTS ""
+static int dirty_bitmap_func(void *opaque, QemuOpts *opts, Error **errp)
+{
+ BlockDriverState *bs = NULL;
+ BdrvDirtyBitmap *bitmap = NULL;
+
+ const char *name = qemu_opt_get(opts, "name");
+ const char *node = qemu_opt_get(opts, "node");
+
+ uint64_t granularity = qemu_opt_get_number(opts, "granularity", 0);
+ bool enabled = qemu_opt_get_bool(opts, "enabled", true);
+ bool create = qemu_opt_get_bool(opts, "create", false);
+
+ if (name == NULL) {
+ error_setg(errp, "'name' option is necessary");
+ return -EINVAL;
+ }
+
+ if (node == NULL) {
+ error_setg(errp, "'node' option is necessary");
+ return -EINVAL;
+ }
+
+ bs = bdrv_lookup_bs(node, node, errp);
+ if (bs == NULL) {
+ return -ENOENT;
+ }
+
+ if (create) {
+ if (bdrv_load_check_dirty_bitmap(bs, name)) {
+ error_setg(errp, "bitmap '%s' already exists", name);
+ return -EEXIST;
+ }
+
+ if (granularity == 0) {
+ granularity = bdrv_get_default_bitmap_granularity(bs);
+ }
+
+ bitmap = bdrv_create_dirty_bitmap(bs, granularity, name, errp);
+ if (bitmap == NULL) {
+ return -EINVAL;
+ }
+ } else {
+ bitmap = bdrv_load_dirty_bitmap(bs, name, errp);
+ if (bitmap == NULL) {
+ return -EINVAL;
+ }
+
+ if (granularity != 0 &&
+ granularity != bdrv_dirty_bitmap_granularity(bitmap)) {
+ bdrv_release_dirty_bitmap(bs, bitmap);
+ error_setg(errp, "granularity doesn't match");
+ return -EINVAL;
+ }
+ }
+
+ bdrv_dirty_bitmap_set_internal_persistance(bitmap, true);
+
+ if (!enabled) {
+ bdrv_disable_dirty_bitmap(bitmap);
+ }
+
+ return 0;
+}
+
static int drive_init_func(void *opaque, QemuOpts *opts, Error **errp)
{
BlockInterfaceType *block_default_type = opaque;
@@ -3006,6 +3070,7 @@ int main(int argc, char **argv, char **envp)
module_call_init(MODULE_INIT_QOM);
qemu_add_opts(&qemu_drive_opts);
+ qemu_add_opts(&qemu_dirty_bitmap_opts);
qemu_add_drive_opts(&qemu_legacy_drive_opts);
qemu_add_drive_opts(&qemu_common_drive_opts);
qemu_add_drive_opts(&qemu_drive_opts);
@@ -3139,6 +3204,11 @@ int main(int argc, char **argv, char **envp)
exit(1);
}
break;
+ case QEMU_OPTION_dirty_bitmap:
+ if (dirty_bitmap_def(optarg) == NULL) {
+ exit(1);
+ }
+ break;
case QEMU_OPTION_set:
if (qemu_set_option(optarg) != 0)
exit(1);
@@ -4454,6 +4524,14 @@ int main(int argc, char **argv, char **envp)
parse_numa_opts(machine_class);
+ if (qemu_opts_foreach(qemu_find_opts("dirty-bitmap"), dirty_bitmap_func,
+ NULL, &err)) {
+ if (err != NULL) {
+ error_report_err(err);
+ }
+ exit(1);
+ }
+
if (qemu_opts_foreach(qemu_find_opts("mon"),
mon_init_func, NULL, NULL)) {
exit(1);
The patch adds the following command line option: -dirty-bitmap [option1=val1][,option2=val2]... Avaliable options are: name The name of the bitmap. Should be unique per 'file'/'node' and per 'for_node'. node The node to load and bind the bitmap. It should be specified as 'id' suboption of one of '-node' options. granularity Granularity (in bytes) for created dirty bitmap. If the bitmap is already exists in specified 'file'/'file_id'/device it's granularity will not be changed but only checked (an error will be generated if this check fails). enabled on|off Enabled flag for the bitmap. By default the bitmap will be enabled. create on|off By default is off. If on, then new bitmap will be created in the image, if the bitmap with same name is already exists an error will be generated. If off, then the bitmap will be loaded from the image, if there is no one an error will be generated. If create=off and granularity is specified then granularity will be checked for loaded bitmap and if not match an error will be generated. Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> --- blockdev.c | 36 ++++++++++++++++++++++ include/sysemu/blockdev.h | 1 + include/sysemu/sysemu.h | 1 + qemu-options.hx | 35 +++++++++++++++++++++ vl.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 151 insertions(+)