PPC: e500mc: add missing IVORs to bitmap
[qemu.git] / block / qed.c
1 /*
2 * QEMU Enhanced Disk Format
3 *
4 * Copyright IBM, Corp. 2010
5 *
6 * Authors:
7 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
8 * Anthony Liguori <aliguori@us.ibm.com>
9 *
10 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
11 * See the COPYING.LIB file in the top-level directory.
12 *
13 */
14
15 #include "qemu-timer.h"
16 #include "trace.h"
17 #include "qed.h"
18 #include "qerror.h"
19 #include "migration.h"
20
21 static void qed_aio_cancel(BlockDriverAIOCB *blockacb)
22 {
23 QEDAIOCB *acb = (QEDAIOCB *)blockacb;
24 bool finished = false;
25
26 /* Wait for the request to finish */
27 acb->finished = &finished;
28 while (!finished) {
29 qemu_aio_wait();
30 }
31 }
32
33 static AIOPool qed_aio_pool = {
34 .aiocb_size = sizeof(QEDAIOCB),
35 .cancel = qed_aio_cancel,
36 };
37
38 static int bdrv_qed_probe(const uint8_t *buf, int buf_size,
39 const char *filename)
40 {
41 const QEDHeader *header = (const QEDHeader *)buf;
42
43 if (buf_size < sizeof(*header)) {
44 return 0;
45 }
46 if (le32_to_cpu(header->magic) != QED_MAGIC) {
47 return 0;
48 }
49 return 100;
50 }
51
52 /**
53 * Check whether an image format is raw
54 *
55 * @fmt: Backing file format, may be NULL
56 */
57 static bool qed_fmt_is_raw(const char *fmt)
58 {
59 return fmt && strcmp(fmt, "raw") == 0;
60 }
61
62 static void qed_header_le_to_cpu(const QEDHeader *le, QEDHeader *cpu)
63 {
64 cpu->magic = le32_to_cpu(le->magic);
65 cpu->cluster_size = le32_to_cpu(le->cluster_size);
66 cpu->table_size = le32_to_cpu(le->table_size);
67 cpu->header_size = le32_to_cpu(le->header_size);
68 cpu->features = le64_to_cpu(le->features);
69 cpu->compat_features = le64_to_cpu(le->compat_features);
70 cpu->autoclear_features = le64_to_cpu(le->autoclear_features);
71 cpu->l1_table_offset = le64_to_cpu(le->l1_table_offset);
72 cpu->image_size = le64_to_cpu(le->image_size);
73 cpu->backing_filename_offset = le32_to_cpu(le->backing_filename_offset);
74 cpu->backing_filename_size = le32_to_cpu(le->backing_filename_size);
75 }
76
77 static void qed_header_cpu_to_le(const QEDHeader *cpu, QEDHeader *le)
78 {
79 le->magic = cpu_to_le32(cpu->magic);
80 le->cluster_size = cpu_to_le32(cpu->cluster_size);
81 le->table_size = cpu_to_le32(cpu->table_size);
82 le->header_size = cpu_to_le32(cpu->header_size);
83 le->features = cpu_to_le64(cpu->features);
84 le->compat_features = cpu_to_le64(cpu->compat_features);
85 le->autoclear_features = cpu_to_le64(cpu->autoclear_features);
86 le->l1_table_offset = cpu_to_le64(cpu->l1_table_offset);
87 le->image_size = cpu_to_le64(cpu->image_size);
88 le->backing_filename_offset = cpu_to_le32(cpu->backing_filename_offset);
89 le->backing_filename_size = cpu_to_le32(cpu->backing_filename_size);
90 }
91
92 static int qed_write_header_sync(BDRVQEDState *s)
93 {
94 QEDHeader le;
95 int ret;
96
97 qed_header_cpu_to_le(&s->header, &le);
98 ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le));
99 if (ret != sizeof(le)) {
100 return ret;
101 }
102 return 0;
103 }
104
105 typedef struct {
106 GenericCB gencb;
107 BDRVQEDState *s;
108 struct iovec iov;
109 QEMUIOVector qiov;
110 int nsectors;
111 uint8_t *buf;
112 } QEDWriteHeaderCB;
113
114 static void qed_write_header_cb(void *opaque, int ret)
115 {
116 QEDWriteHeaderCB *write_header_cb = opaque;
117
118 qemu_vfree(write_header_cb->buf);
119 gencb_complete(write_header_cb, ret);
120 }
121
122 static void qed_write_header_read_cb(void *opaque, int ret)
123 {
124 QEDWriteHeaderCB *write_header_cb = opaque;
125 BDRVQEDState *s = write_header_cb->s;
126
127 if (ret) {
128 qed_write_header_cb(write_header_cb, ret);
129 return;
130 }
131
132 /* Update header */
133 qed_header_cpu_to_le(&s->header, (QEDHeader *)write_header_cb->buf);
134
135 bdrv_aio_writev(s->bs->file, 0, &write_header_cb->qiov,
136 write_header_cb->nsectors, qed_write_header_cb,
137 write_header_cb);
138 }
139
140 /**
141 * Update header in-place (does not rewrite backing filename or other strings)
142 *
143 * This function only updates known header fields in-place and does not affect
144 * extra data after the QED header.
145 */
146 static void qed_write_header(BDRVQEDState *s, BlockDriverCompletionFunc cb,
147 void *opaque)
148 {
149 /* We must write full sectors for O_DIRECT but cannot necessarily generate
150 * the data following the header if an unrecognized compat feature is
151 * active. Therefore, first read the sectors containing the header, update
152 * them, and write back.
153 */
154
155 int nsectors = (sizeof(QEDHeader) + BDRV_SECTOR_SIZE - 1) /
156 BDRV_SECTOR_SIZE;
157 size_t len = nsectors * BDRV_SECTOR_SIZE;
158 QEDWriteHeaderCB *write_header_cb = gencb_alloc(sizeof(*write_header_cb),
159 cb, opaque);
160
161 write_header_cb->s = s;
162 write_header_cb->nsectors = nsectors;
163 write_header_cb->buf = qemu_blockalign(s->bs, len);
164 write_header_cb->iov.iov_base = write_header_cb->buf;
165 write_header_cb->iov.iov_len = len;
166 qemu_iovec_init_external(&write_header_cb->qiov, &write_header_cb->iov, 1);
167
168 bdrv_aio_readv(s->bs->file, 0, &write_header_cb->qiov, nsectors,
169 qed_write_header_read_cb, write_header_cb);
170 }
171
172 static uint64_t qed_max_image_size(uint32_t cluster_size, uint32_t table_size)
173 {
174 uint64_t table_entries;
175 uint64_t l2_size;
176
177 table_entries = (table_size * cluster_size) / sizeof(uint64_t);
178 l2_size = table_entries * cluster_size;
179
180 return l2_size * table_entries;
181 }
182
183 static bool qed_is_cluster_size_valid(uint32_t cluster_size)
184 {
185 if (cluster_size < QED_MIN_CLUSTER_SIZE ||
186 cluster_size > QED_MAX_CLUSTER_SIZE) {
187 return false;
188 }
189 if (cluster_size & (cluster_size - 1)) {
190 return false; /* not power of 2 */
191 }
192 return true;
193 }
194
195 static bool qed_is_table_size_valid(uint32_t table_size)
196 {
197 if (table_size < QED_MIN_TABLE_SIZE ||
198 table_size > QED_MAX_TABLE_SIZE) {
199 return false;
200 }
201 if (table_size & (table_size - 1)) {
202 return false; /* not power of 2 */
203 }
204 return true;
205 }
206
207 static bool qed_is_image_size_valid(uint64_t image_size, uint32_t cluster_size,
208 uint32_t table_size)
209 {
210 if (image_size % BDRV_SECTOR_SIZE != 0) {
211 return false; /* not multiple of sector size */
212 }
213 if (image_size > qed_max_image_size(cluster_size, table_size)) {
214 return false; /* image is too large */
215 }
216 return true;
217 }
218
219 /**
220 * Read a string of known length from the image file
221 *
222 * @file: Image file
223 * @offset: File offset to start of string, in bytes
224 * @n: String length in bytes
225 * @buf: Destination buffer
226 * @buflen: Destination buffer length in bytes
227 * @ret: 0 on success, -errno on failure
228 *
229 * The string is NUL-terminated.
230 */
231 static int qed_read_string(BlockDriverState *file, uint64_t offset, size_t n,
232 char *buf, size_t buflen)
233 {
234 int ret;
235 if (n >= buflen) {
236 return -EINVAL;
237 }
238 ret = bdrv_pread(file, offset, buf, n);
239 if (ret < 0) {
240 return ret;
241 }
242 buf[n] = '\0';
243 return 0;
244 }
245
246 /**
247 * Allocate new clusters
248 *
249 * @s: QED state
250 * @n: Number of contiguous clusters to allocate
251 * @ret: Offset of first allocated cluster
252 *
253 * This function only produces the offset where the new clusters should be
254 * written. It updates BDRVQEDState but does not make any changes to the image
255 * file.
256 */
257 static uint64_t qed_alloc_clusters(BDRVQEDState *s, unsigned int n)
258 {
259 uint64_t offset = s->file_size;
260 s->file_size += n * s->header.cluster_size;
261 return offset;
262 }
263
264 QEDTable *qed_alloc_table(BDRVQEDState *s)
265 {
266 /* Honor O_DIRECT memory alignment requirements */
267 return qemu_blockalign(s->bs,
268 s->header.cluster_size * s->header.table_size);
269 }
270
271 /**
272 * Allocate a new zeroed L2 table
273 */
274 static CachedL2Table *qed_new_l2_table(BDRVQEDState *s)
275 {
276 CachedL2Table *l2_table = qed_alloc_l2_cache_entry(&s->l2_cache);
277
278 l2_table->table = qed_alloc_table(s);
279 l2_table->offset = qed_alloc_clusters(s, s->header.table_size);
280
281 memset(l2_table->table->offsets, 0,
282 s->header.cluster_size * s->header.table_size);
283 return l2_table;
284 }
285
286 static void qed_aio_next_io(void *opaque, int ret);
287
288 static void qed_plug_allocating_write_reqs(BDRVQEDState *s)
289 {
290 assert(!s->allocating_write_reqs_plugged);
291
292 s->allocating_write_reqs_plugged = true;
293 }
294
295 static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)
296 {
297 QEDAIOCB *acb;
298
299 assert(s->allocating_write_reqs_plugged);
300
301 s->allocating_write_reqs_plugged = false;
302
303 acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);
304 if (acb) {
305 qed_aio_next_io(acb, 0);
306 }
307 }
308
309 static void qed_finish_clear_need_check(void *opaque, int ret)
310 {
311 /* Do nothing */
312 }
313
314 static void qed_flush_after_clear_need_check(void *opaque, int ret)
315 {
316 BDRVQEDState *s = opaque;
317
318 bdrv_aio_flush(s->bs, qed_finish_clear_need_check, s);
319
320 /* No need to wait until flush completes */
321 qed_unplug_allocating_write_reqs(s);
322 }
323
324 static void qed_clear_need_check(void *opaque, int ret)
325 {
326 BDRVQEDState *s = opaque;
327
328 if (ret) {
329 qed_unplug_allocating_write_reqs(s);
330 return;
331 }
332
333 s->header.features &= ~QED_F_NEED_CHECK;
334 qed_write_header(s, qed_flush_after_clear_need_check, s);
335 }
336
337 static void qed_need_check_timer_cb(void *opaque)
338 {
339 BDRVQEDState *s = opaque;
340
341 /* The timer should only fire when allocating writes have drained */
342 assert(!QSIMPLEQ_FIRST(&s->allocating_write_reqs));
343
344 trace_qed_need_check_timer_cb(s);
345
346 qed_plug_allocating_write_reqs(s);
347
348 /* Ensure writes are on disk before clearing flag */
349 bdrv_aio_flush(s->bs, qed_clear_need_check, s);
350 }
351
352 static void qed_start_need_check_timer(BDRVQEDState *s)
353 {
354 trace_qed_start_need_check_timer(s);
355
356 /* Use vm_clock so we don't alter the image file while suspended for
357 * migration.
358 */
359 qemu_mod_timer(s->need_check_timer, qemu_get_clock_ns(vm_clock) +
360 get_ticks_per_sec() * QED_NEED_CHECK_TIMEOUT);
361 }
362
363 /* It's okay to call this multiple times or when no timer is started */
364 static void qed_cancel_need_check_timer(BDRVQEDState *s)
365 {
366 trace_qed_cancel_need_check_timer(s);
367 qemu_del_timer(s->need_check_timer);
368 }
369
370 static int bdrv_qed_open(BlockDriverState *bs, int flags)
371 {
372 BDRVQEDState *s = bs->opaque;
373 QEDHeader le_header;
374 int64_t file_size;
375 int ret;
376
377 s->bs = bs;
378 QSIMPLEQ_INIT(&s->allocating_write_reqs);
379
380 ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header));
381 if (ret < 0) {
382 return ret;
383 }
384 qed_header_le_to_cpu(&le_header, &s->header);
385
386 if (s->header.magic != QED_MAGIC) {
387 return -EINVAL;
388 }
389 if (s->header.features & ~QED_FEATURE_MASK) {
390 /* image uses unsupported feature bits */
391 char buf[64];
392 snprintf(buf, sizeof(buf), "%" PRIx64,
393 s->header.features & ~QED_FEATURE_MASK);
394 qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
395 bs->device_name, "QED", buf);
396 return -ENOTSUP;
397 }
398 if (!qed_is_cluster_size_valid(s->header.cluster_size)) {
399 return -EINVAL;
400 }
401
402 /* Round down file size to the last cluster */
403 file_size = bdrv_getlength(bs->file);
404 if (file_size < 0) {
405 return file_size;
406 }
407 s->file_size = qed_start_of_cluster(s, file_size);
408
409 if (!qed_is_table_size_valid(s->header.table_size)) {
410 return -EINVAL;
411 }
412 if (!qed_is_image_size_valid(s->header.image_size,
413 s->header.cluster_size,
414 s->header.table_size)) {
415 return -EINVAL;
416 }
417 if (!qed_check_table_offset(s, s->header.l1_table_offset)) {
418 return -EINVAL;
419 }
420
421 s->table_nelems = (s->header.cluster_size * s->header.table_size) /
422 sizeof(uint64_t);
423 s->l2_shift = ffs(s->header.cluster_size) - 1;
424 s->l2_mask = s->table_nelems - 1;
425 s->l1_shift = s->l2_shift + ffs(s->table_nelems) - 1;
426
427 if ((s->header.features & QED_F_BACKING_FILE)) {
428 if ((uint64_t)s->header.backing_filename_offset +
429 s->header.backing_filename_size >
430 s->header.cluster_size * s->header.header_size) {
431 return -EINVAL;
432 }
433
434 ret = qed_read_string(bs->file, s->header.backing_filename_offset,
435 s->header.backing_filename_size, bs->backing_file,
436 sizeof(bs->backing_file));
437 if (ret < 0) {
438 return ret;
439 }
440
441 if (s->header.features & QED_F_BACKING_FORMAT_NO_PROBE) {
442 pstrcpy(bs->backing_format, sizeof(bs->backing_format), "raw");
443 }
444 }
445
446 /* Reset unknown autoclear feature bits. This is a backwards
447 * compatibility mechanism that allows images to be opened by older
448 * programs, which "knock out" unknown feature bits. When an image is
449 * opened by a newer program again it can detect that the autoclear
450 * feature is no longer valid.
451 */
452 if ((s->header.autoclear_features & ~QED_AUTOCLEAR_FEATURE_MASK) != 0 &&
453 !bdrv_is_read_only(bs->file)) {
454 s->header.autoclear_features &= QED_AUTOCLEAR_FEATURE_MASK;
455
456 ret = qed_write_header_sync(s);
457 if (ret) {
458 return ret;
459 }
460
461 /* From here on only known autoclear feature bits are valid */
462 bdrv_flush(bs->file);
463 }
464
465 s->l1_table = qed_alloc_table(s);
466 qed_init_l2_cache(&s->l2_cache);
467
468 ret = qed_read_l1_table_sync(s);
469 if (ret) {
470 goto out;
471 }
472
473 /* If image was not closed cleanly, check consistency */
474 if (s->header.features & QED_F_NEED_CHECK) {
475 /* Read-only images cannot be fixed. There is no risk of corruption
476 * since write operations are not possible. Therefore, allow
477 * potentially inconsistent images to be opened read-only. This can
478 * aid data recovery from an otherwise inconsistent image.
479 */
480 if (!bdrv_is_read_only(bs->file)) {
481 BdrvCheckResult result = {0};
482
483 ret = qed_check(s, &result, true);
484 if (ret) {
485 goto out;
486 }
487 if (!result.corruptions && !result.check_errors) {
488 /* Ensure fixes reach storage before clearing check bit */
489 bdrv_flush(s->bs);
490
491 s->header.features &= ~QED_F_NEED_CHECK;
492 qed_write_header_sync(s);
493 }
494 }
495 }
496
497 s->need_check_timer = qemu_new_timer_ns(vm_clock,
498 qed_need_check_timer_cb, s);
499
500 error_set(&s->migration_blocker,
501 QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
502 "qed", bs->device_name, "live migration");
503 migrate_add_blocker(s->migration_blocker);
504
505
506 out:
507 if (ret) {
508 qed_free_l2_cache(&s->l2_cache);
509 qemu_vfree(s->l1_table);
510 }
511 return ret;
512 }
513
514 static void bdrv_qed_close(BlockDriverState *bs)
515 {
516 BDRVQEDState *s = bs->opaque;
517
518 migrate_del_blocker(s->migration_blocker);
519 error_free(s->migration_blocker);
520
521 qed_cancel_need_check_timer(s);
522 qemu_free_timer(s->need_check_timer);
523
524 /* Ensure writes reach stable storage */
525 bdrv_flush(bs->file);
526
527 /* Clean shutdown, no check required on next open */
528 if (s->header.features & QED_F_NEED_CHECK) {
529 s->header.features &= ~QED_F_NEED_CHECK;
530 qed_write_header_sync(s);
531 }
532
533 qed_free_l2_cache(&s->l2_cache);
534 qemu_vfree(s->l1_table);
535 }
536
537 static int qed_create(const char *filename, uint32_t cluster_size,
538 uint64_t image_size, uint32_t table_size,
539 const char *backing_file, const char *backing_fmt)
540 {
541 QEDHeader header = {
542 .magic = QED_MAGIC,
543 .cluster_size = cluster_size,
544 .table_size = table_size,
545 .header_size = 1,
546 .features = 0,
547 .compat_features = 0,
548 .l1_table_offset = cluster_size,
549 .image_size = image_size,
550 };
551 QEDHeader le_header;
552 uint8_t *l1_table = NULL;
553 size_t l1_size = header.cluster_size * header.table_size;
554 int ret = 0;
555 BlockDriverState *bs = NULL;
556
557 ret = bdrv_create_file(filename, NULL);
558 if (ret < 0) {
559 return ret;
560 }
561
562 ret = bdrv_file_open(&bs, filename, BDRV_O_RDWR | BDRV_O_CACHE_WB);
563 if (ret < 0) {
564 return ret;
565 }
566
567 /* File must start empty and grow, check truncate is supported */
568 ret = bdrv_truncate(bs, 0);
569 if (ret < 0) {
570 goto out;
571 }
572
573 if (backing_file) {
574 header.features |= QED_F_BACKING_FILE;
575 header.backing_filename_offset = sizeof(le_header);
576 header.backing_filename_size = strlen(backing_file);
577
578 if (qed_fmt_is_raw(backing_fmt)) {
579 header.features |= QED_F_BACKING_FORMAT_NO_PROBE;
580 }
581 }
582
583 qed_header_cpu_to_le(&header, &le_header);
584 ret = bdrv_pwrite(bs, 0, &le_header, sizeof(le_header));
585 if (ret < 0) {
586 goto out;
587 }
588 ret = bdrv_pwrite(bs, sizeof(le_header), backing_file,
589 header.backing_filename_size);
590 if (ret < 0) {
591 goto out;
592 }
593
594 l1_table = g_malloc0(l1_size);
595 ret = bdrv_pwrite(bs, header.l1_table_offset, l1_table, l1_size);
596 if (ret < 0) {
597 goto out;
598 }
599
600 ret = 0; /* success */
601 out:
602 g_free(l1_table);
603 bdrv_delete(bs);
604 return ret;
605 }
606
607 static int bdrv_qed_create(const char *filename, QEMUOptionParameter *options)
608 {
609 uint64_t image_size = 0;
610 uint32_t cluster_size = QED_DEFAULT_CLUSTER_SIZE;
611 uint32_t table_size = QED_DEFAULT_TABLE_SIZE;
612 const char *backing_file = NULL;
613 const char *backing_fmt = NULL;
614
615 while (options && options->name) {
616 if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
617 image_size = options->value.n;
618 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
619 backing_file = options->value.s;
620 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) {
621 backing_fmt = options->value.s;
622 } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) {
623 if (options->value.n) {
624 cluster_size = options->value.n;
625 }
626 } else if (!strcmp(options->name, BLOCK_OPT_TABLE_SIZE)) {
627 if (options->value.n) {
628 table_size = options->value.n;
629 }
630 }
631 options++;
632 }
633
634 if (!qed_is_cluster_size_valid(cluster_size)) {
635 fprintf(stderr, "QED cluster size must be within range [%u, %u] and power of 2\n",
636 QED_MIN_CLUSTER_SIZE, QED_MAX_CLUSTER_SIZE);
637 return -EINVAL;
638 }
639 if (!qed_is_table_size_valid(table_size)) {
640 fprintf(stderr, "QED table size must be within range [%u, %u] and power of 2\n",
641 QED_MIN_TABLE_SIZE, QED_MAX_TABLE_SIZE);
642 return -EINVAL;
643 }
644 if (!qed_is_image_size_valid(image_size, cluster_size, table_size)) {
645 fprintf(stderr, "QED image size must be a non-zero multiple of "
646 "cluster size and less than %" PRIu64 " bytes\n",
647 qed_max_image_size(cluster_size, table_size));
648 return -EINVAL;
649 }
650
651 return qed_create(filename, cluster_size, image_size, table_size,
652 backing_file, backing_fmt);
653 }
654
655 typedef struct {
656 Coroutine *co;
657 int is_allocated;
658 int *pnum;
659 } QEDIsAllocatedCB;
660
661 static void qed_is_allocated_cb(void *opaque, int ret, uint64_t offset, size_t len)
662 {
663 QEDIsAllocatedCB *cb = opaque;
664 *cb->pnum = len / BDRV_SECTOR_SIZE;
665 cb->is_allocated = (ret == QED_CLUSTER_FOUND || ret == QED_CLUSTER_ZERO);
666 if (cb->co) {
667 qemu_coroutine_enter(cb->co, NULL);
668 }
669 }
670
671 static int coroutine_fn bdrv_qed_co_is_allocated(BlockDriverState *bs,
672 int64_t sector_num,
673 int nb_sectors, int *pnum)
674 {
675 BDRVQEDState *s = bs->opaque;
676 uint64_t pos = (uint64_t)sector_num * BDRV_SECTOR_SIZE;
677 size_t len = (size_t)nb_sectors * BDRV_SECTOR_SIZE;
678 QEDIsAllocatedCB cb = {
679 .is_allocated = -1,
680 .pnum = pnum,
681 };
682 QEDRequest request = { .l2_table = NULL };
683
684 qed_find_cluster(s, &request, pos, len, qed_is_allocated_cb, &cb);
685
686 /* Now sleep if the callback wasn't invoked immediately */
687 while (cb.is_allocated == -1) {
688 cb.co = qemu_coroutine_self();
689 qemu_coroutine_yield();
690 }
691
692 qed_unref_l2_cache_entry(request.l2_table);
693
694 return cb.is_allocated;
695 }
696
697 static int bdrv_qed_make_empty(BlockDriverState *bs)
698 {
699 return -ENOTSUP;
700 }
701
702 static BDRVQEDState *acb_to_s(QEDAIOCB *acb)
703 {
704 return acb->common.bs->opaque;
705 }
706
707 /**
708 * Read from the backing file or zero-fill if no backing file
709 *
710 * @s: QED state
711 * @pos: Byte position in device
712 * @qiov: Destination I/O vector
713 * @cb: Completion function
714 * @opaque: User data for completion function
715 *
716 * This function reads qiov->size bytes starting at pos from the backing file.
717 * If there is no backing file then zeroes are read.
718 */
719 static void qed_read_backing_file(BDRVQEDState *s, uint64_t pos,
720 QEMUIOVector *qiov,
721 BlockDriverCompletionFunc *cb, void *opaque)
722 {
723 uint64_t backing_length = 0;
724 size_t size;
725
726 /* If there is a backing file, get its length. Treat the absence of a
727 * backing file like a zero length backing file.
728 */
729 if (s->bs->backing_hd) {
730 int64_t l = bdrv_getlength(s->bs->backing_hd);
731 if (l < 0) {
732 cb(opaque, l);
733 return;
734 }
735 backing_length = l;
736 }
737
738 /* Zero all sectors if reading beyond the end of the backing file */
739 if (pos >= backing_length ||
740 pos + qiov->size > backing_length) {
741 qemu_iovec_memset(qiov, 0, qiov->size);
742 }
743
744 /* Complete now if there are no backing file sectors to read */
745 if (pos >= backing_length) {
746 cb(opaque, 0);
747 return;
748 }
749
750 /* If the read straddles the end of the backing file, shorten it */
751 size = MIN((uint64_t)backing_length - pos, qiov->size);
752
753 BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING);
754 bdrv_aio_readv(s->bs->backing_hd, pos / BDRV_SECTOR_SIZE,
755 qiov, size / BDRV_SECTOR_SIZE, cb, opaque);
756 }
757
758 typedef struct {
759 GenericCB gencb;
760 BDRVQEDState *s;
761 QEMUIOVector qiov;
762 struct iovec iov;
763 uint64_t offset;
764 } CopyFromBackingFileCB;
765
766 static void qed_copy_from_backing_file_cb(void *opaque, int ret)
767 {
768 CopyFromBackingFileCB *copy_cb = opaque;
769 qemu_vfree(copy_cb->iov.iov_base);
770 gencb_complete(&copy_cb->gencb, ret);
771 }
772
773 static void qed_copy_from_backing_file_write(void *opaque, int ret)
774 {
775 CopyFromBackingFileCB *copy_cb = opaque;
776 BDRVQEDState *s = copy_cb->s;
777
778 if (ret) {
779 qed_copy_from_backing_file_cb(copy_cb, ret);
780 return;
781 }
782
783 BLKDBG_EVENT(s->bs->file, BLKDBG_COW_WRITE);
784 bdrv_aio_writev(s->bs->file, copy_cb->offset / BDRV_SECTOR_SIZE,
785 &copy_cb->qiov, copy_cb->qiov.size / BDRV_SECTOR_SIZE,
786 qed_copy_from_backing_file_cb, copy_cb);
787 }
788
789 /**
790 * Copy data from backing file into the image
791 *
792 * @s: QED state
793 * @pos: Byte position in device
794 * @len: Number of bytes
795 * @offset: Byte offset in image file
796 * @cb: Completion function
797 * @opaque: User data for completion function
798 */
799 static void qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos,
800 uint64_t len, uint64_t offset,
801 BlockDriverCompletionFunc *cb,
802 void *opaque)
803 {
804 CopyFromBackingFileCB *copy_cb;
805
806 /* Skip copy entirely if there is no work to do */
807 if (len == 0) {
808 cb(opaque, 0);
809 return;
810 }
811
812 copy_cb = gencb_alloc(sizeof(*copy_cb), cb, opaque);
813 copy_cb->s = s;
814 copy_cb->offset = offset;
815 copy_cb->iov.iov_base = qemu_blockalign(s->bs, len);
816 copy_cb->iov.iov_len = len;
817 qemu_iovec_init_external(&copy_cb->qiov, &copy_cb->iov, 1);
818
819 qed_read_backing_file(s, pos, &copy_cb->qiov,
820 qed_copy_from_backing_file_write, copy_cb);
821 }
822
823 /**
824 * Link one or more contiguous clusters into a table
825 *
826 * @s: QED state
827 * @table: L2 table
828 * @index: First cluster index
829 * @n: Number of contiguous clusters
830 * @cluster: First cluster offset
831 *
832 * The cluster offset may be an allocated byte offset in the image file, the
833 * zero cluster marker, or the unallocated cluster marker.
834 */
835 static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index,
836 unsigned int n, uint64_t cluster)
837 {
838 int i;
839 for (i = index; i < index + n; i++) {
840 table->offsets[i] = cluster;
841 if (!qed_offset_is_unalloc_cluster(cluster) &&
842 !qed_offset_is_zero_cluster(cluster)) {
843 cluster += s->header.cluster_size;
844 }
845 }
846 }
847
848 static void qed_aio_complete_bh(void *opaque)
849 {
850 QEDAIOCB *acb = opaque;
851 BlockDriverCompletionFunc *cb = acb->common.cb;
852 void *user_opaque = acb->common.opaque;
853 int ret = acb->bh_ret;
854 bool *finished = acb->finished;
855
856 qemu_bh_delete(acb->bh);
857 qemu_aio_release(acb);
858
859 /* Invoke callback */
860 cb(user_opaque, ret);
861
862 /* Signal cancel completion */
863 if (finished) {
864 *finished = true;
865 }
866 }
867
868 static void qed_aio_complete(QEDAIOCB *acb, int ret)
869 {
870 BDRVQEDState *s = acb_to_s(acb);
871
872 trace_qed_aio_complete(s, acb, ret);
873
874 /* Free resources */
875 qemu_iovec_destroy(&acb->cur_qiov);
876 qed_unref_l2_cache_entry(acb->request.l2_table);
877
878 /* Arrange for a bh to invoke the completion function */
879 acb->bh_ret = ret;
880 acb->bh = qemu_bh_new(qed_aio_complete_bh, acb);
881 qemu_bh_schedule(acb->bh);
882
883 /* Start next allocating write request waiting behind this one. Note that
884 * requests enqueue themselves when they first hit an unallocated cluster
885 * but they wait until the entire request is finished before waking up the
886 * next request in the queue. This ensures that we don't cycle through
887 * requests multiple times but rather finish one at a time completely.
888 */
889 if (acb == QSIMPLEQ_FIRST(&s->allocating_write_reqs)) {
890 QSIMPLEQ_REMOVE_HEAD(&s->allocating_write_reqs, next);
891 acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);
892 if (acb) {
893 qed_aio_next_io(acb, 0);
894 } else if (s->header.features & QED_F_NEED_CHECK) {
895 qed_start_need_check_timer(s);
896 }
897 }
898 }
899
900 /**
901 * Commit the current L2 table to the cache
902 */
903 static void qed_commit_l2_update(void *opaque, int ret)
904 {
905 QEDAIOCB *acb = opaque;
906 BDRVQEDState *s = acb_to_s(acb);
907 CachedL2Table *l2_table = acb->request.l2_table;
908 uint64_t l2_offset = l2_table->offset;
909
910 qed_commit_l2_cache_entry(&s->l2_cache, l2_table);
911
912 /* This is guaranteed to succeed because we just committed the entry to the
913 * cache.
914 */
915 acb->request.l2_table = qed_find_l2_cache_entry(&s->l2_cache, l2_offset);
916 assert(acb->request.l2_table != NULL);
917
918 qed_aio_next_io(opaque, ret);
919 }
920
921 /**
922 * Update L1 table with new L2 table offset and write it out
923 */
924 static void qed_aio_write_l1_update(void *opaque, int ret)
925 {
926 QEDAIOCB *acb = opaque;
927 BDRVQEDState *s = acb_to_s(acb);
928 int index;
929
930 if (ret) {
931 qed_aio_complete(acb, ret);
932 return;
933 }
934
935 index = qed_l1_index(s, acb->cur_pos);
936 s->l1_table->offsets[index] = acb->request.l2_table->offset;
937
938 qed_write_l1_table(s, index, 1, qed_commit_l2_update, acb);
939 }
940
941 /**
942 * Update L2 table with new cluster offsets and write them out
943 */
944 static void qed_aio_write_l2_update(void *opaque, int ret)
945 {
946 QEDAIOCB *acb = opaque;
947 BDRVQEDState *s = acb_to_s(acb);
948 bool need_alloc = acb->find_cluster_ret == QED_CLUSTER_L1;
949 int index;
950
951 if (ret) {
952 goto err;
953 }
954
955 if (need_alloc) {
956 qed_unref_l2_cache_entry(acb->request.l2_table);
957 acb->request.l2_table = qed_new_l2_table(s);
958 }
959
960 index = qed_l2_index(s, acb->cur_pos);
961 qed_update_l2_table(s, acb->request.l2_table->table, index, acb->cur_nclusters,
962 acb->cur_cluster);
963
964 if (need_alloc) {
965 /* Write out the whole new L2 table */
966 qed_write_l2_table(s, &acb->request, 0, s->table_nelems, true,
967 qed_aio_write_l1_update, acb);
968 } else {
969 /* Write out only the updated part of the L2 table */
970 qed_write_l2_table(s, &acb->request, index, acb->cur_nclusters, false,
971 qed_aio_next_io, acb);
972 }
973 return;
974
975 err:
976 qed_aio_complete(acb, ret);
977 }
978
979 /**
980 * Flush new data clusters before updating the L2 table
981 *
982 * This flush is necessary when a backing file is in use. A crash during an
983 * allocating write could result in empty clusters in the image. If the write
984 * only touched a subregion of the cluster, then backing image sectors have
985 * been lost in the untouched region. The solution is to flush after writing a
986 * new data cluster and before updating the L2 table.
987 */
988 static void qed_aio_write_flush_before_l2_update(void *opaque, int ret)
989 {
990 QEDAIOCB *acb = opaque;
991 BDRVQEDState *s = acb_to_s(acb);
992
993 if (!bdrv_aio_flush(s->bs->file, qed_aio_write_l2_update, opaque)) {
994 qed_aio_complete(acb, -EIO);
995 }
996 }
997
998 /**
999 * Write data to the image file
1000 */
1001 static void qed_aio_write_main(void *opaque, int ret)
1002 {
1003 QEDAIOCB *acb = opaque;
1004 BDRVQEDState *s = acb_to_s(acb);
1005 uint64_t offset = acb->cur_cluster +
1006 qed_offset_into_cluster(s, acb->cur_pos);
1007 BlockDriverCompletionFunc *next_fn;
1008
1009 trace_qed_aio_write_main(s, acb, ret, offset, acb->cur_qiov.size);
1010
1011 if (ret) {
1012 qed_aio_complete(acb, ret);
1013 return;
1014 }
1015
1016 if (acb->find_cluster_ret == QED_CLUSTER_FOUND) {
1017 next_fn = qed_aio_next_io;
1018 } else {
1019 if (s->bs->backing_hd) {
1020 next_fn = qed_aio_write_flush_before_l2_update;
1021 } else {
1022 next_fn = qed_aio_write_l2_update;
1023 }
1024 }
1025
1026 BLKDBG_EVENT(s->bs->file, BLKDBG_WRITE_AIO);
1027 bdrv_aio_writev(s->bs->file, offset / BDRV_SECTOR_SIZE,
1028 &acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE,
1029 next_fn, acb);
1030 }
1031
1032 /**
1033 * Populate back untouched region of new data cluster
1034 */
1035 static void qed_aio_write_postfill(void *opaque, int ret)
1036 {
1037 QEDAIOCB *acb = opaque;
1038 BDRVQEDState *s = acb_to_s(acb);
1039 uint64_t start = acb->cur_pos + acb->cur_qiov.size;
1040 uint64_t len =
1041 qed_start_of_cluster(s, start + s->header.cluster_size - 1) - start;
1042 uint64_t offset = acb->cur_cluster +
1043 qed_offset_into_cluster(s, acb->cur_pos) +
1044 acb->cur_qiov.size;
1045
1046 if (ret) {
1047 qed_aio_complete(acb, ret);
1048 return;
1049 }
1050
1051 trace_qed_aio_write_postfill(s, acb, start, len, offset);
1052 qed_copy_from_backing_file(s, start, len, offset,
1053 qed_aio_write_main, acb);
1054 }
1055
1056 /**
1057 * Populate front untouched region of new data cluster
1058 */
1059 static void qed_aio_write_prefill(void *opaque, int ret)
1060 {
1061 QEDAIOCB *acb = opaque;
1062 BDRVQEDState *s = acb_to_s(acb);
1063 uint64_t start = qed_start_of_cluster(s, acb->cur_pos);
1064 uint64_t len = qed_offset_into_cluster(s, acb->cur_pos);
1065
1066 trace_qed_aio_write_prefill(s, acb, start, len, acb->cur_cluster);
1067 qed_copy_from_backing_file(s, start, len, acb->cur_cluster,
1068 qed_aio_write_postfill, acb);
1069 }
1070
1071 /**
1072 * Check if the QED_F_NEED_CHECK bit should be set during allocating write
1073 */
1074 static bool qed_should_set_need_check(BDRVQEDState *s)
1075 {
1076 /* The flush before L2 update path ensures consistency */
1077 if (s->bs->backing_hd) {
1078 return false;
1079 }
1080
1081 return !(s->header.features & QED_F_NEED_CHECK);
1082 }
1083
1084 /**
1085 * Write new data cluster
1086 *
1087 * @acb: Write request
1088 * @len: Length in bytes
1089 *
1090 * This path is taken when writing to previously unallocated clusters.
1091 */
1092 static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
1093 {
1094 BDRVQEDState *s = acb_to_s(acb);
1095
1096 /* Cancel timer when the first allocating request comes in */
1097 if (QSIMPLEQ_EMPTY(&s->allocating_write_reqs)) {
1098 qed_cancel_need_check_timer(s);
1099 }
1100
1101 /* Freeze this request if another allocating write is in progress */
1102 if (acb != QSIMPLEQ_FIRST(&s->allocating_write_reqs)) {
1103 QSIMPLEQ_INSERT_TAIL(&s->allocating_write_reqs, acb, next);
1104 }
1105 if (acb != QSIMPLEQ_FIRST(&s->allocating_write_reqs) ||
1106 s->allocating_write_reqs_plugged) {
1107 return; /* wait for existing request to finish */
1108 }
1109
1110 acb->cur_nclusters = qed_bytes_to_clusters(s,
1111 qed_offset_into_cluster(s, acb->cur_pos) + len);
1112 acb->cur_cluster = qed_alloc_clusters(s, acb->cur_nclusters);
1113 qemu_iovec_copy(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len);
1114
1115 if (qed_should_set_need_check(s)) {
1116 s->header.features |= QED_F_NEED_CHECK;
1117 qed_write_header(s, qed_aio_write_prefill, acb);
1118 } else {
1119 qed_aio_write_prefill(acb, 0);
1120 }
1121 }
1122
1123 /**
1124 * Write data cluster in place
1125 *
1126 * @acb: Write request
1127 * @offset: Cluster offset in bytes
1128 * @len: Length in bytes
1129 *
1130 * This path is taken when writing to already allocated clusters.
1131 */
1132 static void qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len)
1133 {
1134 /* Calculate the I/O vector */
1135 acb->cur_cluster = offset;
1136 qemu_iovec_copy(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len);
1137
1138 /* Do the actual write */
1139 qed_aio_write_main(acb, 0);
1140 }
1141
1142 /**
1143 * Write data cluster
1144 *
1145 * @opaque: Write request
1146 * @ret: QED_CLUSTER_FOUND, QED_CLUSTER_L2, QED_CLUSTER_L1,
1147 * or -errno
1148 * @offset: Cluster offset in bytes
1149 * @len: Length in bytes
1150 *
1151 * Callback from qed_find_cluster().
1152 */
1153 static void qed_aio_write_data(void *opaque, int ret,
1154 uint64_t offset, size_t len)
1155 {
1156 QEDAIOCB *acb = opaque;
1157
1158 trace_qed_aio_write_data(acb_to_s(acb), acb, ret, offset, len);
1159
1160 acb->find_cluster_ret = ret;
1161
1162 switch (ret) {
1163 case QED_CLUSTER_FOUND:
1164 qed_aio_write_inplace(acb, offset, len);
1165 break;
1166
1167 case QED_CLUSTER_L2:
1168 case QED_CLUSTER_L1:
1169 case QED_CLUSTER_ZERO:
1170 qed_aio_write_alloc(acb, len);
1171 break;
1172
1173 default:
1174 qed_aio_complete(acb, ret);
1175 break;
1176 }
1177 }
1178
1179 /**
1180 * Read data cluster
1181 *
1182 * @opaque: Read request
1183 * @ret: QED_CLUSTER_FOUND, QED_CLUSTER_L2, QED_CLUSTER_L1,
1184 * or -errno
1185 * @offset: Cluster offset in bytes
1186 * @len: Length in bytes
1187 *
1188 * Callback from qed_find_cluster().
1189 */
1190 static void qed_aio_read_data(void *opaque, int ret,
1191 uint64_t offset, size_t len)
1192 {
1193 QEDAIOCB *acb = opaque;
1194 BDRVQEDState *s = acb_to_s(acb);
1195 BlockDriverState *bs = acb->common.bs;
1196
1197 /* Adjust offset into cluster */
1198 offset += qed_offset_into_cluster(s, acb->cur_pos);
1199
1200 trace_qed_aio_read_data(s, acb, ret, offset, len);
1201
1202 if (ret < 0) {
1203 goto err;
1204 }
1205
1206 qemu_iovec_copy(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len);
1207
1208 /* Handle zero cluster and backing file reads */
1209 if (ret == QED_CLUSTER_ZERO) {
1210 qemu_iovec_memset(&acb->cur_qiov, 0, acb->cur_qiov.size);
1211 qed_aio_next_io(acb, 0);
1212 return;
1213 } else if (ret != QED_CLUSTER_FOUND) {
1214 qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov,
1215 qed_aio_next_io, acb);
1216 return;
1217 }
1218
1219 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
1220 bdrv_aio_readv(bs->file, offset / BDRV_SECTOR_SIZE,
1221 &acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE,
1222 qed_aio_next_io, acb);
1223 return;
1224
1225 err:
1226 qed_aio_complete(acb, ret);
1227 }
1228
1229 /**
1230 * Begin next I/O or complete the request
1231 */
1232 static void qed_aio_next_io(void *opaque, int ret)
1233 {
1234 QEDAIOCB *acb = opaque;
1235 BDRVQEDState *s = acb_to_s(acb);
1236 QEDFindClusterFunc *io_fn =
1237 acb->is_write ? qed_aio_write_data : qed_aio_read_data;
1238
1239 trace_qed_aio_next_io(s, acb, ret, acb->cur_pos + acb->cur_qiov.size);
1240
1241 /* Handle I/O error */
1242 if (ret) {
1243 qed_aio_complete(acb, ret);
1244 return;
1245 }
1246
1247 acb->qiov_offset += acb->cur_qiov.size;
1248 acb->cur_pos += acb->cur_qiov.size;
1249 qemu_iovec_reset(&acb->cur_qiov);
1250
1251 /* Complete request */
1252 if (acb->cur_pos >= acb->end_pos) {
1253 qed_aio_complete(acb, 0);
1254 return;
1255 }
1256
1257 /* Find next cluster and start I/O */
1258 qed_find_cluster(s, &acb->request,
1259 acb->cur_pos, acb->end_pos - acb->cur_pos,
1260 io_fn, acb);
1261 }
1262
1263 static BlockDriverAIOCB *qed_aio_setup(BlockDriverState *bs,
1264 int64_t sector_num,
1265 QEMUIOVector *qiov, int nb_sectors,
1266 BlockDriverCompletionFunc *cb,
1267 void *opaque, bool is_write)
1268 {
1269 QEDAIOCB *acb = qemu_aio_get(&qed_aio_pool, bs, cb, opaque);
1270
1271 trace_qed_aio_setup(bs->opaque, acb, sector_num, nb_sectors,
1272 opaque, is_write);
1273
1274 acb->is_write = is_write;
1275 acb->finished = NULL;
1276 acb->qiov = qiov;
1277 acb->qiov_offset = 0;
1278 acb->cur_pos = (uint64_t)sector_num * BDRV_SECTOR_SIZE;
1279 acb->end_pos = acb->cur_pos + nb_sectors * BDRV_SECTOR_SIZE;
1280 acb->request.l2_table = NULL;
1281 qemu_iovec_init(&acb->cur_qiov, qiov->niov);
1282
1283 /* Start request */
1284 qed_aio_next_io(acb, 0);
1285 return &acb->common;
1286 }
1287
1288 static BlockDriverAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs,
1289 int64_t sector_num,
1290 QEMUIOVector *qiov, int nb_sectors,
1291 BlockDriverCompletionFunc *cb,
1292 void *opaque)
1293 {
1294 return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, false);
1295 }
1296
1297 static BlockDriverAIOCB *bdrv_qed_aio_writev(BlockDriverState *bs,
1298 int64_t sector_num,
1299 QEMUIOVector *qiov, int nb_sectors,
1300 BlockDriverCompletionFunc *cb,
1301 void *opaque)
1302 {
1303 return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, true);
1304 }
1305
1306 static BlockDriverAIOCB *bdrv_qed_aio_flush(BlockDriverState *bs,
1307 BlockDriverCompletionFunc *cb,
1308 void *opaque)
1309 {
1310 return bdrv_aio_flush(bs->file, cb, opaque);
1311 }
1312
1313 static int bdrv_qed_truncate(BlockDriverState *bs, int64_t offset)
1314 {
1315 BDRVQEDState *s = bs->opaque;
1316 uint64_t old_image_size;
1317 int ret;
1318
1319 if (!qed_is_image_size_valid(offset, s->header.cluster_size,
1320 s->header.table_size)) {
1321 return -EINVAL;
1322 }
1323
1324 /* Shrinking is currently not supported */
1325 if ((uint64_t)offset < s->header.image_size) {
1326 return -ENOTSUP;
1327 }
1328
1329 old_image_size = s->header.image_size;
1330 s->header.image_size = offset;
1331 ret = qed_write_header_sync(s);
1332 if (ret < 0) {
1333 s->header.image_size = old_image_size;
1334 }
1335 return ret;
1336 }
1337
1338 static int64_t bdrv_qed_getlength(BlockDriverState *bs)
1339 {
1340 BDRVQEDState *s = bs->opaque;
1341 return s->header.image_size;
1342 }
1343
1344 static int bdrv_qed_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1345 {
1346 BDRVQEDState *s = bs->opaque;
1347
1348 memset(bdi, 0, sizeof(*bdi));
1349 bdi->cluster_size = s->header.cluster_size;
1350 return 0;
1351 }
1352
1353 static int bdrv_qed_change_backing_file(BlockDriverState *bs,
1354 const char *backing_file,
1355 const char *backing_fmt)
1356 {
1357 BDRVQEDState *s = bs->opaque;
1358 QEDHeader new_header, le_header;
1359 void *buffer;
1360 size_t buffer_len, backing_file_len;
1361 int ret;
1362
1363 /* Refuse to set backing filename if unknown compat feature bits are
1364 * active. If the image uses an unknown compat feature then we may not
1365 * know the layout of data following the header structure and cannot safely
1366 * add a new string.
1367 */
1368 if (backing_file && (s->header.compat_features &
1369 ~QED_COMPAT_FEATURE_MASK)) {
1370 return -ENOTSUP;
1371 }
1372
1373 memcpy(&new_header, &s->header, sizeof(new_header));
1374
1375 new_header.features &= ~(QED_F_BACKING_FILE |
1376 QED_F_BACKING_FORMAT_NO_PROBE);
1377
1378 /* Adjust feature flags */
1379 if (backing_file) {
1380 new_header.features |= QED_F_BACKING_FILE;
1381
1382 if (qed_fmt_is_raw(backing_fmt)) {
1383 new_header.features |= QED_F_BACKING_FORMAT_NO_PROBE;
1384 }
1385 }
1386
1387 /* Calculate new header size */
1388 backing_file_len = 0;
1389
1390 if (backing_file) {
1391 backing_file_len = strlen(backing_file);
1392 }
1393
1394 buffer_len = sizeof(new_header);
1395 new_header.backing_filename_offset = buffer_len;
1396 new_header.backing_filename_size = backing_file_len;
1397 buffer_len += backing_file_len;
1398
1399 /* Make sure we can rewrite header without failing */
1400 if (buffer_len > new_header.header_size * new_header.cluster_size) {
1401 return -ENOSPC;
1402 }
1403
1404 /* Prepare new header */
1405 buffer = g_malloc(buffer_len);
1406
1407 qed_header_cpu_to_le(&new_header, &le_header);
1408 memcpy(buffer, &le_header, sizeof(le_header));
1409 buffer_len = sizeof(le_header);
1410
1411 if (backing_file) {
1412 memcpy(buffer + buffer_len, backing_file, backing_file_len);
1413 buffer_len += backing_file_len;
1414 }
1415
1416 /* Write new header */
1417 ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len);
1418 g_free(buffer);
1419 if (ret == 0) {
1420 memcpy(&s->header, &new_header, sizeof(new_header));
1421 }
1422 return ret;
1423 }
1424
1425 static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result)
1426 {
1427 BDRVQEDState *s = bs->opaque;
1428
1429 return qed_check(s, result, false);
1430 }
1431
1432 static QEMUOptionParameter qed_create_options[] = {
1433 {
1434 .name = BLOCK_OPT_SIZE,
1435 .type = OPT_SIZE,
1436 .help = "Virtual disk size (in bytes)"
1437 }, {
1438 .name = BLOCK_OPT_BACKING_FILE,
1439 .type = OPT_STRING,
1440 .help = "File name of a base image"
1441 }, {
1442 .name = BLOCK_OPT_BACKING_FMT,
1443 .type = OPT_STRING,
1444 .help = "Image format of the base image"
1445 }, {
1446 .name = BLOCK_OPT_CLUSTER_SIZE,
1447 .type = OPT_SIZE,
1448 .help = "Cluster size (in bytes)",
1449 .value = { .n = QED_DEFAULT_CLUSTER_SIZE },
1450 }, {
1451 .name = BLOCK_OPT_TABLE_SIZE,
1452 .type = OPT_SIZE,
1453 .help = "L1/L2 table size (in clusters)"
1454 },
1455 { /* end of list */ }
1456 };
1457
1458 static BlockDriver bdrv_qed = {
1459 .format_name = "qed",
1460 .instance_size = sizeof(BDRVQEDState),
1461 .create_options = qed_create_options,
1462
1463 .bdrv_probe = bdrv_qed_probe,
1464 .bdrv_open = bdrv_qed_open,
1465 .bdrv_close = bdrv_qed_close,
1466 .bdrv_create = bdrv_qed_create,
1467 .bdrv_co_is_allocated = bdrv_qed_co_is_allocated,
1468 .bdrv_make_empty = bdrv_qed_make_empty,
1469 .bdrv_aio_readv = bdrv_qed_aio_readv,
1470 .bdrv_aio_writev = bdrv_qed_aio_writev,
1471 .bdrv_aio_flush = bdrv_qed_aio_flush,
1472 .bdrv_truncate = bdrv_qed_truncate,
1473 .bdrv_getlength = bdrv_qed_getlength,
1474 .bdrv_get_info = bdrv_qed_get_info,
1475 .bdrv_change_backing_file = bdrv_qed_change_backing_file,
1476 .bdrv_check = bdrv_qed_check,
1477 };
1478
1479 static void bdrv_qed_init(void)
1480 {
1481 bdrv_register(&bdrv_qed);
1482 }
1483
1484 block_init(bdrv_qed_init);