1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27
28#define ZLIB_CONST
29#include <zlib.h>
30
31#include "qcow2.h"
32#include "block/thread-pool.h"
33#include "crypto.h"
34
35static int coroutine_fn
36qcow2_co_process(BlockDriverState *bs, ThreadPoolFunc *func, void *arg)
37{
38 int ret;
39 BDRVQcow2State *s = bs->opaque;
40 ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
41
42 qemu_co_mutex_lock(&s->lock);
43 while (s->nb_threads >= QCOW2_MAX_THREADS) {
44 qemu_co_queue_wait(&s->thread_task_queue, &s->lock);
45 }
46 s->nb_threads++;
47 qemu_co_mutex_unlock(&s->lock);
48
49 ret = thread_pool_submit_co(pool, func, arg);
50
51 qemu_co_mutex_lock(&s->lock);
52 s->nb_threads--;
53 qemu_co_queue_next(&s->thread_task_queue);
54 qemu_co_mutex_unlock(&s->lock);
55
56 return ret;
57}
58
59
60
61
62
63
64typedef ssize_t (*Qcow2CompressFunc)(void *dest, size_t dest_size,
65 const void *src, size_t src_size);
66typedef struct Qcow2CompressData {
67 void *dest;
68 size_t dest_size;
69 const void *src;
70 size_t src_size;
71 ssize_t ret;
72
73 Qcow2CompressFunc func;
74} Qcow2CompressData;
75
76
77
78
79
80
81
82
83
84
85
86static ssize_t qcow2_compress(void *dest, size_t dest_size,
87 const void *src, size_t src_size)
88{
89 ssize_t ret;
90 z_stream strm;
91
92
93 memset(&strm, 0, sizeof(strm));
94 ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
95 -12, 9, Z_DEFAULT_STRATEGY);
96 if (ret != Z_OK) {
97 return -EIO;
98 }
99
100
101
102
103
104 strm.avail_in = src_size;
105 strm.next_in = (void *) src;
106 strm.avail_out = dest_size;
107 strm.next_out = dest;
108
109 ret = deflate(&strm, Z_FINISH);
110 if (ret == Z_STREAM_END) {
111 ret = dest_size - strm.avail_out;
112 } else {
113 ret = (ret == Z_OK ? -ENOMEM : -EIO);
114 }
115
116 deflateEnd(&strm);
117
118 return ret;
119}
120
121
122
123
124
125
126
127
128
129
130
131
132
133static ssize_t qcow2_decompress(void *dest, size_t dest_size,
134 const void *src, size_t src_size)
135{
136 int ret = 0;
137 z_stream strm;
138
139 memset(&strm, 0, sizeof(strm));
140 strm.avail_in = src_size;
141 strm.next_in = (void *) src;
142 strm.avail_out = dest_size;
143 strm.next_out = dest;
144
145 ret = inflateInit2(&strm, -12);
146 if (ret != Z_OK) {
147 return -1;
148 }
149
150 ret = inflate(&strm, Z_FINISH);
151 if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) || strm.avail_out != 0) {
152
153
154
155
156
157 ret = -1;
158 }
159
160 inflateEnd(&strm);
161
162 return ret;
163}
164
165static int qcow2_compress_pool_func(void *opaque)
166{
167 Qcow2CompressData *data = opaque;
168
169 data->ret = data->func(data->dest, data->dest_size,
170 data->src, data->src_size);
171
172 return 0;
173}
174
175static ssize_t coroutine_fn
176qcow2_co_do_compress(BlockDriverState *bs, void *dest, size_t dest_size,
177 const void *src, size_t src_size, Qcow2CompressFunc func)
178{
179 Qcow2CompressData arg = {
180 .dest = dest,
181 .dest_size = dest_size,
182 .src = src,
183 .src_size = src_size,
184 .func = func,
185 };
186
187 qcow2_co_process(bs, qcow2_compress_pool_func, &arg);
188
189 return arg.ret;
190}
191
192ssize_t coroutine_fn
193qcow2_co_compress(BlockDriverState *bs, void *dest, size_t dest_size,
194 const void *src, size_t src_size)
195{
196 return qcow2_co_do_compress(bs, dest, dest_size, src, src_size,
197 qcow2_compress);
198}
199
200ssize_t coroutine_fn
201qcow2_co_decompress(BlockDriverState *bs, void *dest, size_t dest_size,
202 const void *src, size_t src_size)
203{
204 return qcow2_co_do_compress(bs, dest, dest_size, src, src_size,
205 qcow2_decompress);
206}
207
208
209
210
211
212
213
214
215
216
217typedef int (*Qcow2EncDecFunc)(QCryptoBlock *block, uint64_t offset,
218 uint8_t *buf, size_t len, Error **errp);
219
220typedef struct Qcow2EncDecData {
221 QCryptoBlock *block;
222 uint64_t offset;
223 uint8_t *buf;
224 size_t len;
225
226 Qcow2EncDecFunc func;
227} Qcow2EncDecData;
228
229static int qcow2_encdec_pool_func(void *opaque)
230{
231 Qcow2EncDecData *data = opaque;
232
233 return data->func(data->block, data->offset, data->buf, data->len, NULL);
234}
235
236static int coroutine_fn
237qcow2_co_encdec(BlockDriverState *bs, uint64_t file_cluster_offset,
238 uint64_t offset, void *buf, size_t len, Qcow2EncDecFunc func)
239{
240 BDRVQcow2State *s = bs->opaque;
241 Qcow2EncDecData arg = {
242 .block = s->crypto,
243 .offset = s->crypt_physical_offset ?
244 file_cluster_offset + offset_into_cluster(s, offset) :
245 offset,
246 .buf = buf,
247 .len = len,
248 .func = func,
249 };
250
251 return qcow2_co_process(bs, qcow2_encdec_pool_func, &arg);
252}
253
254int coroutine_fn
255qcow2_co_encrypt(BlockDriverState *bs, uint64_t file_cluster_offset,
256 uint64_t offset, void *buf, size_t len)
257{
258 return qcow2_co_encdec(bs, file_cluster_offset, offset, buf, len,
259 qcrypto_block_encrypt);
260}
261
262int coroutine_fn
263qcow2_co_decrypt(BlockDriverState *bs, uint64_t file_cluster_offset,
264 uint64_t offset, void *buf, size_t len)
265{
266 return qcow2_co_encdec(bs, file_cluster_offset, offset, buf, len,
267 qcrypto_block_decrypt);
268}
269