1 From 7d2906f7da677d2f2533d1455453dc328cb65590 Mon Sep 17 00:00:00 2001
2 From: Dietmar Maurer <dietmar@proxmox.com>
3 Date: Tue, 13 Nov 2012 11:27:56 +0100
4 Subject: [PATCH v3 3/7] add backup related monitor commands
6 We use a generic BackupDriver struct to encapsulate all archive format
9 Another option would be to simply dump <devid,cluster_num,cluster_data> to
10 the output fh (pipe), and an external binary saves the data. That way we
11 could move the whole archive format related code out of qemu.
13 Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
16 blockdev.c | 410 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
17 hmp-commands.hx | 31 ++++
21 qapi-schema.json | 91 ++++++++++++
22 qmp-commands.hx | 27 ++++
23 8 files changed, 645 insertions(+), 0 deletions(-)
25 diff --git a/backup.h b/backup.h
26 index 87b9942..c6e5d3c 100644
29 @@ -29,4 +29,17 @@ int backup_job_create(BlockDriverState *bs, BackupDumpFunc *backup_dump_cb,
30 BlockDriverCompletionFunc *backup_complete_cb,
33 +typedef struct BackupDriver {
35 + void *(*open_cb)(const char *filename, uuid_t uuid, int64_t speed,
37 + int (*close_cb)(void *opaque, Error **errp);
38 + int (*register_config_cb)(void *opaque, const char *name, gpointer data,
40 + int (*register_stream_cb)(void *opaque, const char *devname, size_t size);
41 + int (*dump_cb)(void *opaque, uint8_t dev_id, int64_t cluster_num,
42 + unsigned char *buf, size_t *zero_bytes);
43 + int (*complete_cb)(void *opaque, uint8_t dev_id, int ret);
46 #endif /* QEMU_BACKUP_H */
47 diff --git a/blockdev.c b/blockdev.c
48 index e73fd6e..37edb75 100644
52 #include "qmp-commands.h"
54 #include "arch_init.h"
57 static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives);
59 @@ -1321,6 +1322,415 @@ void qmp_drive_mirror(const char *device, const char *target,
60 drive_get_ref(drive_get_by_blockdev(bs));
63 +/* Backup related function */
65 +static void backup_run_next_job(void);
67 +static struct GenericBackupState {
74 + const BackupDriver *driver;
82 +typedef struct BackupCB {
83 + BlockDriverState *bs;
92 +static int backup_dump_cb(void *opaque, BlockDriverState *bs,
93 + int64_t cluster_num, unsigned char *buf)
95 + BackupCB *bcb = opaque;
97 + assert(backup_state.driver);
98 + assert(backup_state.writer);
99 + assert(backup_state.driver->dump_cb);
101 + size_t zero_bytes = 0;
102 + int bytes = backup_state.driver->dump_cb(backup_state.writer,
103 + bcb->dev_id, cluster_num,
107 + bcb->transferred += bytes;
108 + backup_state.transferred += bytes;
110 + bcb->zero_bytes += bytes;
111 + backup_state.zero_bytes += zero_bytes;
118 +static void backup_cleanup(void)
120 + if (backup_state.writer && backup_state.driver) {
121 + backup_state.end_time = time(NULL);
122 + Error *local_err = NULL;
123 + backup_state.driver->close_cb(backup_state.writer, &local_err);
124 + error_propagate(&backup_state.error, local_err);
125 + backup_state.writer = NULL;
128 + if (backup_state.bcb_list) {
129 + GList *l = backup_state.bcb_list;
131 + BackupCB *bcb = l->data;
132 + l = g_list_next(l);
133 + drive_put_ref_bh_schedule(drive_get_by_blockdev(bcb->bs));
136 + g_list_free(backup_state.bcb_list);
137 + backup_state.bcb_list = NULL;
141 +static void backup_complete_cb(void *opaque, int ret)
143 + BackupCB *bcb = opaque;
145 + assert(backup_state.driver);
146 + assert(backup_state.writer);
147 + assert(backup_state.driver->complete_cb);
148 + assert(backup_state.driver->close_cb);
150 + bcb->completed = true;
152 + backup_state.driver->complete_cb(backup_state.writer, bcb->dev_id, ret);
154 + backup_run_next_job();
157 +static void backup_cancel(void)
159 + if (!backup_state.error) {
160 + error_setg(&backup_state.error, "backup cancelled");
163 + /* we only need to cancel the running job - backup_run_next_job() cancels
164 + * the other jobs */
166 + GList *l = backup_state.bcb_list;
168 + BackupCB *bcb = l->data;
169 + l = g_list_next(l);
170 + BlockJob *job = bcb->bs->job;
171 + if (!bcb->completed && job) {
172 + block_job_cancel(job);
173 + /* make sure we call the complete callback */
175 + block_job_completed(job, -1);
181 + if (!l) { /* all jobs completed */
186 +void qmp_backup_cancel(Error **errp)
191 +static void backup_run_next_job(void)
193 + GList *l = backup_state.bcb_list;
195 + BackupCB *bcb = l->data;
196 + l = g_list_next(l);
198 + if (bcb->bs && bcb->bs->job && !bcb->completed) {
199 + if (!bcb->started) {
200 + bcb->started = true;
201 + if (!backup_state.error) {
202 + backup_job_start(bcb->bs);
204 + block_job_completed(bcb->bs->job, -1);
214 +static void backup_start_jobs(void)
216 + /* create all jobs (one for each device), start first one */
217 + GList *l = backup_state.bcb_list;
219 + BackupCB *bcb = l->data;
220 + l = g_list_next(l);
222 + if (backup_job_create(bcb->bs, backup_dump_cb, backup_complete_cb,
224 + error_setg(&backup_state.error, "backup_job_create failed");
230 + backup_run_next_job();
233 +char *qmp_backup(const char *backupfile, bool has_format, BackupFormat format,
234 + bool has_config_filename, const char *config_filename,
235 + bool has_devlist, const char *devlist,
236 + bool has_speed, int64_t speed, Error **errp)
238 + BlockDriverState *bs;
239 + Error *local_err = NULL;
241 + void *writer = NULL;
242 + gchar **devs = NULL;
243 + GList *bcblist = NULL;
245 + /* Todo: try to auto-detect format based on file name */
246 + format = has_format ? format : BACKUP_FORMAT_VMA;
248 + /* fixme: find driver for specifued format */
249 + const BackupDriver *driver = NULL;
252 + error_set(errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
257 + devs = g_strsplit_set(devlist, ",;:", -1);
261 + bs = bdrv_find(*d);
263 + if (bdrv_is_read_only(bs)) {
264 + error_set(errp, QERR_DEVICE_IS_READ_ONLY, *d);
267 + if (!bdrv_is_inserted(bs)) {
268 + error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, *d);
271 + BackupCB *bcb = g_new0(BackupCB, 1);
273 + bcblist = g_list_append(bcblist, bcb);
275 + error_set(errp, QERR_DEVICE_NOT_FOUND, *d);
284 + while ((bs = bdrv_next(bs))) {
286 + if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
290 + BackupCB *bcb = g_new0(BackupCB, 1);
292 + bcblist = g_list_append(bcblist, bcb);
297 + error_set(errp, ERROR_CLASS_GENERIC_ERROR, "empty device list");
301 + GList *l = bcblist;
303 + BackupCB *bcb = l->data;
304 + l = g_list_next(l);
305 + if (bcb->bs->job) {
306 + error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bcb->bs));
311 + uuid_generate(uuid);
313 + writer = driver->open_cb(backupfile, uuid, has_speed ? speed : 0,
316 + if (error_is_set(&local_err)) {
317 + error_propagate(errp, local_err);
324 + /* register all devices for vma writer */
327 + BackupCB *bcb = l->data;
328 + l = g_list_next(l);
330 + int64_t size = bdrv_getlength(bcb->bs);
331 + const char *devname = bdrv_get_device_name(bcb->bs);
332 + bcb->dev_id = driver->register_stream_cb(writer, devname, size);
333 + if (bcb->dev_id <= 0) {
334 + error_set(errp, ERROR_CLASS_GENERIC_ERROR,
335 + "register_stream failed");
342 + /* add configuration file to archive */
343 + if (has_config_filename) {
344 + char *cdata = NULL;
346 + GError *err = NULL;
347 + if (!g_file_get_contents(config_filename, &cdata, &clen, &err)) {
348 + error_setg(errp, "unable to read file '%s'", config_filename);
352 + const char *basename = g_path_get_basename(config_filename);
353 + if (driver->register_config_cb(writer, basename, cdata, clen) < 0) {
354 + error_setg(errp, "register_config failed");
361 + /* initialize global backup_state now */
363 + if (backup_state.error) {
364 + error_free(backup_state.error);
365 + backup_state.error = NULL;
368 + backup_state.driver = driver;
370 + backup_state.start_time = time(NULL);
371 + backup_state.end_time = 0;
373 + if (backup_state.backupfile) {
374 + g_free(backup_state.backupfile);
376 + backup_state.backupfile = g_strdup(backupfile);
378 + backup_state.writer = writer;
380 + uuid_copy(backup_state.uuid, uuid);
381 + uuid_unparse_lower(uuid, backup_state.uuid_str);
383 + backup_state.bcb_list = bcblist;
385 + backup_state.total = total;
386 + backup_state.transferred = 0;
387 + backup_state.zero_bytes = 0;
389 + /* Grab a reference so hotplug does not delete the
390 + * BlockDriverState from underneath us.
394 + BackupCB *bcb = l->data;
395 + l = g_list_next(l);
396 + drive_get_ref(drive_get_by_blockdev(bcb->bs));
399 + backup_start_jobs();
401 + return g_strdup(backup_state.uuid_str);
408 + l = g_list_next(l);
410 + g_list_free(bcblist);
417 + unlink(backupfile);
420 + driver->close_cb(writer, &err);
427 +BackupStatus *qmp_query_backup(Error **errp)
429 + BackupStatus *info = g_malloc0(sizeof(*info));
431 + if (!backup_state.start_time) {
432 + /* not started, return {} */
436 + info->has_status = true;
437 + info->has_start_time = true;
438 + info->start_time = backup_state.start_time;
440 + if (backup_state.backupfile) {
441 + info->has_backupfile = true;
442 + info->backupfile = g_strdup(backup_state.backupfile);
445 + info->has_uuid = true;
446 + info->uuid = g_strdup(backup_state.uuid_str);
448 + if (backup_state.end_time) {
449 + if (backup_state.error) {
450 + info->status = g_strdup("error");
451 + info->has_errmsg = true;
452 + info->errmsg = g_strdup(error_get_pretty(backup_state.error));
454 + info->status = g_strdup("done");
456 + info->has_end_time = true;
457 + info->end_time = backup_state.end_time;
459 + info->status = g_strdup("active");
462 + info->has_total = true;
463 + info->total = backup_state.total;
464 + info->has_zero_bytes = true;
465 + info->zero_bytes = backup_state.zero_bytes;
466 + info->has_transferred = true;
467 + info->transferred = backup_state.transferred;
472 static BlockJob *find_block_job(const char *device)
474 BlockDriverState *bs;
475 diff --git a/hmp-commands.hx b/hmp-commands.hx
476 index 010b8c9..57be357 100644
477 --- a/hmp-commands.hx
478 +++ b/hmp-commands.hx
479 @@ -83,6 +83,35 @@ STEXI
480 Copy data from a backing file into a block device.
485 + .args_type = "backupfile:s,speed:o?,devlist:s?",
486 + .params = "backupfile [speed [devlist]]",
487 + .help = "create a VM Backup.",
488 + .mhandler.cmd = hmp_backup,
498 + .name = "backup_cancel",
501 + .help = "cancel the current VM backup",
502 + .mhandler.cmd = hmp_backup_cancel,
507 +@findex backup_cancel
508 +Cancel the current VM backup.
513 .name = "block_job_set_speed",
514 .args_type = "device:B,speed:o",
515 @@ -1558,6 +1587,8 @@ show CPU statistics
516 show user network stack connection states
518 show migration status
521 @item info migrate_capabilities
522 show current migration capabilities
523 @item info migrate_cache_size
524 diff --git a/hmp.c b/hmp.c
525 index 180ba2b..27fd421 100644
528 @@ -130,6 +130,38 @@ void hmp_info_mice(Monitor *mon)
529 qapi_free_MouseInfoList(mice_list);
532 +void hmp_info_backup(Monitor *mon)
534 + BackupStatus *info;
536 + info = qmp_query_backup(NULL);
537 + if (info->has_status) {
538 + if (info->has_errmsg) {
539 + monitor_printf(mon, "Backup status: %s - %s\n",
540 + info->status, info->errmsg);
542 + monitor_printf(mon, "Backup status: %s\n", info->status);
545 + if (info->has_backupfile) {
546 + int per = (info->has_total && info->total &&
547 + info->has_transferred && info->transferred) ?
548 + (info->transferred * 100)/info->total : 0;
549 + int zero_per = (info->has_total && info->total &&
550 + info->has_zero_bytes && info->zero_bytes) ?
551 + (info->zero_bytes * 100)/info->total : 0;
552 + monitor_printf(mon, "Backup file: %s\n", info->backupfile);
553 + monitor_printf(mon, "Backup uuid: %s\n", info->uuid);
554 + monitor_printf(mon, "Total size: %zd\n", info->total);
555 + monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
556 + info->transferred, per);
557 + monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
558 + info->zero_bytes, zero_per);
561 + qapi_free_BackupStatus(info);
564 void hmp_info_migrate(Monitor *mon)
567 @@ -977,6 +1009,37 @@ void hmp_block_stream(Monitor *mon, const QDict *qdict)
568 hmp_handle_error(mon, &error);
571 +void hmp_backup_cancel(Monitor *mon, const QDict *qdict)
573 + Error *errp = NULL;
575 + qmp_backup_cancel(&errp);
577 + if (error_is_set(&errp)) {
578 + monitor_printf(mon, "%s\n", error_get_pretty(errp));
584 +void hmp_backup(Monitor *mon, const QDict *qdict)
586 + const char *backupfile = qdict_get_str(qdict, "backupfile");
587 + const char *devlist = qdict_get_try_str(qdict, "devlist");
588 + int64_t speed = qdict_get_try_int(qdict, "speed", 0);
590 + Error *errp = NULL;
592 + qmp_backup(backupfile, true, BACKUP_FORMAT_VMA, false, NULL, !!devlist,
593 + devlist, qdict_haskey(qdict, "speed"), speed, &errp);
595 + if (error_is_set(&errp)) {
596 + monitor_printf(mon, "%s\n", error_get_pretty(errp));
602 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
605 diff --git a/hmp.h b/hmp.h
606 index 0ab03be..20c9a62 100644
609 @@ -28,6 +28,7 @@ void hmp_info_mice(Monitor *mon);
610 void hmp_info_migrate(Monitor *mon);
611 void hmp_info_migrate_capabilities(Monitor *mon);
612 void hmp_info_migrate_cache_size(Monitor *mon);
613 +void hmp_info_backup(Monitor *mon);
614 void hmp_info_cpus(Monitor *mon);
615 void hmp_info_block(Monitor *mon);
616 void hmp_info_blockstats(Monitor *mon);
617 @@ -63,6 +64,8 @@ void hmp_eject(Monitor *mon, const QDict *qdict);
618 void hmp_change(Monitor *mon, const QDict *qdict);
619 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict);
620 void hmp_block_stream(Monitor *mon, const QDict *qdict);
621 +void hmp_backup(Monitor *mon, const QDict *qdict);
622 +void hmp_backup_cancel(Monitor *mon, const QDict *qdict);
623 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict);
624 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict);
625 void hmp_block_job_pause(Monitor *mon, const QDict *qdict);
626 diff --git a/monitor.c b/monitor.c
627 index c0e32d6..85cf47e 100644
630 @@ -2680,6 +2680,13 @@ static mon_cmd_t info_cmds[] = {
637 + .help = "show backup status",
638 + .mhandler.info = hmp_info_backup,
644 diff --git a/qapi-schema.json b/qapi-schema.json
645 index 5dfa052..2d3699b 100644
646 --- a/qapi-schema.json
647 +++ b/qapi-schema.json
649 { 'type': 'EventInfo', 'data': {'name': 'str'} }
654 +# Detailed backup status.
656 +# @status: #optional string describing the current backup status.
657 +# This can be 'active', 'done', 'error'. If this field is not
658 +# returned, no backup process has been initiated
660 +# @errmsg: #optional error message (only returned if status is 'error')
662 +# @total: #optional total amount of bytes involved in the backup process
664 +# @transferred: #optional amount of bytes already backed up.
666 +# @zero-bytes: #optional amount of 'zero' bytes detected.
668 +# @start-time: #optional time (epoch) when backup job started.
670 +# @end-time: #optional time (epoch) when backup job finished.
672 +# @backupfile: #optional backup file name
674 +# @uuid: #optional uuid for this backup job
678 +{ 'type': 'BackupStatus',
679 + 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int',
680 + '*transferred': 'int', '*zero-bytes': 'int',
681 + '*start-time': 'int', '*end-time': 'int',
682 + '*backupfile': 'str', '*uuid': 'str' } }
687 # Return a list of supported QMP events by this server
688 @@ -1764,6 +1797,64 @@
689 'data': { 'path': 'str' },
690 'returns': [ 'ObjectPropertyInfo' ] }
696 +# An enumeration of supported backup formats.
698 +# @vma: Proxmox vma backup format
700 +{ 'enum': 'BackupFormat',
701 + 'data': [ 'vma' ] }
706 +# Starts a VM backup.
708 +# @backupfile: the backup file name
710 +# @format: format of the backup file
712 +# @config-filename: #optional name of a configuration file to include into
713 +# the backup archive.
715 +# @speed: #optional the maximum speed, in bytes per second
717 +# Returns: the uuid of the backup job
721 +{ 'command': 'backup', 'data': { 'backupfile': 'str', '*format': 'BackupFormat',
722 + '*config-filename': 'str',
723 + '*devlist': 'str', '*speed': 'int' },
729 +# Returns information about current/last backup task.
731 +# Returns: @BackupStatus
735 +{ 'command': 'query-backup', 'returns': 'BackupStatus' }
740 +# Cancel the current executing backup process.
742 +# Returns: nothing on success
744 +# Notes: This command succeeds even if there is no backup process running.
748 +{ 'command': 'backup-cancel' }
753 diff --git a/qmp-commands.hx b/qmp-commands.hx
754 index 5c692d0..c46fdc4 100644
755 --- a/qmp-commands.hx
756 +++ b/qmp-commands.hx
757 @@ -822,6 +822,18 @@ EQMP
762 + .args_type = "backupfile:s,format:s?,config-filename:F?,speed:o?,devlist:s?",
763 + .mhandler.cmd_new = qmp_marshal_input_backup,
767 + .name = "backup_cancel",
769 + .mhandler.cmd_new = qmp_marshal_input_backup_cancel,
773 .name = "block-job-set-speed",
774 .args_type = "device:B,speed:o",
775 .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
776 @@ -2491,6 +2503,21 @@ EQMP
789 + .name = "query-backup",
791 + .mhandler.cmd_new = qmp_marshal_input_query_backup,
795 migrate-set-capabilities