[pve-qemu-kvm.git] / debian / patches / pve / 0038-vma-byte-based-write-calls.patch

From a004ee9295029201e8fc3b8fe4acf7f85674527c Mon Sep 17 00:00:00 2001
From: Wolfgang Bumiller <w.bumiller@proxmox.com>
Date: Fri, 9 Sep 2016 14:51:28 +0200
Subject: [PATCH 38/48] vma: byte based write calls

---
 vma-reader.c | 42 +++++++++++++++++++++---------------------
 vma.c        | 22 ++++++++++------------
 vma.h        |  2 +-
 3 files changed, 32 insertions(+), 34 deletions(-)

diff --git a/vma-reader.c b/vma-reader.c
index 78f1de9..2000889 100644
--- a/vma-reader.c
+++ b/vma-reader.c
@@ -25,7 +25,7 @@
 static unsigned char zero_vma_block[VMA_BLOCK_SIZE];
 
 typedef struct VmaRestoreState {
-    BlockDriverState *bs;
+    BlockBackend *target;
     bool write_zeroes;
     unsigned long *bitmap;
     int bitmap_size;
@@ -423,12 +423,12 @@ VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id)
 }
 
 static void allocate_rstate(VmaReader *vmar,  guint8 dev_id,
-                            BlockDriverState *bs, bool write_zeroes)
+                            BlockBackend *target, bool write_zeroes)
 {
     assert(vmar);
     assert(dev_id);
 
-    vmar->rstate[dev_id].bs = bs;
+    vmar->rstate[dev_id].target = target;
     vmar->rstate[dev_id].write_zeroes = write_zeroes;
 
     int64_t size = vmar->devinfo[dev_id].size;
@@ -443,15 +443,15 @@ static void allocate_rstate(VmaReader *vmar,  guint8 dev_id,
     vmar->cluster_count += size/VMA_CLUSTER_SIZE;
 }
 
-int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockDriverState *bs,
+int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockBackend *target,
                            bool write_zeroes, Error **errp)
 {
     assert(vmar);
-    assert(bs != NULL);
+    assert(target != NULL);
     assert(dev_id);
-    assert(vmar->rstate[dev_id].bs == NULL);
+    assert(vmar->rstate[dev_id].target == NULL);
 
-    int64_t size = bdrv_getlength(bs);
+    int64_t size = blk_getlength(target);
     int64_t size_diff = size - vmar->devinfo[dev_id].size;
 
     /* storage types can have different size restrictions, so it
@@ -465,7 +465,7 @@ int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockDriverState *bs,
         return -1;
     }
 
-    allocate_rstate(vmar, dev_id, bs, write_zeroes);
+    allocate_rstate(vmar, dev_id, target, write_zeroes);
 
     return 0;
 }
@@ -507,7 +507,7 @@ static size_t full_write(int fd, void *buf, size_t len)
 }
 
 static int restore_write_data(VmaReader *vmar, guint8 dev_id,
-                              BlockDriverState *bs, int vmstate_fd,
+                              BlockBackend *target, int vmstate_fd,
                               unsigned char *buf, int64_t sector_num,
                               int nb_sectors, Error **errp)
 {
@@ -523,10 +523,10 @@ static int restore_write_data(VmaReader *vmar, guint8 dev_id,
             }
         }
     } else {
-        int res = bdrv_write(bs, sector_num, buf, nb_sectors);
+        int res = blk_pwrite(target, sector_num * BDRV_SECTOR_SIZE, buf, nb_sectors * BDRV_SECTOR_SIZE, 0);
         if (res < 0) {
-            error_setg(errp, "bdrv_write to %s failed (%d)",
-                       bdrv_get_device_name(bs), res);
+            error_setg(errp, "blk_pwrite to %s failed (%d)",
+                       bdrv_get_device_name(blk_bs(target)), res);
             return -1;
         }
     }
@@ -556,11 +556,11 @@ static int restore_extent(VmaReader *vmar, unsigned char *buf,
         }
 
         VmaRestoreState *rstate = &vmar->rstate[dev_id];
-        BlockDriverState *bs = NULL;
+        BlockBackend *target = NULL;
 
         if (dev_id != vmar->vmstate_stream) {
-            bs = rstate->bs;
-            if (!verify && !bs) {
+            target = rstate->target;
+            if (!verify && !target) {
                 error_setg(errp, "got wrong dev id %d", dev_id);
                 return -1;
             }
@@ -618,7 +618,7 @@ static int restore_extent(VmaReader *vmar, unsigned char *buf,
 
             if (!verify) {
                 int nb_sectors = end_sector - sector_num;
-                if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
+                if (restore_write_data(vmar, dev_id, target, vmstate_fd,
                                        buf + start, sector_num, nb_sectors,
                                        errp) < 0) {
                     return -1;
@@ -654,7 +654,7 @@ static int restore_extent(VmaReader *vmar, unsigned char *buf,
 
                     if (!verify) {
                         int nb_sectors = end_sector - sector_num;
-                        if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
+                        if (restore_write_data(vmar, dev_id, target, vmstate_fd,
                                                buf + start, sector_num,
                                                nb_sectors, errp) < 0) {
                             return -1;
@@ -678,7 +678,7 @@ static int restore_extent(VmaReader *vmar, unsigned char *buf,
                         }
 
                         if (rstate->write_zeroes && !verify) {
-                            if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
+                            if (restore_write_data(vmar, dev_id, target, vmstate_fd,
                                                    zero_vma_block, sector_num,
                                                    nb_sectors, errp) < 0) {
                                 return -1;
@@ -786,12 +786,12 @@ static int vma_reader_restore_full(VmaReader *vmar, int vmstate_fd,
     int i;
     for (i = 1; i < 256; i++) {
         VmaRestoreState *rstate = &vmar->rstate[i];
-        if (!rstate->bs) {
+        if (!rstate->target) {
             continue;
         }
 
-        if (bdrv_flush(rstate->bs) < 0) {
-            error_setg(errp, "vma bdrv_flush %s failed",
+        if (blk_flush(rstate->target) < 0) {
+            error_setg(errp, "vma blk_flush %s failed",
                        vmar->devinfo[i].devname);
             return -1;
         }
diff --git a/vma.c b/vma.c
index ad51090..aafdc2d 100644
--- a/vma.c
+++ b/vma.c
@@ -334,9 +334,7 @@ static int extract_content(int argc, char **argv)
                         error_get_pretty(errp));
             }
 
-	    BlockDriverState *bs = blk_bs(blk);
-
-            if (vma_reader_register_bs(vmar, i, bs, write_zero, &errp) < 0) {
+            if (vma_reader_register_bs(vmar, i, blk, write_zero, &errp) < 0) {
                 g_error("%s", error_get_pretty(errp));
             }
 
@@ -428,7 +426,7 @@ static int verify_content(int argc, char **argv)
 }
 
 typedef struct BackupJob {
-    BlockDriverState *bs;
+    BlockBackend *target;
     int64_t len;
     VmaWriter *vmaw;
     uint8_t dev_id;
@@ -457,7 +455,7 @@ static void coroutine_fn backup_run(void *opaque)
     int64_t start, end;
     int ret = 0;
 
-    unsigned char *buf = qemu_blockalign(job->bs, VMA_CLUSTER_SIZE);
+    unsigned char *buf = blk_blockalign(job->target, VMA_CLUSTER_SIZE);
 
     start = 0;
     end = DIV_ROUND_UP(job->len / BDRV_SECTOR_SIZE,
@@ -468,8 +466,8 @@ static void coroutine_fn backup_run(void *opaque)
         iov.iov_len = VMA_CLUSTER_SIZE;
         qemu_iovec_init_external(&qiov, &iov, 1);
 
-        ret = bdrv_co_readv(job->bs, start * BACKUP_SECTORS_PER_CLUSTER,
-                            BACKUP_SECTORS_PER_CLUSTER, &qiov);
+        ret = blk_co_preadv(job->target, start * BACKUP_SECTORS_PER_CLUSTER,
+                            BACKUP_SECTORS_PER_CLUSTER, &qiov, 0);
         if (ret < 0) {
             vma_writer_set_error(job->vmaw, "read error", -1);
             goto out;
@@ -564,14 +562,14 @@ static int create_archive(int argc, char **argv)
         path = extract_devname(path, &devname, devcount++);
 
         Error *errp = NULL;
-        BlockDriverState *bs;
+        BlockBackend *target;
 
-        bs = bdrv_open(path, NULL, NULL, 0, &errp);
-        if (!bs) {
+        target = blk_new_open(path, NULL, NULL, 0, &errp);
+        if (!target) {
             unlink(archivename);
             g_error("bdrv_open '%s' failed - %s", path, error_get_pretty(errp));
         }
-        int64_t size = bdrv_getlength(bs);
+        int64_t size = blk_getlength(target);
         int dev_id = vma_writer_register_stream(vmaw, devname, size);
         if (dev_id <= 0) {
             unlink(archivename);
@@ -580,7 +578,7 @@ static int create_archive(int argc, char **argv)
 
         BackupJob *job = g_new0(BackupJob, 1);
         job->len = size;
-        job->bs = bs;
+        job->target = target;
         job->vmaw = vmaw;
         job->dev_id = dev_id;
 
diff --git a/vma.h b/vma.h
index 365ceb2..fa6f4df 100644
--- a/vma.h
+++ b/vma.h
@@ -140,7 +140,7 @@ VmaHeader *vma_reader_get_header(VmaReader *vmar);
 GList *vma_reader_get_config_data(VmaReader *vmar);
 VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id);
 int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id,
-                           BlockDriverState *bs, bool write_zeroes,
+                           BlockBackend *target, bool write_zeroes,
                            Error **errp);
 int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
                        Error **errp);
-- 
2.1.4
Commit	Line	Data
87ba737b	1	From a004ee9295029201e8fc3b8fe4acf7f85674527c Mon Sep 17 00:00:00 2001
68a30562 WB	2	From: Wolfgang Bumiller <w.bumiller@proxmox.com>
68a30562 WB	3	Date: Fri, 9 Sep 2016 14:51:28 +0200
adeb0c7a	4	Subject: [PATCH 38/48] vma: byte based write calls
68a30562 WB	5
	6	---
	7	vma-reader.c \| 42 +++++++++++++++++++++---------------------
	8	vma.c \| 22 ++++++++++------------
	9	vma.h \| 2 +-
	10	3 files changed, 32 insertions(+), 34 deletions(-)
	11
	12	diff --git a/vma-reader.c b/vma-reader.c
	13	index 78f1de9..2000889 100644
	14	--- a/vma-reader.c
	15	+++ b/vma-reader.c
	16	@@ -25,7 +25,7 @@
	17	static unsigned char zero_vma_block[VMA_BLOCK_SIZE];
	18
	19	typedef struct VmaRestoreState {
	20	- BlockDriverState *bs;
	21	+ BlockBackend *target;
	22	bool write_zeroes;
	23	unsigned long *bitmap;
	24	int bitmap_size;
	25	@@ -423,12 +423,12 @@ VmaDeviceInfo vma_reader_get_device_info(VmaReader vmar, guint8 dev_id)
	26	}
	27
	28	static void allocate_rstate(VmaReader *vmar, guint8 dev_id,
	29	- BlockDriverState *bs, bool write_zeroes)
	30	+ BlockBackend *target, bool write_zeroes)
	31	{
	32	assert(vmar);
	33	assert(dev_id);
	34
	35	- vmar->rstate[dev_id].bs = bs;
	36	+ vmar->rstate[dev_id].target = target;
	37	vmar->rstate[dev_id].write_zeroes = write_zeroes;
	38
	39	int64_t size = vmar->devinfo[dev_id].size;
	40	@@ -443,15 +443,15 @@ static void allocate_rstate(VmaReader *vmar, guint8 dev_id,
	41	vmar->cluster_count += size/VMA_CLUSTER_SIZE;
	42	}
	43
	44	-int vma_reader_register_bs(VmaReader vmar, guint8 dev_id, BlockDriverState bs,
	45	+int vma_reader_register_bs(VmaReader vmar, guint8 dev_id, BlockBackend target,
	46	bool write_zeroes, Error **errp)
	47	{
	48	assert(vmar);
	49	- assert(bs != NULL);
	50	+ assert(target != NULL);
	51	assert(dev_id);
	52	- assert(vmar->rstate[dev_id].bs == NULL);
	53	+ assert(vmar->rstate[dev_id].target == NULL);
	54
	55	- int64_t size = bdrv_getlength(bs);
	56	+ int64_t size = blk_getlength(target);
	57	int64_t size_diff = size - vmar->devinfo[dev_id].size;
	58
	59	/* storage types can have different size restrictions, so it
	60	@@ -465,7 +465,7 @@ int vma_reader_register_bs(VmaReader vmar, guint8 dev_id, BlockDriverState bs,
	61	return -1;
	62	}
	63
	64	- allocate_rstate(vmar, dev_id, bs, write_zeroes);
	65	+ allocate_rstate(vmar, dev_id, target, write_zeroes);
	66
	67	return 0;
	68	}
69	@@ -507,7 +507,7 @@ static size_t full_write(int fd, void *buf, size_t len)
70	}
71
72	static int restore_write_data(VmaReader *vmar, guint8 dev_id,
73	- BlockDriverState *bs, int vmstate_fd,
74	+ BlockBackend *target, int vmstate_fd,
75	unsigned char *buf, int64_t sector_num,
76	int nb_sectors, Error **errp)
77	{
78	@@ -523,10 +523,10 @@ static int restore_write_data(VmaReader *vmar, guint8 dev_id,
79	}
80	}
81	} else {
82	- int res = bdrv_write(bs, sector_num, buf, nb_sectors);
83	+ int res = blk_pwrite(target, sector_num * BDRV_SECTOR_SIZE, buf, nb_sectors * BDRV_SECTOR_SIZE, 0);
84	if (res < 0) {
85	- error_setg(errp, "bdrv_write to %s failed (%d)",
86	- bdrv_get_device_name(bs), res);
87	+ error_setg(errp, "blk_pwrite to %s failed (%d)",
88	+ bdrv_get_device_name(blk_bs(target)), res);
89	return -1;
90	}
91	}
92	@@ -556,11 +556,11 @@ static int restore_extent(VmaReader vmar, unsigned char buf,
93	}
94
95	VmaRestoreState *rstate = &vmar->rstate[dev_id];
96	- BlockDriverState *bs = NULL;
97	+ BlockBackend *target = NULL;
98
99	if (dev_id != vmar->vmstate_stream) {
100	- bs = rstate->bs;
101	- if (!verify && !bs) {
102	+ target = rstate->target;
103	+ if (!verify && !target) {
104	error_setg(errp, "got wrong dev id %d", dev_id);
105	return -1;
106	}
107	@@ -618,7 +618,7 @@ static int restore_extent(VmaReader vmar, unsigned char buf,
108
109	if (!verify) {
110	int nb_sectors = end_sector - sector_num;
111	- if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
112	+ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
113	buf + start, sector_num, nb_sectors,
114	errp) < 0) {
115	return -1;
116	@@ -654,7 +654,7 @@ static int restore_extent(VmaReader vmar, unsigned char buf,
117
118	if (!verify) {
119	int nb_sectors = end_sector - sector_num;
120	- if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
121	+ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
122	buf + start, sector_num,
123	nb_sectors, errp) < 0) {
124	return -1;
125	@@ -678,7 +678,7 @@ static int restore_extent(VmaReader vmar, unsigned char buf,
126	}
127
128	if (rstate->write_zeroes && !verify) {
129	- if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
130	+ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
131	zero_vma_block, sector_num,
132	nb_sectors, errp) < 0) {
133	return -1;
134	@@ -786,12 +786,12 @@ static int vma_reader_restore_full(VmaReader *vmar, int vmstate_fd,
135	int i;
136	for (i = 1; i < 256; i++) {
137	VmaRestoreState *rstate = &vmar->rstate[i];
138	- if (!rstate->bs) {
139	+ if (!rstate->target) {
140	continue;
141	}
142
143	- if (bdrv_flush(rstate->bs) < 0) {
144	- error_setg(errp, "vma bdrv_flush %s failed",
145	+ if (blk_flush(rstate->target) < 0) {
146	+ error_setg(errp, "vma blk_flush %s failed",
147	vmar->devinfo[i].devname);
148	return -1;
149	}
150	diff --git a/vma.c b/vma.c
1a91ab45	151	index ad51090..aafdc2d 100644
68a30562 WB	152	--- a/vma.c
68a30562 WB	153	+++ b/vma.c
1a91ab45	154	@@ -334,9 +334,7 @@ static int extract_content(int argc, char **argv)
68a30562 WB	155	error_get_pretty(errp));
	156	}
	157
	158	- BlockDriverState *bs = blk_bs(blk);
	159	-
	160	- if (vma_reader_register_bs(vmar, i, bs, write_zero, &errp) < 0) {
	161	+ if (vma_reader_register_bs(vmar, i, blk, write_zero, &errp) < 0) {
	162	g_error("%s", error_get_pretty(errp));
	163	}
	164
1a91ab45	165	@@ -428,7 +426,7 @@ static int verify_content(int argc, char **argv)
68a30562 WB	166	}
	167
	168	typedef struct BackupJob {
	169	- BlockDriverState *bs;
	170	+ BlockBackend *target;
	171	int64_t len;
	172	VmaWriter *vmaw;
	173	uint8_t dev_id;
1a91ab45	174	@@ -457,7 +455,7 @@ static void coroutine_fn backup_run(void *opaque)
68a30562 WB	175	int64_t start, end;
	176	int ret = 0;
	177
	178	- unsigned char *buf = qemu_blockalign(job->bs, VMA_CLUSTER_SIZE);
	179	+ unsigned char *buf = blk_blockalign(job->target, VMA_CLUSTER_SIZE);
	180
	181	start = 0;
	182	end = DIV_ROUND_UP(job->len / BDRV_SECTOR_SIZE,
1a91ab45	183	@@ -468,8 +466,8 @@ static void coroutine_fn backup_run(void *opaque)
68a30562 WB	184	iov.iov_len = VMA_CLUSTER_SIZE;
	185	qemu_iovec_init_external(&qiov, &iov, 1);
	186
	187	- ret = bdrv_co_readv(job->bs, start * BACKUP_SECTORS_PER_CLUSTER,
	188	- BACKUP_SECTORS_PER_CLUSTER, &qiov);
	189	+ ret = blk_co_preadv(job->target, start * BACKUP_SECTORS_PER_CLUSTER,
	190	+ BACKUP_SECTORS_PER_CLUSTER, &qiov, 0);
	191	if (ret < 0) {
	192	vma_writer_set_error(job->vmaw, "read error", -1);
	193	goto out;
1a91ab45	194	@@ -564,14 +562,14 @@ static int create_archive(int argc, char **argv)
68a30562 WB	195	path = extract_devname(path, &devname, devcount++);
	196
	197	Error *errp = NULL;
	198	- BlockDriverState *bs;
	199	+ BlockBackend *target;
	200
	201	- bs = bdrv_open(path, NULL, NULL, 0, &errp);
	202	- if (!bs) {
	203	+ target = blk_new_open(path, NULL, NULL, 0, &errp);
	204	+ if (!target) {
	205	unlink(archivename);
	206	g_error("bdrv_open '%s' failed - %s", path, error_get_pretty(errp));
	207	}
	208	- int64_t size = bdrv_getlength(bs);
	209	+ int64_t size = blk_getlength(target);
	210	int dev_id = vma_writer_register_stream(vmaw, devname, size);
	211	if (dev_id <= 0) {
	212	unlink(archivename);
1a91ab45	213	@@ -580,7 +578,7 @@ static int create_archive(int argc, char **argv)
68a30562 WB	214
	215	BackupJob *job = g_new0(BackupJob, 1);
	216	job->len = size;
	217	- job->bs = bs;
	218	+ job->target = target;
	219	job->vmaw = vmaw;
	220	job->dev_id = dev_id;
	221
	222	diff --git a/vma.h b/vma.h
	223	index 365ceb2..fa6f4df 100644
	224	--- a/vma.h
	225	+++ b/vma.h
	226	@@ -140,7 +140,7 @@ VmaHeader vma_reader_get_header(VmaReader vmar);
	227	GList vma_reader_get_config_data(VmaReader vmar);
	228	VmaDeviceInfo vma_reader_get_device_info(VmaReader vmar, guint8 dev_id);
	229	int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id,
	230	- BlockDriverState *bs, bool write_zeroes,
	231	+ BlockBackend *target, bool write_zeroes,
	232	Error **errp);
	233	int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
	234	Error **errp);
	235	--
	236	2.1.4
	237