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
27
28#include "qemu/osdep.h"
29#include "qemu-common.h"
30#include "qemu/error-report.h"
31#include "qemu/iov.h"
32#include "qemu/sockets.h"
33#include "qemu/coroutine.h"
34#include "migration/migration.h"
35#include "migration/qemu-file.h"
36#include "migration/qemu-file-internal.h"
37#include "trace.h"
38
39#define QSB_CHUNK_SIZE (1 << 10)
40#define QSB_MAX_CHUNK_SIZE (16 * QSB_CHUNK_SIZE)
41
42
43
44
45
46
47
48
49
50
51
52
53
54QEMUSizedBuffer *qsb_create(const uint8_t *buffer, size_t len)
55{
56 QEMUSizedBuffer *qsb;
57 size_t alloc_len, num_chunks, i, to_copy;
58 size_t chunk_size = (len > QSB_MAX_CHUNK_SIZE)
59 ? QSB_MAX_CHUNK_SIZE
60 : QSB_CHUNK_SIZE;
61
62 num_chunks = DIV_ROUND_UP(len ? len : QSB_CHUNK_SIZE, chunk_size);
63 alloc_len = num_chunks * chunk_size;
64
65 qsb = g_try_new0(QEMUSizedBuffer, 1);
66 if (!qsb) {
67 return NULL;
68 }
69
70 qsb->iov = g_try_new0(struct iovec, num_chunks);
71 if (!qsb->iov) {
72 g_free(qsb);
73 return NULL;
74 }
75
76 qsb->n_iov = num_chunks;
77
78 for (i = 0; i < num_chunks; i++) {
79 qsb->iov[i].iov_base = g_try_malloc0(chunk_size);
80 if (!qsb->iov[i].iov_base) {
81
82 qsb_free(qsb);
83 return NULL;
84 }
85
86 qsb->iov[i].iov_len = chunk_size;
87 if (buffer) {
88 to_copy = (len - qsb->used) > chunk_size
89 ? chunk_size : (len - qsb->used);
90 memcpy(qsb->iov[i].iov_base, &buffer[qsb->used], to_copy);
91 qsb->used += to_copy;
92 }
93 }
94
95 qsb->size = alloc_len;
96
97 return qsb;
98}
99
100
101
102
103
104
105void qsb_free(QEMUSizedBuffer *qsb)
106{
107 size_t i;
108
109 if (!qsb) {
110 return;
111 }
112
113 for (i = 0; i < qsb->n_iov; i++) {
114 g_free(qsb->iov[i].iov_base);
115 }
116 g_free(qsb->iov);
117 g_free(qsb);
118}
119
120
121
122
123
124
125
126
127size_t qsb_get_length(const QEMUSizedBuffer *qsb)
128{
129 return qsb->used;
130}
131
132
133
134
135
136
137
138
139
140
141
142
143
144size_t qsb_set_length(QEMUSizedBuffer *qsb, size_t new_len)
145{
146 if (new_len <= qsb->size) {
147 qsb->used = new_len;
148 } else {
149 qsb->used = qsb->size;
150 }
151 return qsb->used;
152}
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167static ssize_t qsb_get_iovec(const QEMUSizedBuffer *qsb,
168 off_t pos, off_t *d_off)
169{
170 ssize_t i;
171 off_t curr = 0;
172
173 if (pos > qsb->used) {
174 return -1;
175 }
176
177 for (i = 0; i < qsb->n_iov; i++) {
178 if (curr + qsb->iov[i].iov_len > pos) {
179 *d_off = pos - curr;
180 return i;
181 }
182 curr += qsb->iov[i].iov_len;
183 }
184 return -1;
185}
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200ssize_t qsb_get_buffer(const QEMUSizedBuffer *qsb, off_t start,
201 size_t count, uint8_t *buffer)
202{
203 const struct iovec *iov;
204 size_t to_copy, all_copy;
205 ssize_t index;
206 off_t s_off;
207 off_t d_off = 0;
208 char *s;
209
210 if (start > qsb->used) {
211 return 0;
212 }
213
214 all_copy = qsb->used - start;
215 if (all_copy > count) {
216 all_copy = count;
217 } else {
218 count = all_copy;
219 }
220
221 index = qsb_get_iovec(qsb, start, &s_off);
222 if (index < 0) {
223 return 0;
224 }
225
226 while (all_copy > 0) {
227 iov = &qsb->iov[index];
228
229 s = iov->iov_base;
230
231 to_copy = iov->iov_len - s_off;
232 if (to_copy > all_copy) {
233 to_copy = all_copy;
234 }
235 memcpy(&buffer[d_off], &s[s_off], to_copy);
236
237 d_off += to_copy;
238 all_copy -= to_copy;
239
240 s_off = 0;
241 index++;
242 }
243
244 return count;
245}
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260static ssize_t qsb_grow(QEMUSizedBuffer *qsb, size_t new_size)
261{
262 size_t needed_chunks, i;
263
264 if (qsb->size < new_size) {
265 struct iovec *new_iov;
266 size_t size_diff = new_size - qsb->size;
267 size_t chunk_size = (size_diff > QSB_MAX_CHUNK_SIZE)
268 ? QSB_MAX_CHUNK_SIZE : QSB_CHUNK_SIZE;
269
270 needed_chunks = DIV_ROUND_UP(size_diff, chunk_size);
271
272 new_iov = g_try_new(struct iovec, qsb->n_iov + needed_chunks);
273 if (new_iov == NULL) {
274 return -ENOMEM;
275 }
276
277
278 for (i = qsb->n_iov; i < qsb->n_iov + needed_chunks; i++) {
279 new_iov[i].iov_base = g_try_malloc0(chunk_size);
280 new_iov[i].iov_len = chunk_size;
281 if (!new_iov[i].iov_base) {
282 size_t j;
283
284
285 for (j = qsb->n_iov; j < i; j++) {
286 g_free(new_iov[j].iov_base);
287 }
288 g_free(new_iov);
289
290 return -ENOMEM;
291 }
292 }
293
294
295
296
297
298 for (i = 0; i < qsb->n_iov; i++) {
299 new_iov[i] = qsb->iov[i];
300 }
301
302 qsb->n_iov += needed_chunks;
303 g_free(qsb->iov);
304 qsb->iov = new_iov;
305 qsb->size += (needed_chunks * chunk_size);
306 }
307
308 return qsb->size;
309}
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324ssize_t qsb_write_at(QEMUSizedBuffer *qsb, const uint8_t *source,
325 off_t pos, size_t count)
326{
327 ssize_t rc = qsb_grow(qsb, pos + count);
328 size_t to_copy;
329 size_t all_copy = count;
330 const struct iovec *iov;
331 ssize_t index;
332 char *dest;
333 off_t d_off, s_off = 0;
334
335 if (rc < 0) {
336 return rc;
337 }
338
339 if (pos + count > qsb->used) {
340 qsb->used = pos + count;
341 }
342
343 index = qsb_get_iovec(qsb, pos, &d_off);
344 if (index < 0) {
345 return -EINVAL;
346 }
347
348 while (all_copy > 0) {
349 iov = &qsb->iov[index];
350
351 dest = iov->iov_base;
352
353 to_copy = iov->iov_len - d_off;
354 if (to_copy > all_copy) {
355 to_copy = all_copy;
356 }
357
358 memcpy(&dest[d_off], &source[s_off], to_copy);
359
360 s_off += to_copy;
361 all_copy -= to_copy;
362
363 d_off = 0;
364 index++;
365 }
366
367 return count;
368}
369
370typedef struct QEMUBuffer {
371 QEMUSizedBuffer *qsb;
372 QEMUFile *file;
373 bool qsb_allocated;
374} QEMUBuffer;
375
376static ssize_t buf_get_buffer(void *opaque, uint8_t *buf, int64_t pos,
377 size_t size)
378{
379 QEMUBuffer *s = opaque;
380 ssize_t len = qsb_get_length(s->qsb) - pos;
381
382 if (len <= 0) {
383 return 0;
384 }
385
386 if (len > size) {
387 len = size;
388 }
389 return qsb_get_buffer(s->qsb, pos, len, buf);
390}
391
392static ssize_t buf_put_buffer(void *opaque, const uint8_t *buf,
393 int64_t pos, size_t size)
394{
395 QEMUBuffer *s = opaque;
396
397 return qsb_write_at(s->qsb, buf, pos, size);
398}
399
400static int buf_close(void *opaque)
401{
402 QEMUBuffer *s = opaque;
403
404 if (s->qsb_allocated) {
405 qsb_free(s->qsb);
406 }
407
408 g_free(s);
409
410 return 0;
411}
412
413const QEMUSizedBuffer *qemu_buf_get(QEMUFile *f)
414{
415 QEMUBuffer *p;
416
417 qemu_fflush(f);
418
419 p = f->opaque;
420
421 return p->qsb;
422}
423
424static const QEMUFileOps buf_read_ops = {
425 .get_buffer = buf_get_buffer,
426 .close = buf_close,
427};
428
429static const QEMUFileOps buf_write_ops = {
430 .put_buffer = buf_put_buffer,
431 .close = buf_close,
432};
433
434QEMUFile *qemu_bufopen(const char *mode, QEMUSizedBuffer *input)
435{
436 QEMUBuffer *s;
437
438 if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') ||
439 mode[1] != '\0') {
440 error_report("qemu_bufopen: Argument validity check failed");
441 return NULL;
442 }
443
444 s = g_new0(QEMUBuffer, 1);
445 s->qsb = input;
446
447 if (s->qsb == NULL) {
448 s->qsb = qsb_create(NULL, 0);
449 s->qsb_allocated = true;
450 }
451 if (!s->qsb) {
452 g_free(s);
453 error_report("qemu_bufopen: qsb_create failed");
454 return NULL;
455 }
456
457
458 if (mode[0] == 'r') {
459 s->file = qemu_fopen_ops(s, &buf_read_ops);
460 } else {
461 s->file = qemu_fopen_ops(s, &buf_write_ops);
462 }
463 return s->file;
464}
465