| blob | 0a23a45bc941322f364966c1f388a2f60cbebed3 |
1 From cf9cc8878d3246069da3fdf7ec865b7b983487fe 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 v5 3/6] add backup related monitor commands
6 We use a generic BackupDriver struct to encapsulate all archive format
7 related function.
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>
14 ---
15 backup.h | 15 ++
16 blockdev.c | 423 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
17 hmp-commands.hx | 31 ++++
18 hmp.c | 63 ++++++++
19 hmp.h | 3 +
20 monitor.c | 7 +
21 qapi-schema.json | 95 ++++++++++++
22 qmp-commands.hx | 27 ++++
23 8 files changed, 664 insertions(+), 0 deletions(-)
25 diff --git a/backup.h b/backup.h
26 index 9b1ea1c..22598a6 100644
27 --- a/backup.h
28 +++ b/backup.h
29 @@ -14,6 +14,9 @@
30 #ifndef QEMU_BACKUP_H
31 #define QEMU_BACKUP_H
33 +#include <uuid/uuid.h>
34 +#include "block/block.h"
35 +
36 #define BACKUP_CLUSTER_BITS 16
37 #define BACKUP_CLUSTER_SIZE (1<<BACKUP_CLUSTER_BITS)
38 #define BACKUP_BLOCKS_PER_CLUSTER (BACKUP_CLUSTER_SIZE/BDRV_SECTOR_SIZE)
39 @@ -27,4 +30,16 @@ int backup_job_create(BlockDriverState *bs, BackupDumpFunc *backup_dump_cb,
40 BlockDriverCompletionFunc *backup_complete_cb,
41 void *opaque, int64_t speed);
43 +typedef struct BackupDriver {
44 + const char *format;
45 + void *(*open)(const char *filename, uuid_t uuid, Error **errp);
46 + int (*close)(void *opaque, Error **errp);
47 + int (*register_config)(void *opaque, const char *name, gpointer data,
48 + size_t data_len);
49 + int (*register_stream)(void *opaque, const char *devname, size_t size);
50 + int (*dump)(void *opaque, uint8_t dev_id, int64_t cluster_num,
51 + unsigned char *buf, size_t *zero_bytes);
52 + int (*complete)(void *opaque, uint8_t dev_id, int ret);
53 +} BackupDriver;
54 +
55 #endif /* QEMU_BACKUP_H */
56 diff --git a/blockdev.c b/blockdev.c
57 index 63e6f1e..84f598d 100644
58 --- a/blockdev.c
59 +++ b/blockdev.c
60 @@ -20,6 +20,7 @@
61 #include "qmp-commands.h"
62 #include "trace.h"
63 #include "sysemu/arch_init.h"
64 +#include "backup.h"
66 static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives);
68 @@ -1334,6 +1335,428 @@ void qmp_drive_mirror(const char *device, const char *target,
69 drive_get_ref(drive_get_by_blockdev(bs));
70 }
72 +/* Backup related function */
73 +
74 +static void backup_run_next_job(void);
75 +
76 +static struct GenericBackupState {
77 + Error *error;
78 + bool cancel;
79 + uuid_t uuid;
80 + char uuid_str[37];
81 + int64_t speed;
82 + time_t start_time;
83 + time_t end_time;
84 + char *backup_file;
85 + const BackupDriver *driver;
86 + void *writer;
87 + GList *bcb_list;
88 + size_t total;
89 + size_t transferred;
90 + size_t zero_bytes;
91 +} backup_state;
92 +
93 +typedef struct BackupCB {
94 + BlockDriverState *bs;
95 + uint8_t dev_id;
96 + bool started;
97 + bool completed;
98 + size_t size;
99 + size_t transferred;
100 + size_t zero_bytes;
101 +} BackupCB;
102 +
103 +static int backup_dump_cb(void *opaque, BlockDriverState *bs,
104 + int64_t cluster_num, unsigned char *buf)
105 +{
106 + BackupCB *bcb = opaque;
107 +
108 + assert(backup_state.driver);
109 + assert(backup_state.writer);
110 + assert(backup_state.driver->dump);
111 +
112 + size_t zero_bytes = 0;
113 + int bytes = backup_state.driver->dump(backup_state.writer,
114 + bcb->dev_id, cluster_num,
115 + buf, &zero_bytes);
116 +
117 + if (bytes > 0) {
118 + bcb->transferred += bytes;
119 + backup_state.transferred += bytes;
120 + if (zero_bytes) {
121 + bcb->zero_bytes += bytes;
122 + backup_state.zero_bytes += zero_bytes;
123 + }
124 + }
125 +
126 + return bytes;
127 +}
128 +
129 +static void backup_cleanup(void)
130 +{
131 + if (backup_state.writer && backup_state.driver) {
132 + backup_state.end_time = time(NULL);
133 + Error *local_err = NULL;
134 + backup_state.driver->close(backup_state.writer, &local_err);
135 + error_propagate(&backup_state.error, local_err);
136 + backup_state.writer = NULL;
137 + }
138 +
139 + if (backup_state.bcb_list) {
140 + GList *l = backup_state.bcb_list;
141 + while (l) {
142 + BackupCB *bcb = l->data;
143 + l = g_list_next(l);
144 + drive_put_ref_bh_schedule(drive_get_by_blockdev(bcb->bs));
145 + g_free(bcb);
146 + }
147 + g_list_free(backup_state.bcb_list);
148 + backup_state.bcb_list = NULL;
149 + }
150 +}
151 +
152 +static void backup_complete_cb(void *opaque, int ret)
153 +{
154 + BackupCB *bcb = opaque;
155 +
156 + assert(backup_state.driver);
157 + assert(backup_state.writer);
158 + assert(backup_state.driver->complete);
159 + assert(backup_state.driver->close);
160 +
161 + bcb->completed = true;
162 +
163 + backup_state.driver->complete(backup_state.writer, bcb->dev_id, ret);
164 +
165 + if (!backup_state.cancel) {
166 + backup_run_next_job();
167 + }
168 +}
169 +
170 +static void backup_cancel(void)
171 +{
172 + backup_state.cancel = true;
173 +
174 + if (!backup_state.error) {
175 + error_setg(&backup_state.error, "backup cancelled");
176 + }
177 +
178 + /* drain all i/o (awake jobs waiting for aio) */
179 + bdrv_drain_all();
180 +
181 + int job_count = 0;
182 + GList *l = backup_state.bcb_list;
183 + while (l) {
184 + BackupCB *bcb = l->data;
185 + l = g_list_next(l);
186 + BlockJob *job = bcb->bs->job;
187 + if (job) {
188 + job_count++;
189 + if (!bcb->started) {
190 + bcb->started = true;
191 + backup_job_start(bcb->bs, true);
192 + }
193 + if (!bcb->completed) {
194 + block_job_cancel_sync(job);
195 + }
196 + }
197 + }
198 +
199 + backup_cleanup();
200 +}
201 +
202 +void qmp_backup_cancel(Error **errp)
203 +{
204 + backup_cancel();
205 +}
206 +
207 +static void backup_run_next_job(void)
208 +{
209 + GList *l = backup_state.bcb_list;
210 + while (l) {
211 + BackupCB *bcb = l->data;
212 + l = g_list_next(l);
213 +
214 + if (bcb->bs && bcb->bs->job && !bcb->completed) {
215 + if (!bcb->started) {
216 + bcb->started = true;
217 + bool cancel = backup_state.error || backup_state.cancel;
218 + backup_job_start(bcb->bs, cancel);
219 + }
220 + return;
221 + }
222 + }
223 +
224 + backup_cleanup();
225 +}
226 +
227 +static void backup_start_jobs(void)
228 +{
229 + /* create all jobs (one for each device), start first one */
230 + GList *l = backup_state.bcb_list;
231 + while (l) {
232 + BackupCB *bcb = l->data;
233 + l = g_list_next(l);
234 +
235 + if (backup_job_create(bcb->bs, backup_dump_cb, backup_complete_cb,
236 + bcb, backup_state.speed) != 0) {
237 + error_setg(&backup_state.error, "backup_job_create failed");
238 + backup_cancel();
239 + return;
240 + }
241 + }
242 +
243 + backup_run_next_job();
244 +}
245 +
246 +char *qmp_backup(const char *backup_file, bool has_format, BackupFormat format,
247 + bool has_config_file, const char *config_file,
248 + bool has_devlist, const char *devlist,
249 + bool has_speed, int64_t speed, Error **errp)
250 +{
251 + BlockDriverState *bs;
252 + Error *local_err = NULL;
253 + uuid_t uuid;
254 + void *writer = NULL;
255 + gchar **devs = NULL;
256 + GList *bcblist = NULL;
257 +
258 + if (backup_state.bcb_list) {
259 + error_set(errp, ERROR_CLASS_GENERIC_ERROR,
260 + "previous backup not finished");
261 + return NULL;
262 + }
263 +
264 + /* Todo: try to auto-detect format based on file name */
265 + format = has_format ? format : BACKUP_FORMAT_VMA;
266 +
267 + /* fixme: find driver for specifued format */
268 + const BackupDriver *driver = NULL;
269 +
270 + if (!driver) {
271 + error_set(errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
272 + return NULL;
273 + }
274 +
275 + if (has_devlist) {
276 + devs = g_strsplit_set(devlist, ",;:", -1);
277 +
278 + gchar **d = devs;
279 + while (d && *d) {
280 + bs = bdrv_find(*d);
281 + if (bs) {
282 + if (bdrv_is_read_only(bs)) {
283 + error_set(errp, QERR_DEVICE_IS_READ_ONLY, *d);
284 + goto err;
285 + }
286 + if (!bdrv_is_inserted(bs)) {
287 + error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, *d);
288 + goto err;
289 + }
290 + BackupCB *bcb = g_new0(BackupCB, 1);
291 + bcb->bs = bs;
292 + bcblist = g_list_append(bcblist, bcb);
293 + } else {
294 + error_set(errp, QERR_DEVICE_NOT_FOUND, *d);
295 + goto err;
296 + }
297 + d++;
298 + }
299 +
300 + } else {
301 +
302 + bs = NULL;
303 + while ((bs = bdrv_next(bs))) {
304 +
305 + if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
306 + continue;
307 + }
308 +
309 + BackupCB *bcb = g_new0(BackupCB, 1);
310 + bcb->bs = bs;
311 + bcblist = g_list_append(bcblist, bcb);
312 + }
313 + }
314 +
315 + if (!bcblist) {
316 + error_set(errp, ERROR_CLASS_GENERIC_ERROR, "empty device list");
317 + goto err;
318 + }
319 +
320 + GList *l = bcblist;
321 + while (l) {
322 + BackupCB *bcb = l->data;
323 + l = g_list_next(l);
324 + if (bcb->bs->job) {
325 + error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bcb->bs));
326 + goto err;
327 + }
328 + }
329 +
330 + uuid_generate(uuid);
331 +
332 + writer = driver->open(backup_file, uuid, &local_err);
333 + if (!writer) {
334 + if (error_is_set(&local_err)) {
335 + error_propagate(errp, local_err);
336 + }
337 + goto err;
338 + }
339 +
340 + size_t total = 0;
341 +
342 + /* register all devices for vma writer */
343 + l = bcblist;
344 + while (l) {
345 + BackupCB *bcb = l->data;
346 + l = g_list_next(l);
347 +
348 + int64_t size = bdrv_getlength(bcb->bs);
349 + const char *devname = bdrv_get_device_name(bcb->bs);
350 + bcb->dev_id = driver->register_stream(writer, devname, size);
351 + if (bcb->dev_id <= 0) {
352 + error_set(errp, ERROR_CLASS_GENERIC_ERROR,
353 + "register_stream failed");
354 + goto err;
355 + }
356 + bcb->size = size;
357 + total += size;
358 + }
359 +
360 + /* add configuration file to archive */
361 + if (has_config_file) {
362 + char *cdata = NULL;
363 + gsize clen = 0;
364 + GError *err = NULL;
365 + if (!g_file_get_contents(config_file, &cdata, &clen, &err)) {
366 + error_setg(errp, "unable to read file '%s'", config_file);
367 + goto err;
368 + }
369 +
370 + const char *basename = g_path_get_basename(config_file);
371 + if (driver->register_config(writer, basename, cdata, clen) < 0) {
372 + error_setg(errp, "register_config failed");
373 + g_free(cdata);
374 + goto err;
375 + }
376 + g_free(cdata);
377 + }
378 +
379 + /* initialize global backup_state now */
380 +
381 + backup_state.cancel = false;
382 +
383 + if (backup_state.error) {
384 + error_free(backup_state.error);
385 + backup_state.error = NULL;
386 + }
387 +
388 + backup_state.driver = driver;
389 +
390 + backup_state.speed = (has_speed && speed > 0) ? speed : 0;
391 +
392 + backup_state.start_time = time(NULL);
393 + backup_state.end_time = 0;
394 +
395 + if (backup_state.backup_file) {
396 + g_free(backup_state.backup_file);
397 + }
398 + backup_state.backup_file = g_strdup(backup_file);
399 +
400 + backup_state.writer = writer;
401 +
402 + uuid_copy(backup_state.uuid, uuid);
403 + uuid_unparse_lower(uuid, backup_state.uuid_str);
404 +
405 + backup_state.bcb_list = bcblist;
406 +
407 + backup_state.total = total;
408 + backup_state.transferred = 0;
409 + backup_state.zero_bytes = 0;
410 +
411 + /* Grab a reference so hotplug does not delete the
412 + * BlockDriverState from underneath us.
413 + */
414 + l = bcblist;
415 + while (l) {
416 + BackupCB *bcb = l->data;
417 + l = g_list_next(l);
418 + drive_get_ref(drive_get_by_blockdev(bcb->bs));
419 + }
420 +
421 + backup_start_jobs();
422 +
423 + return g_strdup(backup_state.uuid_str);
424 +
425 +err:
426 +
427 + l = bcblist;
428 + while (l) {
429 + g_free(l->data);
430 + l = g_list_next(l);
431 + }
432 + g_list_free(bcblist);
433 +
434 + if (devs) {
435 + g_strfreev(devs);
436 + }
437 +
438 + if (writer) {
439 + unlink(backup_file);
440 + if (driver) {
441 + Error *err = NULL;
442 + driver->close(writer, &err);
443 + }
444 + }
445 +
446 + return NULL;
447 +}
448 +
449 +BackupStatus *qmp_query_backup(Error **errp)
450 +{
451 + BackupStatus *info = g_malloc0(sizeof(*info));
452 +
453 + if (!backup_state.start_time) {
454 + /* not started, return {} */
455 + return info;
456 + }
457 +
458 + info->has_status = true;
459 + info->has_start_time = true;
460 + info->start_time = backup_state.start_time;
461 +
462 + if (backup_state.backup_file) {
463 + info->has_backup_file = true;
464 + info->backup_file = g_strdup(backup_state.backup_file);
465 + }
466 +
467 + info->has_uuid = true;
468 + info->uuid = g_strdup(backup_state.uuid_str);
469 +
470 + if (backup_state.end_time) {
471 + if (backup_state.error) {
472 + info->status = g_strdup("error");
473 + info->has_errmsg = true;
474 + info->errmsg = g_strdup(error_get_pretty(backup_state.error));
475 + } else {
476 + info->status = g_strdup("done");
477 + }
478 + info->has_end_time = true;
479 + info->end_time = backup_state.end_time;
480 + } else {
481 + info->status = g_strdup("active");
482 + }
483 +
484 + info->has_total = true;
485 + info->total = backup_state.total;
486 + info->has_zero_bytes = true;
487 + info->zero_bytes = backup_state.zero_bytes;
488 + info->has_transferred = true;
489 + info->transferred = backup_state.transferred;
490 +
491 + return info;
492 +}
493 +
494 static BlockJob *find_block_job(const char *device)
495 {
496 BlockDriverState *bs;
497 diff --git a/hmp-commands.hx b/hmp-commands.hx
498 index 64008a9..0f178d8 100644
499 --- a/hmp-commands.hx
500 +++ b/hmp-commands.hx
501 @@ -83,6 +83,35 @@ STEXI
502 Copy data from a backing file into a block device.
503 ETEXI
505 + {
506 + .name = "backup",
507 + .args_type = "backupfile:s,speed:o?,devlist:s?",
508 + .params = "backupfile [speed [devlist]]",
509 + .help = "create a VM Backup.",
510 + .mhandler.cmd = hmp_backup,
511 + },
512 +
513 +STEXI
514 +@item backup
515 +@findex backup
516 +Create a VM backup.
517 +ETEXI
518 +
519 + {
520 + .name = "backup_cancel",
521 + .args_type = "",
522 + .params = "",
523 + .help = "cancel the current VM backup",
524 + .mhandler.cmd = hmp_backup_cancel,
525 + },
526 +
527 +STEXI
528 +@item backup_cancel
529 +@findex backup_cancel
530 +Cancel the current VM backup.
531 +
532 +ETEXI
533 +
534 {
535 .name = "block_job_set_speed",
536 .args_type = "device:B,speed:o",
537 @@ -1630,6 +1659,8 @@ show CPU statistics
538 show user network stack connection states
539 @item info migrate
540 show migration status
541 +@item info backup
542 +show backup status
543 @item info migrate_capabilities
544 show current migration capabilities
545 @item info migrate_cache_size
546 diff --git a/hmp.c b/hmp.c
547 index 2f47a8a..b2c1f23 100644
548 --- a/hmp.c
549 +++ b/hmp.c
550 @@ -131,6 +131,38 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
551 qapi_free_MouseInfoList(mice_list);
552 }
554 +void hmp_info_backup(Monitor *mon, const QDict *qdict)
555 +{
556 + BackupStatus *info;
557 +
558 + info = qmp_query_backup(NULL);
559 + if (info->has_status) {
560 + if (info->has_errmsg) {
561 + monitor_printf(mon, "Backup status: %s - %s\n",
562 + info->status, info->errmsg);
563 + } else {
564 + monitor_printf(mon, "Backup status: %s\n", info->status);
565 + }
566 + }
567 + if (info->has_backup_file) {
568 + int per = (info->has_total && info->total &&
569 + info->has_transferred && info->transferred) ?
570 + (info->transferred * 100)/info->total : 0;
571 + int zero_per = (info->has_total && info->total &&
572 + info->has_zero_bytes && info->zero_bytes) ?
573 + (info->zero_bytes * 100)/info->total : 0;
574 + monitor_printf(mon, "Backup file: %s\n", info->backup_file);
575 + monitor_printf(mon, "Backup uuid: %s\n", info->uuid);
576 + monitor_printf(mon, "Total size: %zd\n", info->total);
577 + monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
578 + info->transferred, per);
579 + monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
580 + info->zero_bytes, zero_per);
581 + }
582 +
583 + qapi_free_BackupStatus(info);
584 +}
585 +
586 void hmp_info_migrate(Monitor *mon, const QDict *qdict)
587 {
588 MigrationInfo *info;
589 @@ -998,6 +1030,37 @@ void hmp_block_stream(Monitor *mon, const QDict *qdict)
590 hmp_handle_error(mon, &error);
591 }
593 +void hmp_backup_cancel(Monitor *mon, const QDict *qdict)
594 +{
595 + Error *errp = NULL;
596 +
597 + qmp_backup_cancel(&errp);
598 +
599 + if (error_is_set(&errp)) {
600 + monitor_printf(mon, "%s\n", error_get_pretty(errp));
601 + error_free(errp);
602 + return;
603 + }
604 +}
605 +
606 +void hmp_backup(Monitor *mon, const QDict *qdict)
607 +{
608 + const char *backup_file = qdict_get_str(qdict, "backup-file");
609 + const char *devlist = qdict_get_try_str(qdict, "devlist");
610 + int64_t speed = qdict_get_try_int(qdict, "speed", 0);
611 +
612 + Error *errp = NULL;
613 +
614 + qmp_backup(backup_file, true, BACKUP_FORMAT_VMA, false, NULL, !!devlist,
615 + devlist, qdict_haskey(qdict, "speed"), speed, &errp);
616 +
617 + if (error_is_set(&errp)) {
618 + monitor_printf(mon, "%s\n", error_get_pretty(errp));
619 + error_free(errp);
620 + return;
621 + }
622 +}
623 +
624 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
625 {
626 Error *error = NULL;
627 diff --git a/hmp.h b/hmp.h
628 index 30b3c20..ad4cf80 100644
629 --- a/hmp.h
630 +++ b/hmp.h
631 @@ -28,6 +28,7 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict);
632 void hmp_info_migrate(Monitor *mon, const QDict *qdict);
633 void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict);
634 void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict);
635 +void hmp_info_backup(Monitor *mon, const QDict *qdict);
636 void hmp_info_cpus(Monitor *mon, const QDict *qdict);
637 void hmp_info_block(Monitor *mon, const QDict *qdict);
638 void hmp_info_blockstats(Monitor *mon, const QDict *qdict);
639 @@ -65,6 +66,8 @@ void hmp_eject(Monitor *mon, const QDict *qdict);
640 void hmp_change(Monitor *mon, const QDict *qdict);
641 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict);
642 void hmp_block_stream(Monitor *mon, const QDict *qdict);
643 +void hmp_backup(Monitor *mon, const QDict *qdict);
644 +void hmp_backup_cancel(Monitor *mon, const QDict *qdict);
645 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict);
646 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict);
647 void hmp_block_job_pause(Monitor *mon, const QDict *qdict);
648 diff --git a/monitor.c b/monitor.c
649 index 6a0f257..e4a810c 100644
650 --- a/monitor.c
651 +++ b/monitor.c
652 @@ -2666,6 +2666,13 @@ static mon_cmd_t info_cmds[] = {
653 },
654 #endif
655 {
656 + .name = "backup",
657 + .args_type = "",
658 + .params = "",
659 + .help = "show backup status",
660 + .mhandler.cmd = hmp_info_backup,
661 + },
662 + {
663 .name = "migrate",
664 .args_type = "",
665 .params = "",
666 diff --git a/qapi-schema.json b/qapi-schema.json
667 index 7275b5d..09ca8ef 100644
668 --- a/qapi-schema.json
669 +++ b/qapi-schema.json
670 @@ -425,6 +425,39 @@
671 { 'type': 'EventInfo', 'data': {'name': 'str'} }
673 ##
674 +# @BackupStatus:
675 +#
676 +# Detailed backup status.
677 +#
678 +# @status: #optional string describing the current backup status.
679 +# This can be 'active', 'done', 'error'. If this field is not
680 +# returned, no backup process has been initiated
681 +#
682 +# @errmsg: #optional error message (only returned if status is 'error')
683 +#
684 +# @total: #optional total amount of bytes involved in the backup process
685 +#
686 +# @transferred: #optional amount of bytes already backed up.
687 +#
688 +# @zero-bytes: #optional amount of 'zero' bytes detected.
689 +#
690 +# @start-time: #optional time (epoch) when backup job started.
691 +#
692 +# @end-time: #optional time (epoch) when backup job finished.
693 +#
694 +# @backupfile: #optional backup file name
695 +#
696 +# @uuid: #optional uuid for this backup job
697 +#
698 +# Since: 1.5.0
699 +##
700 +{ 'type': 'BackupStatus',
701 + 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int',
702 + '*transferred': 'int', '*zero-bytes': 'int',
703 + '*start-time': 'int', '*end-time': 'int',
704 + '*backup-file': 'str', '*uuid': 'str' } }
705 +
706 +##
707 # @query-events:
708 #
709 # Return a list of supported QMP events by this server
710 @@ -1824,6 +1857,68 @@
711 'data': { 'path': 'str' },
712 'returns': [ 'ObjectPropertyInfo' ] }
714 +
715 +##
716 +# @BackupFormat
717 +#
718 +# An enumeration of supported backup formats.
719 +#
720 +# @vma: Proxmox vma backup format
721 +##
722 +{ 'enum': 'BackupFormat',
723 + 'data': [ 'vma' ] }
724 +
725 +##
726 +# @backup:
727 +#
728 +# Starts a VM backup.
729 +#
730 +# @backup-file: the backup file name
731 +#
732 +# @format: format of the backup file
733 +#
734 +# @config-filename: #optional name of a configuration file to include into
735 +# the backup archive.
736 +#
737 +# @speed: #optional the maximum speed, in bytes per second
738 +#
739 +# @devlist: #optional list of block device names (separated by ',', ';'
740 +# or ':'). By default the backup includes all writable block devices.
741 +#
742 +# Returns: the uuid of the backup job
743 +#
744 +# Since: 1.5.0
745 +##
746 +{ 'command': 'backup', 'data': { 'backup-file': 'str',
747 + '*format': 'BackupFormat',
748 + '*config-file': 'str',
749 + '*devlist': 'str', '*speed': 'int' },
750 + 'returns': 'str' }
751 +
752 +##
753 +# @query-backup
754 +#
755 +# Returns information about current/last backup task.
756 +#
757 +# Returns: @BackupStatus
758 +#
759 +# Since: 1.5.0
760 +##
761 +{ 'command': 'query-backup', 'returns': 'BackupStatus' }
762 +
763 +##
764 +# @backup-cancel
765 +#
766 +# Cancel the current executing backup process.
767 +#
768 +# Returns: nothing on success
769 +#
770 +# Notes: This command succeeds even if there is no backup process running.
771 +#
772 +# Since: 1.5.0
773 +##
774 +{ 'command': 'backup-cancel' }
775 +
776 ##
777 # @qom-get:
778 #
779 diff --git a/qmp-commands.hx b/qmp-commands.hx
780 index 799adea..17e381b 100644
781 --- a/qmp-commands.hx
782 +++ b/qmp-commands.hx
783 @@ -889,6 +889,18 @@ EQMP
784 },
786 {
787 + .name = "backup",
788 + .args_type = "backup-file:s,format:s?,config-file:F?,speed:o?,devlist:s?",
789 + .mhandler.cmd_new = qmp_marshal_input_backup,
790 + },
791 +
792 + {
793 + .name = "backup-cancel",
794 + .args_type = "",
795 + .mhandler.cmd_new = qmp_marshal_input_backup_cancel,
796 + },
797 +
798 + {
799 .name = "block-job-set-speed",
800 .args_type = "device:B,speed:o",
801 .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
802 @@ -2566,6 +2578,21 @@ EQMP
803 },
805 SQMP
806 +
807 +query-backup
808 +-------------
809 +
810 +Backup status.
811 +
812 +EQMP
813 +
814 + {
815 + .name = "query-backup",
816 + .args_type = "",
817 + .mhandler.cmd_new = qmp_marshal_input_query_backup,
818 + },
819 +
820 +SQMP
821 migrate-set-capabilities
822 -------
824 --
825 1.7.2.5