[pve-qemu-kvm.git] / debian / patches / backup-add-dir-format.patch

Index: new/qapi-schema.json
===================================================================
--- new.orig/qapi-schema.json	2014-11-20 08:59:29.000000000 +0100
+++ new/qapi-schema.json	2014-11-20 09:03:23.000000000 +0100
@@ -391,7 +391,7 @@
 # @vma: Proxmox vma backup format
 ##
 { 'enum': 'BackupFormat',
-  'data': [ 'vma' ] }
+  'data': [ 'vma', 'dir' ] }
 
 ##
 # @backup:
Index: new/blockdev.c
===================================================================
--- new.orig/blockdev.c	2014-11-20 08:59:29.000000000 +0100
+++ new/blockdev.c	2014-11-20 09:04:05.000000000 +0100
@@ -2301,6 +2301,8 @@
     uint8_t dev_id;
     //bool started;
     bool completed;
+    char targetfile[PATH_MAX];
+    BlockDriverState *target;
 } PVEBackupDevInfo;
 
 static void pvebackup_run_next_job(void);
@@ -2369,8 +2371,6 @@
 {
     PVEBackupDevInfo *di = opaque;
 
-    assert(backup_state.vmaw);
-
     di->completed = true;
 
     if (ret < 0 && !backup_state.error) {
@@ -2381,8 +2381,11 @@
     BlockDriverState *bs = di->bs;
 
     di->bs = NULL;
+    di->target = NULL;
 
-    vma_writer_close_stream(backup_state.vmaw, di->dev_id);
+    if (backup_state.vmaw) {
+        vma_writer_close_stream(backup_state.vmaw, di->dev_id);
+    }
 
     block_job_cb(bs, ret);
 
@@ -2461,6 +2464,7 @@
 {
     BlockBackend *blk;
     BlockDriverState *bs = NULL;
+    const char *backup_dir = NULL;
     Error *local_err = NULL;
     uuid_t uuid;
     VmaWriter *vmaw = NULL;
@@ -2478,11 +2482,6 @@
     /* Todo: try to auto-detect format based on file name */
     format = has_format ? format : BACKUP_FORMAT_VMA;
 
-    if (format != BACKUP_FORMAT_VMA) {
-        error_set(errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
-        return NULL;
-    }
-
     if (has_devlist) {
         devs = g_strsplit_set(devlist, ",;:", -1);
 
@@ -2551,27 +2550,63 @@
 
     uuid_generate(uuid);
 
-    vmaw = vma_writer_create(backup_file, uuid, &local_err);
-    if (!vmaw) {
-        if (local_err) {
-            error_propagate(errp, local_err);
+    if (format == BACKUP_FORMAT_VMA) {
+        vmaw = vma_writer_create(backup_file, uuid, &local_err);
+        if (!vmaw) {
+            if (local_err) {
+                error_propagate(errp, local_err);
+            }
+            goto err;
         }
-        goto err;
-    }
 
-    /* register all devices for vma writer */
-    l = di_list;
-    while (l) {
-        PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-        l = g_list_next(l);
+        /* register all devices for vma writer */
+        l = di_list;
+        while (l) {
+            PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+            l = g_list_next(l);
 
-        const char *devname = bdrv_get_device_name(di->bs);
-        di->dev_id = vma_writer_register_stream(vmaw, devname, di->size);
-        if (di->dev_id <= 0) {
-            error_set(errp, ERROR_CLASS_GENERIC_ERROR,
-                      "register_stream failed");
+            const char *devname = bdrv_get_device_name(di->bs);
+            di->dev_id = vma_writer_register_stream(vmaw, devname, di->size);
+            if (di->dev_id <= 0) {
+                error_set(errp, ERROR_CLASS_GENERIC_ERROR,
+                          "register_stream failed");
+                goto err;
+            }
+        }
+    } else if (format == BACKUP_FORMAT_DIR) {
+        if (mkdir(backup_file, 0640) != 0) {
+            error_setg_errno(errp, errno, "can't create directory '%s'\n",
+                             backup_file);
             goto err;
         }
+        backup_dir = backup_file;
+
+        l = di_list;
+        while (l) {
+            PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+            l = g_list_next(l);
+
+            const char *devname = bdrv_get_device_name(di->bs);
+            snprintf(di->targetfile, PATH_MAX, "%s/%s.raw", backup_dir, devname);
+
+            int flags = BDRV_O_RDWR|BDRV_O_CACHE_WB;
+            bdrv_img_create(di->targetfile, "raw", NULL, NULL, NULL,
+                            di->size, flags, &local_err, false);
+            if (local_err) {
+                error_propagate(errp, local_err);
+                goto err;
+            }
+
+            di->target = bdrv_new();
+            if (bdrv_open(&di->target, di->targetfile, NULL, NULL, flags, NULL, &local_err) < 0) {
+                bdrv_unref(di->target);
+                error_propagate(errp, local_err);
+                goto err;
+            }
+        }
+    } else {
+       error_set(errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
+       goto err;
     }
 
     /* add configuration file to archive */
@@ -2584,12 +2619,27 @@
             goto err;
         }
 
-        const char *basename = g_path_get_basename(config_file);
-        if (vma_writer_add_config(vmaw, basename, cdata, clen) != 0) {
-            error_setg(errp, "unable to add config data to vma archive");
-            g_free(cdata);
-            goto err;
+        char *basename = g_path_get_basename(config_file);
+
+        if (format == BACKUP_FORMAT_VMA) {
+            if (vma_writer_add_config(vmaw, basename, cdata, clen) != 0) {
+                error_setg(errp, "unable to add config data to vma archive");
+                g_free(cdata);
+                g_free(basename);
+                goto err;
+            }
+        } else if (format == BACKUP_FORMAT_DIR) {
+            char config_path[PATH_MAX];
+            snprintf(config_path, PATH_MAX, "%s/%s", backup_dir, basename);
+            if (!g_file_set_contents(config_path, cdata, clen, &err)) {
+                error_setg(errp, "unable to write config file '%s'", config_path);
+                g_free(cdata);
+                g_free(basename);
+                goto err;
+            }
         }
+
+        g_free(basename);
         g_free(cdata);
     }
 
@@ -2629,10 +2679,11 @@
         PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
         l = g_list_next(l);
 
-        backup_start(di->bs, NULL, speed, MIRROR_SYNC_MODE_FULL, NULL,
+        backup_start(di->bs, di->target, speed, MIRROR_SYNC_MODE_FULL, NULL,
                      BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
                      pvebackup_dump_cb, pvebackup_complete_cb, di,
                      1, &local_err);
+
         if (local_err != NULL) {
             error_setg(&backup_state.error, "backup_job_create failed");
             pvebackup_cancel(NULL);
@@ -2651,8 +2702,17 @@
 
     l = di_list;
     while (l) {
-        g_free(l->data);
+        PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
         l = g_list_next(l);
+
+        if (di->target) {
+            bdrv_unref(di->target);
+        }
+
+        if (di->targetfile[0]) {
+            unlink(di->targetfile);
+        }
+        g_free(di);
     }
     g_list_free(di_list);
 
@@ -2666,6 +2726,10 @@
         unlink(backup_file);
     }
 
+    if (backup_dir) {
+        rmdir(backup_dir);
+    }
+
     return NULL;
 }
 
Index: new/hmp-commands.hx
===================================================================
--- new.orig/hmp-commands.hx	2014-11-20 08:59:29.000000000 +0100
+++ new/hmp-commands.hx	2014-11-20 09:03:23.000000000 +0100
@@ -89,9 +89,11 @@
 
    {
         .name       = "backup",
-        .args_type  = "backupfile:s,speed:o?,devlist:s?",
-        .params     = "backupfile [speed [devlist]]",
-        .help       = "create a VM Backup.",
+        .args_type  = "directory:-d,backupfile:s,speed:o?,devlist:s?",
+        .params     = "[-d] backupfile [speed [devlist]]",
+        .help       = "create a VM Backup."
+		    "\n\t\t\t Use -d to dump data into a directory instead"
+		    "\n\t\t\t of using VMA format.",
         .mhandler.cmd = hmp_backup,
     },
 
Index: new/hmp.c
===================================================================
--- new.orig/hmp.c	2014-11-20 08:59:29.000000000 +0100
+++ new/hmp.c	2014-11-20 09:03:23.000000000 +0100
@@ -1459,11 +1459,13 @@
 {
     Error *error = NULL;
 
+    int dir = qdict_get_try_bool(qdict, "directory", 0);
     const char *backup_file = qdict_get_str(qdict, "backupfile");
     const char *devlist = qdict_get_try_str(qdict, "devlist");
     int64_t speed = qdict_get_try_int(qdict, "speed", 0);
 
-    qmp_backup(backup_file, true, BACKUP_FORMAT_VMA, false, NULL, !!devlist,
+    qmp_backup(backup_file, true, dir ? BACKUP_FORMAT_DIR : BACKUP_FORMAT_VMA,
+               false, NULL, !!devlist,
                devlist, qdict_haskey(qdict, "speed"), speed, &error);
 
     hmp_handle_error(mon, &error);
Commit	Line	Data
2bde36a4 DM	1	Index: new/qapi-schema.json
2bde36a4 DM	2	===================================================================
24bb7da3 DM	3	--- new.orig/qapi-schema.json 2014-11-20 08:59:29.000000000 +0100
	4	+++ new/qapi-schema.json 2014-11-20 09:03:23.000000000 +0100
	5	@@ -391,7 +391,7 @@
2bde36a4 DM	6	# @vma: Proxmox vma backup format
	7	##
	8	{ 'enum': 'BackupFormat',
	9	- 'data': [ 'vma' ] }
	10	+ 'data': [ 'vma', 'dir' ] }
	11
	12	##
	13	# @backup:
	14	Index: new/blockdev.c
	15	===================================================================
24bb7da3 DM	16	--- new.orig/blockdev.c 2014-11-20 08:59:29.000000000 +0100
24bb7da3 DM	17	+++ new/blockdev.c 2014-11-20 09:04:05.000000000 +0100
1fc535a6	18	@@ -2301,6 +2301,8 @@
2bde36a4 DM	19	uint8_t dev_id;
	20	//bool started;
	21	bool completed;
	22	+ char targetfile[PATH_MAX];
	23	+ BlockDriverState *target;
	24	} PVEBackupDevInfo;
	25
	26	static void pvebackup_run_next_job(void);
1fc535a6	27	@@ -2369,8 +2371,6 @@
1f41b4e8 DM	28	{
1f41b4e8 DM	29	PVEBackupDevInfo *di = opaque;
2bde36a4	30
1f41b4e8 DM	31	- assert(backup_state.vmaw);
1f41b4e8 DM	32	-
2bde36a4	33	di->completed = true;
81300c8b	34
be73ac8a	35	if (ret < 0 && !backup_state.error) {
1fc535a6	36	@@ -2381,8 +2381,11 @@
81300c8b DM	37	BlockDriverState *bs = di->bs;
81300c8b DM	38
2bde36a4 DM	39	di->bs = NULL;
	40	+ di->target = NULL;
	41
	42	- vma_writer_close_stream(backup_state.vmaw, di->dev_id);
	43	+ if (backup_state.vmaw) {
	44	+ vma_writer_close_stream(backup_state.vmaw, di->dev_id);
	45	+ }
	46
81300c8b DM	47	block_job_cb(bs, ret);
81300c8b DM	48
1fc535a6	49	@@ -2461,6 +2464,7 @@
2bde36a4	50	{
58117ea6 WB	51	BlockBackend *blk;
58117ea6 WB	52	BlockDriverState *bs = NULL;
2bde36a4 DM	53	+ const char *backup_dir = NULL;
	54	Error *local_err = NULL;
	55	uuid_t uuid;
	56	VmaWriter *vmaw = NULL;
1fc535a6	57	@@ -2478,11 +2482,6 @@
2bde36a4 DM	58	/* Todo: try to auto-detect format based on file name */
	59	format = has_format ? format : BACKUP_FORMAT_VMA;
	60
	61	- if (format != BACKUP_FORMAT_VMA) {
	62	- error_set(errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
	63	- return NULL;
	64	- }
	65	-
	66	if (has_devlist) {
	67	devs = g_strsplit_set(devlist, ",;:", -1);
	68
1fc535a6	69	@@ -2551,27 +2550,63 @@
2bde36a4 DM	70
	71	uuid_generate(uuid);
	72
	73	- vmaw = vma_writer_create(backup_file, uuid, &local_err);
	74	- if (!vmaw) {
fbe817e2	75	- if (local_err) {
2bde36a4 DM	76	- error_propagate(errp, local_err);
	77	+ if (format == BACKUP_FORMAT_VMA) {
	78	+ vmaw = vma_writer_create(backup_file, uuid, &local_err);
	79	+ if (!vmaw) {
fbe817e2	80	+ if (local_err) {
2bde36a4 DM	81	+ error_propagate(errp, local_err);
	82	+ }
	83	+ goto err;
	84	}
	85	- goto err;
	86	- }
	87
	88	- /* register all devices for vma writer */
	89	- l = di_list;
	90	- while (l) {
	91	- PVEBackupDevInfo di = (PVEBackupDevInfo )l->data;
	92	- l = g_list_next(l);
	93	+ /* register all devices for vma writer */
	94	+ l = di_list;
	95	+ while (l) {
	96	+ PVEBackupDevInfo di = (PVEBackupDevInfo )l->data;
	97	+ l = g_list_next(l);
	98
	99	- const char *devname = bdrv_get_device_name(di->bs);
	100	- di->dev_id = vma_writer_register_stream(vmaw, devname, di->size);
	101	- if (di->dev_id <= 0) {
	102	- error_set(errp, ERROR_CLASS_GENERIC_ERROR,
	103	- "register_stream failed");
	104	+ const char *devname = bdrv_get_device_name(di->bs);
	105	+ di->dev_id = vma_writer_register_stream(vmaw, devname, di->size);
	106	+ if (di->dev_id <= 0) {
	107	+ error_set(errp, ERROR_CLASS_GENERIC_ERROR,
	108	+ "register_stream failed");
	109	+ goto err;
	110	+ }
	111	+ }
	112	+ } else if (format == BACKUP_FORMAT_DIR) {
	113	+ if (mkdir(backup_file, 0640) != 0) {
	114	+ error_setg_errno(errp, errno, "can't create directory '%s'\n",
	115	+ backup_file);
	116	goto err;
	117	}
	118	+ backup_dir = backup_file;
	119	+
	120	+ l = di_list;
	121	+ while (l) {
	122	+ PVEBackupDevInfo di = (PVEBackupDevInfo )l->data;
	123	+ l = g_list_next(l);
	124	+
	125	+ const char *devname = bdrv_get_device_name(di->bs);
	126	+ snprintf(di->targetfile, PATH_MAX, "%s/%s.raw", backup_dir, devname);
	127	+
	128	+ int flags = BDRV_O_RDWR\|BDRV_O_CACHE_WB;
	129	+ bdrv_img_create(di->targetfile, "raw", NULL, NULL, NULL,
	130	+ di->size, flags, &local_err, false);
fbe817e2	131	+ if (local_err) {
2bde36a4 DM	132	+ error_propagate(errp, local_err);
	133	+ goto err;
	134	+ }
	135	+
24bb7da3	136	+ di->target = bdrv_new();
85e020cf	137	+ if (bdrv_open(&di->target, di->targetfile, NULL, NULL, flags, NULL, &local_err) < 0) {
2bde36a4 DM	138	+ bdrv_unref(di->target);
	139	+ error_propagate(errp, local_err);
	140	+ goto err;
	141	+ }
	142	+ }
	143	+ } else {
	144	+ error_set(errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
	145	+ goto err;
	146	}
	147
	148	/* add configuration file to archive */
1fc535a6	149	@@ -2584,12 +2619,27 @@
2bde36a4 DM	150	goto err;
	151	}
	152
	153	- const char *basename = g_path_get_basename(config_file);
	154	- if (vma_writer_add_config(vmaw, basename, cdata, clen) != 0) {
	155	- error_setg(errp, "unable to add config data to vma archive");
	156	- g_free(cdata);
	157	- goto err;
	158	+ char *basename = g_path_get_basename(config_file);
	159	+
	160	+ if (format == BACKUP_FORMAT_VMA) {
	161	+ if (vma_writer_add_config(vmaw, basename, cdata, clen) != 0) {
	162	+ error_setg(errp, "unable to add config data to vma archive");
	163	+ g_free(cdata);
	164	+ g_free(basename);
	165	+ goto err;
	166	+ }
	167	+ } else if (format == BACKUP_FORMAT_DIR) {
	168	+ char config_path[PATH_MAX];
1f4921fb	169	+ snprintf(config_path, PATH_MAX, "%s/%s", backup_dir, basename);
2bde36a4 DM	170	+ if (!g_file_set_contents(config_path, cdata, clen, &err)) {
	171	+ error_setg(errp, "unable to write config file '%s'", config_path);
	172	+ g_free(cdata);
	173	+ g_free(basename);
	174	+ goto err;
	175	+ }
	176	}
	177	+
	178	+ g_free(basename);
	179	g_free(cdata);
	180	}
	181
1fc535a6	182	@@ -2629,10 +2679,11 @@
2bde36a4 DM	183	PVEBackupDevInfo di = (PVEBackupDevInfo )l->data;
	184	l = g_list_next(l);
	185
1fc535a6 WB	186	- backup_start(di->bs, NULL, speed, MIRROR_SYNC_MODE_FULL, NULL,
1fc535a6 WB	187	+ backup_start(di->bs, di->target, speed, MIRROR_SYNC_MODE_FULL, NULL,
2bde36a4 DM	188	BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
2bde36a4 DM	189	pvebackup_dump_cb, pvebackup_complete_cb, di,
9ceb049d	190	1, &local_err);
2bde36a4 DM	191	+
	192	if (local_err != NULL) {
	193	error_setg(&backup_state.error, "backup_job_create failed");
	194	pvebackup_cancel(NULL);
1fc535a6	195	@@ -2651,8 +2702,17 @@
2bde36a4 DM	196
	197	l = di_list;
	198	while (l) {
	199	- g_free(l->data);
	200	+ PVEBackupDevInfo di = (PVEBackupDevInfo )l->data;
	201	l = g_list_next(l);
	202	+
	203	+ if (di->target) {
	204	+ bdrv_unref(di->target);
	205	+ }
	206	+
	207	+ if (di->targetfile[0]) {
	208	+ unlink(di->targetfile);
	209	+ }
	210	+ g_free(di);
	211	}
	212	g_list_free(di_list);
	213
1fc535a6	214	@@ -2666,6 +2726,10 @@
2bde36a4 DM	215	unlink(backup_file);
	216	}
	217
	218	+ if (backup_dir) {
	219	+ rmdir(backup_dir);
	220	+ }
	221	+
	222	return NULL;
	223	}
	224
c9df43dd DM	225	Index: new/hmp-commands.hx
c9df43dd DM	226	===================================================================
24bb7da3 DM	227	--- new.orig/hmp-commands.hx 2014-11-20 08:59:29.000000000 +0100
24bb7da3 DM	228	+++ new/hmp-commands.hx 2014-11-20 09:03:23.000000000 +0100
1fc535a6	229	@@ -89,9 +89,11 @@
c9df43dd DM	230
	231	{
	232	.name = "backup",
	233	- .args_type = "backupfile:s,speed:o?,devlist:s?",
	234	- .params = "backupfile [speed [devlist]]",
	235	- .help = "create a VM Backup.",
	236	+ .args_type = "directory:-d,backupfile:s,speed:o?,devlist:s?",
	237	+ .params = "[-d] backupfile [speed [devlist]]",
1f41b4e8	238	+ .help = "create a VM Backup."
c9df43dd DM	239	+ "\n\t\t\t Use -d to dump data into a directory instead"
	240	+ "\n\t\t\t of using VMA format.",
	241	.mhandler.cmd = hmp_backup,
	242	},
	243
	244	Index: new/hmp.c
	245	===================================================================
24bb7da3 DM	246	--- new.orig/hmp.c 2014-11-20 08:59:29.000000000 +0100
24bb7da3 DM	247	+++ new/hmp.c 2014-11-20 09:03:23.000000000 +0100
1fc535a6	248	@@ -1459,11 +1459,13 @@
c9df43dd DM	249	{
	250	Error *error = NULL;
	251
	252	+ int dir = qdict_get_try_bool(qdict, "directory", 0);
	253	const char *backup_file = qdict_get_str(qdict, "backupfile");
	254	const char *devlist = qdict_get_try_str(qdict, "devlist");
	255	int64_t speed = qdict_get_try_int(qdict, "speed", 0);
	256
	257	- qmp_backup(backup_file, true, BACKUP_FORMAT_VMA, false, NULL, !!devlist,
	258	+ qmp_backup(backup_file, true, dir ? BACKUP_FORMAT_DIR : BACKUP_FORMAT_VMA,
	259	+ false, NULL, !!devlist,
	260	devlist, qdict_haskey(qdict, "speed"), speed, &error);
	261
	262	hmp_handle_error(mon, &error);