2 * QEMU Enhanced Disk Format
4 * Copyright IBM, Corp. 2010
7 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
8 * Anthony Liguori <aliguori@us.ibm.com>
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.
15 #include "qemu/timer.h"
18 #include "qapi/qmp/qerror.h"
19 #include "migration/migration.h"
21 static void qed_aio_cancel(BlockDriverAIOCB
*blockacb
)
23 QEDAIOCB
*acb
= (QEDAIOCB
*)blockacb
;
24 bool finished
= false;
26 /* Wait for the request to finish */
27 acb
->finished
= &finished
;
33 static const AIOCBInfo qed_aiocb_info
= {
34 .aiocb_size
= sizeof(QEDAIOCB
),
35 .cancel
= qed_aio_cancel
,
38 static int bdrv_qed_probe(const uint8_t *buf
, int buf_size
,
41 const QEDHeader
*header
= (const QEDHeader
*)buf
;
43 if (buf_size
< sizeof(*header
)) {
46 if (le32_to_cpu(header
->magic
) != QED_MAGIC
) {
53 * Check whether an image format is raw
55 * @fmt: Backing file format, may be NULL
57 static bool qed_fmt_is_raw(const char *fmt
)
59 return fmt
&& strcmp(fmt
, "raw") == 0;
62 static void qed_header_le_to_cpu(const QEDHeader
*le
, QEDHeader
*cpu
)
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
);
77 static void qed_header_cpu_to_le(const QEDHeader
*cpu
, QEDHeader
*le
)
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
);
92 int qed_write_header_sync(BDRVQEDState
*s
)
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
)) {
114 static void qed_write_header_cb(void *opaque
, int ret
)
116 QEDWriteHeaderCB
*write_header_cb
= opaque
;
118 qemu_vfree(write_header_cb
->buf
);
119 gencb_complete(write_header_cb
, ret
);
122 static void qed_write_header_read_cb(void *opaque
, int ret
)
124 QEDWriteHeaderCB
*write_header_cb
= opaque
;
125 BDRVQEDState
*s
= write_header_cb
->s
;
128 qed_write_header_cb(write_header_cb
, ret
);
133 qed_header_cpu_to_le(&s
->header
, (QEDHeader
*)write_header_cb
->buf
);
135 bdrv_aio_writev(s
->bs
->file
, 0, &write_header_cb
->qiov
,
136 write_header_cb
->nsectors
, qed_write_header_cb
,
141 * Update header in-place (does not rewrite backing filename or other strings)
143 * This function only updates known header fields in-place and does not affect
144 * extra data after the QED header.
146 static void qed_write_header(BDRVQEDState
*s
, BlockDriverCompletionFunc cb
,
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.
155 int nsectors
= (sizeof(QEDHeader
) + BDRV_SECTOR_SIZE
- 1) /
157 size_t len
= nsectors
* BDRV_SECTOR_SIZE
;
158 QEDWriteHeaderCB
*write_header_cb
= gencb_alloc(sizeof(*write_header_cb
),
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);
168 bdrv_aio_readv(s
->bs
->file
, 0, &write_header_cb
->qiov
, nsectors
,
169 qed_write_header_read_cb
, write_header_cb
);
172 static uint64_t qed_max_image_size(uint32_t cluster_size
, uint32_t table_size
)
174 uint64_t table_entries
;
177 table_entries
= (table_size
* cluster_size
) / sizeof(uint64_t);
178 l2_size
= table_entries
* cluster_size
;
180 return l2_size
* table_entries
;
183 static bool qed_is_cluster_size_valid(uint32_t cluster_size
)
185 if (cluster_size
< QED_MIN_CLUSTER_SIZE
||
186 cluster_size
> QED_MAX_CLUSTER_SIZE
) {
189 if (cluster_size
& (cluster_size
- 1)) {
190 return false; /* not power of 2 */
195 static bool qed_is_table_size_valid(uint32_t table_size
)
197 if (table_size
< QED_MIN_TABLE_SIZE
||
198 table_size
> QED_MAX_TABLE_SIZE
) {
201 if (table_size
& (table_size
- 1)) {
202 return false; /* not power of 2 */
207 static bool qed_is_image_size_valid(uint64_t image_size
, uint32_t cluster_size
,
210 if (image_size
% BDRV_SECTOR_SIZE
!= 0) {
211 return false; /* not multiple of sector size */
213 if (image_size
> qed_max_image_size(cluster_size
, table_size
)) {
214 return false; /* image is too large */
220 * Read a string of known length from the 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
229 * The string is NUL-terminated.
231 static int qed_read_string(BlockDriverState
*file
, uint64_t offset
, size_t n
,
232 char *buf
, size_t buflen
)
238 ret
= bdrv_pread(file
, offset
, buf
, n
);
247 * Allocate new clusters
250 * @n: Number of contiguous clusters to allocate
251 * @ret: Offset of first allocated cluster
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
257 static uint64_t qed_alloc_clusters(BDRVQEDState
*s
, unsigned int n
)
259 uint64_t offset
= s
->file_size
;
260 s
->file_size
+= n
* s
->header
.cluster_size
;
264 QEDTable
*qed_alloc_table(BDRVQEDState
*s
)
266 /* Honor O_DIRECT memory alignment requirements */
267 return qemu_blockalign(s
->bs
,
268 s
->header
.cluster_size
* s
->header
.table_size
);
272 * Allocate a new zeroed L2 table
274 static CachedL2Table
*qed_new_l2_table(BDRVQEDState
*s
)
276 CachedL2Table
*l2_table
= qed_alloc_l2_cache_entry(&s
->l2_cache
);
278 l2_table
->table
= qed_alloc_table(s
);
279 l2_table
->offset
= qed_alloc_clusters(s
, s
->header
.table_size
);
281 memset(l2_table
->table
->offsets
, 0,
282 s
->header
.cluster_size
* s
->header
.table_size
);
286 static void qed_aio_next_io(void *opaque
, int ret
);
288 static void qed_plug_allocating_write_reqs(BDRVQEDState
*s
)
290 assert(!s
->allocating_write_reqs_plugged
);
292 s
->allocating_write_reqs_plugged
= true;
295 static void qed_unplug_allocating_write_reqs(BDRVQEDState
*s
)
299 assert(s
->allocating_write_reqs_plugged
);
301 s
->allocating_write_reqs_plugged
= false;
303 acb
= QSIMPLEQ_FIRST(&s
->allocating_write_reqs
);
305 qed_aio_next_io(acb
, 0);
309 static void qed_finish_clear_need_check(void *opaque
, int ret
)
314 static void qed_flush_after_clear_need_check(void *opaque
, int ret
)
316 BDRVQEDState
*s
= opaque
;
318 bdrv_aio_flush(s
->bs
, qed_finish_clear_need_check
, s
);
320 /* No need to wait until flush completes */
321 qed_unplug_allocating_write_reqs(s
);
324 static void qed_clear_need_check(void *opaque
, int ret
)
326 BDRVQEDState
*s
= opaque
;
329 qed_unplug_allocating_write_reqs(s
);
333 s
->header
.features
&= ~QED_F_NEED_CHECK
;
334 qed_write_header(s
, qed_flush_after_clear_need_check
, s
);
337 static void qed_need_check_timer_cb(void *opaque
)
339 BDRVQEDState
*s
= opaque
;
341 /* The timer should only fire when allocating writes have drained */
342 assert(!QSIMPLEQ_FIRST(&s
->allocating_write_reqs
));
344 trace_qed_need_check_timer_cb(s
);
346 qed_plug_allocating_write_reqs(s
);
348 /* Ensure writes are on disk before clearing flag */
349 bdrv_aio_flush(s
->bs
, qed_clear_need_check
, s
);
352 static void qed_start_need_check_timer(BDRVQEDState
*s
)
354 trace_qed_start_need_check_timer(s
);
356 /* Use QEMU_CLOCK_VIRTUAL so we don't alter the image file while suspended for
359 timer_mod(s
->need_check_timer
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
360 get_ticks_per_sec() * QED_NEED_CHECK_TIMEOUT
);
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
)
366 trace_qed_cancel_need_check_timer(s
);
367 timer_del(s
->need_check_timer
);
370 static void bdrv_qed_rebind(BlockDriverState
*bs
)
372 BDRVQEDState
*s
= bs
->opaque
;
376 static int bdrv_qed_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
379 BDRVQEDState
*s
= bs
->opaque
;
385 QSIMPLEQ_INIT(&s
->allocating_write_reqs
);
387 ret
= bdrv_pread(bs
->file
, 0, &le_header
, sizeof(le_header
));
391 qed_header_le_to_cpu(&le_header
, &s
->header
);
393 if (s
->header
.magic
!= QED_MAGIC
) {
396 if (s
->header
.features
& ~QED_FEATURE_MASK
) {
397 /* image uses unsupported feature bits */
399 snprintf(buf
, sizeof(buf
), "%" PRIx64
,
400 s
->header
.features
& ~QED_FEATURE_MASK
);
401 qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE
,
402 bs
->device_name
, "QED", buf
);
405 if (!qed_is_cluster_size_valid(s
->header
.cluster_size
)) {
409 /* Round down file size to the last cluster */
410 file_size
= bdrv_getlength(bs
->file
);
414 s
->file_size
= qed_start_of_cluster(s
, file_size
);
416 if (!qed_is_table_size_valid(s
->header
.table_size
)) {
419 if (!qed_is_image_size_valid(s
->header
.image_size
,
420 s
->header
.cluster_size
,
421 s
->header
.table_size
)) {
424 if (!qed_check_table_offset(s
, s
->header
.l1_table_offset
)) {
428 s
->table_nelems
= (s
->header
.cluster_size
* s
->header
.table_size
) /
430 s
->l2_shift
= ffs(s
->header
.cluster_size
) - 1;
431 s
->l2_mask
= s
->table_nelems
- 1;
432 s
->l1_shift
= s
->l2_shift
+ ffs(s
->table_nelems
) - 1;
434 if ((s
->header
.features
& QED_F_BACKING_FILE
)) {
435 if ((uint64_t)s
->header
.backing_filename_offset
+
436 s
->header
.backing_filename_size
>
437 s
->header
.cluster_size
* s
->header
.header_size
) {
441 ret
= qed_read_string(bs
->file
, s
->header
.backing_filename_offset
,
442 s
->header
.backing_filename_size
, bs
->backing_file
,
443 sizeof(bs
->backing_file
));
448 if (s
->header
.features
& QED_F_BACKING_FORMAT_NO_PROBE
) {
449 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), "raw");
453 /* Reset unknown autoclear feature bits. This is a backwards
454 * compatibility mechanism that allows images to be opened by older
455 * programs, which "knock out" unknown feature bits. When an image is
456 * opened by a newer program again it can detect that the autoclear
457 * feature is no longer valid.
459 if ((s
->header
.autoclear_features
& ~QED_AUTOCLEAR_FEATURE_MASK
) != 0 &&
460 !bdrv_is_read_only(bs
->file
) && !(flags
& BDRV_O_INCOMING
)) {
461 s
->header
.autoclear_features
&= QED_AUTOCLEAR_FEATURE_MASK
;
463 ret
= qed_write_header_sync(s
);
468 /* From here on only known autoclear feature bits are valid */
469 bdrv_flush(bs
->file
);
472 s
->l1_table
= qed_alloc_table(s
);
473 qed_init_l2_cache(&s
->l2_cache
);
475 ret
= qed_read_l1_table_sync(s
);
480 /* If image was not closed cleanly, check consistency */
481 if (!(flags
& BDRV_O_CHECK
) && (s
->header
.features
& QED_F_NEED_CHECK
)) {
482 /* Read-only images cannot be fixed. There is no risk of corruption
483 * since write operations are not possible. Therefore, allow
484 * potentially inconsistent images to be opened read-only. This can
485 * aid data recovery from an otherwise inconsistent image.
487 if (!bdrv_is_read_only(bs
->file
) &&
488 !(flags
& BDRV_O_INCOMING
)) {
489 BdrvCheckResult result
= {0};
491 ret
= qed_check(s
, &result
, true);
498 s
->need_check_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
499 qed_need_check_timer_cb
, s
);
503 qed_free_l2_cache(&s
->l2_cache
);
504 qemu_vfree(s
->l1_table
);
509 /* We have nothing to do for QED reopen, stubs just return
511 static int bdrv_qed_reopen_prepare(BDRVReopenState
*state
,
512 BlockReopenQueue
*queue
, Error
**errp
)
517 static void bdrv_qed_close(BlockDriverState
*bs
)
519 BDRVQEDState
*s
= bs
->opaque
;
521 qed_cancel_need_check_timer(s
);
522 timer_free(s
->need_check_timer
);
524 /* Ensure writes reach stable storage */
525 bdrv_flush(bs
->file
);
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
);
533 qed_free_l2_cache(&s
->l2_cache
);
534 qemu_vfree(s
->l1_table
);
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
)
543 .cluster_size
= cluster_size
,
544 .table_size
= table_size
,
547 .compat_features
= 0,
548 .l1_table_offset
= cluster_size
,
549 .image_size
= image_size
,
552 uint8_t *l1_table
= NULL
;
553 size_t l1_size
= header
.cluster_size
* header
.table_size
;
555 BlockDriverState
*bs
= NULL
;
557 ret
= bdrv_create_file(filename
, NULL
);
562 ret
= bdrv_file_open(&bs
, filename
, NULL
, BDRV_O_RDWR
| BDRV_O_CACHE_WB
);
567 /* File must start empty and grow, check truncate is supported */
568 ret
= bdrv_truncate(bs
, 0);
574 header
.features
|= QED_F_BACKING_FILE
;
575 header
.backing_filename_offset
= sizeof(le_header
);
576 header
.backing_filename_size
= strlen(backing_file
);
578 if (qed_fmt_is_raw(backing_fmt
)) {
579 header
.features
|= QED_F_BACKING_FORMAT_NO_PROBE
;
583 qed_header_cpu_to_le(&header
, &le_header
);
584 ret
= bdrv_pwrite(bs
, 0, &le_header
, sizeof(le_header
));
588 ret
= bdrv_pwrite(bs
, sizeof(le_header
), backing_file
,
589 header
.backing_filename_size
);
594 l1_table
= g_malloc0(l1_size
);
595 ret
= bdrv_pwrite(bs
, header
.l1_table_offset
, l1_table
, l1_size
);
600 ret
= 0; /* success */
607 static int bdrv_qed_create(const char *filename
, QEMUOptionParameter
*options
)
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
;
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
;
626 } else if (!strcmp(options
->name
, BLOCK_OPT_TABLE_SIZE
)) {
627 if (options
->value
.n
) {
628 table_size
= options
->value
.n
;
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
);
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
);
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
));
651 return qed_create(filename
, cluster_size
, image_size
, table_size
,
652 backing_file
, backing_fmt
);
656 BlockDriverState
*bs
;
663 static void qed_is_allocated_cb(void *opaque
, int ret
, uint64_t offset
, size_t len
)
665 QEDIsAllocatedCB
*cb
= opaque
;
666 BDRVQEDState
*s
= cb
->bs
->opaque
;
667 *cb
->pnum
= len
/ BDRV_SECTOR_SIZE
;
669 case QED_CLUSTER_FOUND
:
670 offset
|= qed_offset_into_cluster(s
, cb
->pos
);
671 cb
->status
= BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
| offset
;
673 case QED_CLUSTER_ZERO
:
674 cb
->status
= BDRV_BLOCK_ZERO
;
687 qemu_coroutine_enter(cb
->co
, NULL
);
691 static int64_t coroutine_fn
bdrv_qed_co_get_block_status(BlockDriverState
*bs
,
693 int nb_sectors
, int *pnum
)
695 BDRVQEDState
*s
= bs
->opaque
;
696 size_t len
= (size_t)nb_sectors
* BDRV_SECTOR_SIZE
;
697 QEDIsAllocatedCB cb
= {
699 .pos
= (uint64_t)sector_num
* BDRV_SECTOR_SIZE
,
700 .status
= BDRV_BLOCK_OFFSET_MASK
,
703 QEDRequest request
= { .l2_table
= NULL
};
705 qed_find_cluster(s
, &request
, cb
.pos
, len
, qed_is_allocated_cb
, &cb
);
707 /* Now sleep if the callback wasn't invoked immediately */
708 while (cb
.status
== BDRV_BLOCK_OFFSET_MASK
) {
709 cb
.co
= qemu_coroutine_self();
710 qemu_coroutine_yield();
713 qed_unref_l2_cache_entry(request
.l2_table
);
718 static int bdrv_qed_make_empty(BlockDriverState
*bs
)
723 static BDRVQEDState
*acb_to_s(QEDAIOCB
*acb
)
725 return acb
->common
.bs
->opaque
;
729 * Read from the backing file or zero-fill if no backing file
732 * @pos: Byte position in device
733 * @qiov: Destination I/O vector
734 * @cb: Completion function
735 * @opaque: User data for completion function
737 * This function reads qiov->size bytes starting at pos from the backing file.
738 * If there is no backing file then zeroes are read.
740 static void qed_read_backing_file(BDRVQEDState
*s
, uint64_t pos
,
742 BlockDriverCompletionFunc
*cb
, void *opaque
)
744 uint64_t backing_length
= 0;
747 /* If there is a backing file, get its length. Treat the absence of a
748 * backing file like a zero length backing file.
750 if (s
->bs
->backing_hd
) {
751 int64_t l
= bdrv_getlength(s
->bs
->backing_hd
);
759 /* Zero all sectors if reading beyond the end of the backing file */
760 if (pos
>= backing_length
||
761 pos
+ qiov
->size
> backing_length
) {
762 qemu_iovec_memset(qiov
, 0, 0, qiov
->size
);
765 /* Complete now if there are no backing file sectors to read */
766 if (pos
>= backing_length
) {
771 /* If the read straddles the end of the backing file, shorten it */
772 size
= MIN((uint64_t)backing_length
- pos
, qiov
->size
);
774 BLKDBG_EVENT(s
->bs
->file
, BLKDBG_READ_BACKING_AIO
);
775 bdrv_aio_readv(s
->bs
->backing_hd
, pos
/ BDRV_SECTOR_SIZE
,
776 qiov
, size
/ BDRV_SECTOR_SIZE
, cb
, opaque
);
785 } CopyFromBackingFileCB
;
787 static void qed_copy_from_backing_file_cb(void *opaque
, int ret
)
789 CopyFromBackingFileCB
*copy_cb
= opaque
;
790 qemu_vfree(copy_cb
->iov
.iov_base
);
791 gencb_complete(©_cb
->gencb
, ret
);
794 static void qed_copy_from_backing_file_write(void *opaque
, int ret
)
796 CopyFromBackingFileCB
*copy_cb
= opaque
;
797 BDRVQEDState
*s
= copy_cb
->s
;
800 qed_copy_from_backing_file_cb(copy_cb
, ret
);
804 BLKDBG_EVENT(s
->bs
->file
, BLKDBG_COW_WRITE
);
805 bdrv_aio_writev(s
->bs
->file
, copy_cb
->offset
/ BDRV_SECTOR_SIZE
,
806 ©_cb
->qiov
, copy_cb
->qiov
.size
/ BDRV_SECTOR_SIZE
,
807 qed_copy_from_backing_file_cb
, copy_cb
);
811 * Copy data from backing file into the image
814 * @pos: Byte position in device
815 * @len: Number of bytes
816 * @offset: Byte offset in image file
817 * @cb: Completion function
818 * @opaque: User data for completion function
820 static void qed_copy_from_backing_file(BDRVQEDState
*s
, uint64_t pos
,
821 uint64_t len
, uint64_t offset
,
822 BlockDriverCompletionFunc
*cb
,
825 CopyFromBackingFileCB
*copy_cb
;
827 /* Skip copy entirely if there is no work to do */
833 copy_cb
= gencb_alloc(sizeof(*copy_cb
), cb
, opaque
);
835 copy_cb
->offset
= offset
;
836 copy_cb
->iov
.iov_base
= qemu_blockalign(s
->bs
, len
);
837 copy_cb
->iov
.iov_len
= len
;
838 qemu_iovec_init_external(©_cb
->qiov
, ©_cb
->iov
, 1);
840 qed_read_backing_file(s
, pos
, ©_cb
->qiov
,
841 qed_copy_from_backing_file_write
, copy_cb
);
845 * Link one or more contiguous clusters into a table
849 * @index: First cluster index
850 * @n: Number of contiguous clusters
851 * @cluster: First cluster offset
853 * The cluster offset may be an allocated byte offset in the image file, the
854 * zero cluster marker, or the unallocated cluster marker.
856 static void qed_update_l2_table(BDRVQEDState
*s
, QEDTable
*table
, int index
,
857 unsigned int n
, uint64_t cluster
)
860 for (i
= index
; i
< index
+ n
; i
++) {
861 table
->offsets
[i
] = cluster
;
862 if (!qed_offset_is_unalloc_cluster(cluster
) &&
863 !qed_offset_is_zero_cluster(cluster
)) {
864 cluster
+= s
->header
.cluster_size
;
869 static void qed_aio_complete_bh(void *opaque
)
871 QEDAIOCB
*acb
= opaque
;
872 BlockDriverCompletionFunc
*cb
= acb
->common
.cb
;
873 void *user_opaque
= acb
->common
.opaque
;
874 int ret
= acb
->bh_ret
;
875 bool *finished
= acb
->finished
;
877 qemu_bh_delete(acb
->bh
);
878 qemu_aio_release(acb
);
880 /* Invoke callback */
881 cb(user_opaque
, ret
);
883 /* Signal cancel completion */
889 static void qed_aio_complete(QEDAIOCB
*acb
, int ret
)
891 BDRVQEDState
*s
= acb_to_s(acb
);
893 trace_qed_aio_complete(s
, acb
, ret
);
896 qemu_iovec_destroy(&acb
->cur_qiov
);
897 qed_unref_l2_cache_entry(acb
->request
.l2_table
);
899 /* Free the buffer we may have allocated for zero writes */
900 if (acb
->flags
& QED_AIOCB_ZERO
) {
901 qemu_vfree(acb
->qiov
->iov
[0].iov_base
);
902 acb
->qiov
->iov
[0].iov_base
= NULL
;
905 /* Arrange for a bh to invoke the completion function */
907 acb
->bh
= qemu_bh_new(qed_aio_complete_bh
, acb
);
908 qemu_bh_schedule(acb
->bh
);
910 /* Start next allocating write request waiting behind this one. Note that
911 * requests enqueue themselves when they first hit an unallocated cluster
912 * but they wait until the entire request is finished before waking up the
913 * next request in the queue. This ensures that we don't cycle through
914 * requests multiple times but rather finish one at a time completely.
916 if (acb
== QSIMPLEQ_FIRST(&s
->allocating_write_reqs
)) {
917 QSIMPLEQ_REMOVE_HEAD(&s
->allocating_write_reqs
, next
);
918 acb
= QSIMPLEQ_FIRST(&s
->allocating_write_reqs
);
920 qed_aio_next_io(acb
, 0);
921 } else if (s
->header
.features
& QED_F_NEED_CHECK
) {
922 qed_start_need_check_timer(s
);
928 * Commit the current L2 table to the cache
930 static void qed_commit_l2_update(void *opaque
, int ret
)
932 QEDAIOCB
*acb
= opaque
;
933 BDRVQEDState
*s
= acb_to_s(acb
);
934 CachedL2Table
*l2_table
= acb
->request
.l2_table
;
935 uint64_t l2_offset
= l2_table
->offset
;
937 qed_commit_l2_cache_entry(&s
->l2_cache
, l2_table
);
939 /* This is guaranteed to succeed because we just committed the entry to the
942 acb
->request
.l2_table
= qed_find_l2_cache_entry(&s
->l2_cache
, l2_offset
);
943 assert(acb
->request
.l2_table
!= NULL
);
945 qed_aio_next_io(opaque
, ret
);
949 * Update L1 table with new L2 table offset and write it out
951 static void qed_aio_write_l1_update(void *opaque
, int ret
)
953 QEDAIOCB
*acb
= opaque
;
954 BDRVQEDState
*s
= acb_to_s(acb
);
958 qed_aio_complete(acb
, ret
);
962 index
= qed_l1_index(s
, acb
->cur_pos
);
963 s
->l1_table
->offsets
[index
] = acb
->request
.l2_table
->offset
;
965 qed_write_l1_table(s
, index
, 1, qed_commit_l2_update
, acb
);
969 * Update L2 table with new cluster offsets and write them out
971 static void qed_aio_write_l2_update(QEDAIOCB
*acb
, int ret
, uint64_t offset
)
973 BDRVQEDState
*s
= acb_to_s(acb
);
974 bool need_alloc
= acb
->find_cluster_ret
== QED_CLUSTER_L1
;
982 qed_unref_l2_cache_entry(acb
->request
.l2_table
);
983 acb
->request
.l2_table
= qed_new_l2_table(s
);
986 index
= qed_l2_index(s
, acb
->cur_pos
);
987 qed_update_l2_table(s
, acb
->request
.l2_table
->table
, index
, acb
->cur_nclusters
,
991 /* Write out the whole new L2 table */
992 qed_write_l2_table(s
, &acb
->request
, 0, s
->table_nelems
, true,
993 qed_aio_write_l1_update
, acb
);
995 /* Write out only the updated part of the L2 table */
996 qed_write_l2_table(s
, &acb
->request
, index
, acb
->cur_nclusters
, false,
997 qed_aio_next_io
, acb
);
1002 qed_aio_complete(acb
, ret
);
1005 static void qed_aio_write_l2_update_cb(void *opaque
, int ret
)
1007 QEDAIOCB
*acb
= opaque
;
1008 qed_aio_write_l2_update(acb
, ret
, acb
->cur_cluster
);
1012 * Flush new data clusters before updating the L2 table
1014 * This flush is necessary when a backing file is in use. A crash during an
1015 * allocating write could result in empty clusters in the image. If the write
1016 * only touched a subregion of the cluster, then backing image sectors have
1017 * been lost in the untouched region. The solution is to flush after writing a
1018 * new data cluster and before updating the L2 table.
1020 static void qed_aio_write_flush_before_l2_update(void *opaque
, int ret
)
1022 QEDAIOCB
*acb
= opaque
;
1023 BDRVQEDState
*s
= acb_to_s(acb
);
1025 if (!bdrv_aio_flush(s
->bs
->file
, qed_aio_write_l2_update_cb
, opaque
)) {
1026 qed_aio_complete(acb
, -EIO
);
1031 * Write data to the image file
1033 static void qed_aio_write_main(void *opaque
, int ret
)
1035 QEDAIOCB
*acb
= opaque
;
1036 BDRVQEDState
*s
= acb_to_s(acb
);
1037 uint64_t offset
= acb
->cur_cluster
+
1038 qed_offset_into_cluster(s
, acb
->cur_pos
);
1039 BlockDriverCompletionFunc
*next_fn
;
1041 trace_qed_aio_write_main(s
, acb
, ret
, offset
, acb
->cur_qiov
.size
);
1044 qed_aio_complete(acb
, ret
);
1048 if (acb
->find_cluster_ret
== QED_CLUSTER_FOUND
) {
1049 next_fn
= qed_aio_next_io
;
1051 if (s
->bs
->backing_hd
) {
1052 next_fn
= qed_aio_write_flush_before_l2_update
;
1054 next_fn
= qed_aio_write_l2_update_cb
;
1058 BLKDBG_EVENT(s
->bs
->file
, BLKDBG_WRITE_AIO
);
1059 bdrv_aio_writev(s
->bs
->file
, offset
/ BDRV_SECTOR_SIZE
,
1060 &acb
->cur_qiov
, acb
->cur_qiov
.size
/ BDRV_SECTOR_SIZE
,
1065 * Populate back untouched region of new data cluster
1067 static void qed_aio_write_postfill(void *opaque
, int ret
)
1069 QEDAIOCB
*acb
= opaque
;
1070 BDRVQEDState
*s
= acb_to_s(acb
);
1071 uint64_t start
= acb
->cur_pos
+ acb
->cur_qiov
.size
;
1073 qed_start_of_cluster(s
, start
+ s
->header
.cluster_size
- 1) - start
;
1074 uint64_t offset
= acb
->cur_cluster
+
1075 qed_offset_into_cluster(s
, acb
->cur_pos
) +
1079 qed_aio_complete(acb
, ret
);
1083 trace_qed_aio_write_postfill(s
, acb
, start
, len
, offset
);
1084 qed_copy_from_backing_file(s
, start
, len
, offset
,
1085 qed_aio_write_main
, acb
);
1089 * Populate front untouched region of new data cluster
1091 static void qed_aio_write_prefill(void *opaque
, int ret
)
1093 QEDAIOCB
*acb
= opaque
;
1094 BDRVQEDState
*s
= acb_to_s(acb
);
1095 uint64_t start
= qed_start_of_cluster(s
, acb
->cur_pos
);
1096 uint64_t len
= qed_offset_into_cluster(s
, acb
->cur_pos
);
1098 trace_qed_aio_write_prefill(s
, acb
, start
, len
, acb
->cur_cluster
);
1099 qed_copy_from_backing_file(s
, start
, len
, acb
->cur_cluster
,
1100 qed_aio_write_postfill
, acb
);
1104 * Check if the QED_F_NEED_CHECK bit should be set during allocating write
1106 static bool qed_should_set_need_check(BDRVQEDState
*s
)
1108 /* The flush before L2 update path ensures consistency */
1109 if (s
->bs
->backing_hd
) {
1113 return !(s
->header
.features
& QED_F_NEED_CHECK
);
1116 static void qed_aio_write_zero_cluster(void *opaque
, int ret
)
1118 QEDAIOCB
*acb
= opaque
;
1121 qed_aio_complete(acb
, ret
);
1125 qed_aio_write_l2_update(acb
, 0, 1);
1129 * Write new data cluster
1131 * @acb: Write request
1132 * @len: Length in bytes
1134 * This path is taken when writing to previously unallocated clusters.
1136 static void qed_aio_write_alloc(QEDAIOCB
*acb
, size_t len
)
1138 BDRVQEDState
*s
= acb_to_s(acb
);
1139 BlockDriverCompletionFunc
*cb
;
1141 /* Cancel timer when the first allocating request comes in */
1142 if (QSIMPLEQ_EMPTY(&s
->allocating_write_reqs
)) {
1143 qed_cancel_need_check_timer(s
);
1146 /* Freeze this request if another allocating write is in progress */
1147 if (acb
!= QSIMPLEQ_FIRST(&s
->allocating_write_reqs
)) {
1148 QSIMPLEQ_INSERT_TAIL(&s
->allocating_write_reqs
, acb
, next
);
1150 if (acb
!= QSIMPLEQ_FIRST(&s
->allocating_write_reqs
) ||
1151 s
->allocating_write_reqs_plugged
) {
1152 return; /* wait for existing request to finish */
1155 acb
->cur_nclusters
= qed_bytes_to_clusters(s
,
1156 qed_offset_into_cluster(s
, acb
->cur_pos
) + len
);
1157 qemu_iovec_concat(&acb
->cur_qiov
, acb
->qiov
, acb
->qiov_offset
, len
);
1159 if (acb
->flags
& QED_AIOCB_ZERO
) {
1160 /* Skip ahead if the clusters are already zero */
1161 if (acb
->find_cluster_ret
== QED_CLUSTER_ZERO
) {
1162 qed_aio_next_io(acb
, 0);
1166 cb
= qed_aio_write_zero_cluster
;
1168 cb
= qed_aio_write_prefill
;
1169 acb
->cur_cluster
= qed_alloc_clusters(s
, acb
->cur_nclusters
);
1172 if (qed_should_set_need_check(s
)) {
1173 s
->header
.features
|= QED_F_NEED_CHECK
;
1174 qed_write_header(s
, cb
, acb
);
1181 * Write data cluster in place
1183 * @acb: Write request
1184 * @offset: Cluster offset in bytes
1185 * @len: Length in bytes
1187 * This path is taken when writing to already allocated clusters.
1189 static void qed_aio_write_inplace(QEDAIOCB
*acb
, uint64_t offset
, size_t len
)
1191 /* Allocate buffer for zero writes */
1192 if (acb
->flags
& QED_AIOCB_ZERO
) {
1193 struct iovec
*iov
= acb
->qiov
->iov
;
1195 if (!iov
->iov_base
) {
1196 iov
->iov_base
= qemu_blockalign(acb
->common
.bs
, iov
->iov_len
);
1197 memset(iov
->iov_base
, 0, iov
->iov_len
);
1201 /* Calculate the I/O vector */
1202 acb
->cur_cluster
= offset
;
1203 qemu_iovec_concat(&acb
->cur_qiov
, acb
->qiov
, acb
->qiov_offset
, len
);
1205 /* Do the actual write */
1206 qed_aio_write_main(acb
, 0);
1210 * Write data cluster
1212 * @opaque: Write request
1213 * @ret: QED_CLUSTER_FOUND, QED_CLUSTER_L2, QED_CLUSTER_L1,
1215 * @offset: Cluster offset in bytes
1216 * @len: Length in bytes
1218 * Callback from qed_find_cluster().
1220 static void qed_aio_write_data(void *opaque
, int ret
,
1221 uint64_t offset
, size_t len
)
1223 QEDAIOCB
*acb
= opaque
;
1225 trace_qed_aio_write_data(acb_to_s(acb
), acb
, ret
, offset
, len
);
1227 acb
->find_cluster_ret
= ret
;
1230 case QED_CLUSTER_FOUND
:
1231 qed_aio_write_inplace(acb
, offset
, len
);
1234 case QED_CLUSTER_L2
:
1235 case QED_CLUSTER_L1
:
1236 case QED_CLUSTER_ZERO
:
1237 qed_aio_write_alloc(acb
, len
);
1241 qed_aio_complete(acb
, ret
);
1249 * @opaque: Read request
1250 * @ret: QED_CLUSTER_FOUND, QED_CLUSTER_L2, QED_CLUSTER_L1,
1252 * @offset: Cluster offset in bytes
1253 * @len: Length in bytes
1255 * Callback from qed_find_cluster().
1257 static void qed_aio_read_data(void *opaque
, int ret
,
1258 uint64_t offset
, size_t len
)
1260 QEDAIOCB
*acb
= opaque
;
1261 BDRVQEDState
*s
= acb_to_s(acb
);
1262 BlockDriverState
*bs
= acb
->common
.bs
;
1264 /* Adjust offset into cluster */
1265 offset
+= qed_offset_into_cluster(s
, acb
->cur_pos
);
1267 trace_qed_aio_read_data(s
, acb
, ret
, offset
, len
);
1273 qemu_iovec_concat(&acb
->cur_qiov
, acb
->qiov
, acb
->qiov_offset
, len
);
1275 /* Handle zero cluster and backing file reads */
1276 if (ret
== QED_CLUSTER_ZERO
) {
1277 qemu_iovec_memset(&acb
->cur_qiov
, 0, 0, acb
->cur_qiov
.size
);
1278 qed_aio_next_io(acb
, 0);
1280 } else if (ret
!= QED_CLUSTER_FOUND
) {
1281 qed_read_backing_file(s
, acb
->cur_pos
, &acb
->cur_qiov
,
1282 qed_aio_next_io
, acb
);
1286 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
1287 bdrv_aio_readv(bs
->file
, offset
/ BDRV_SECTOR_SIZE
,
1288 &acb
->cur_qiov
, acb
->cur_qiov
.size
/ BDRV_SECTOR_SIZE
,
1289 qed_aio_next_io
, acb
);
1293 qed_aio_complete(acb
, ret
);
1297 * Begin next I/O or complete the request
1299 static void qed_aio_next_io(void *opaque
, int ret
)
1301 QEDAIOCB
*acb
= opaque
;
1302 BDRVQEDState
*s
= acb_to_s(acb
);
1303 QEDFindClusterFunc
*io_fn
= (acb
->flags
& QED_AIOCB_WRITE
) ?
1304 qed_aio_write_data
: qed_aio_read_data
;
1306 trace_qed_aio_next_io(s
, acb
, ret
, acb
->cur_pos
+ acb
->cur_qiov
.size
);
1308 /* Handle I/O error */
1310 qed_aio_complete(acb
, ret
);
1314 acb
->qiov_offset
+= acb
->cur_qiov
.size
;
1315 acb
->cur_pos
+= acb
->cur_qiov
.size
;
1316 qemu_iovec_reset(&acb
->cur_qiov
);
1318 /* Complete request */
1319 if (acb
->cur_pos
>= acb
->end_pos
) {
1320 qed_aio_complete(acb
, 0);
1324 /* Find next cluster and start I/O */
1325 qed_find_cluster(s
, &acb
->request
,
1326 acb
->cur_pos
, acb
->end_pos
- acb
->cur_pos
,
1330 static BlockDriverAIOCB
*qed_aio_setup(BlockDriverState
*bs
,
1332 QEMUIOVector
*qiov
, int nb_sectors
,
1333 BlockDriverCompletionFunc
*cb
,
1334 void *opaque
, int flags
)
1336 QEDAIOCB
*acb
= qemu_aio_get(&qed_aiocb_info
, bs
, cb
, opaque
);
1338 trace_qed_aio_setup(bs
->opaque
, acb
, sector_num
, nb_sectors
,
1342 acb
->finished
= NULL
;
1344 acb
->qiov_offset
= 0;
1345 acb
->cur_pos
= (uint64_t)sector_num
* BDRV_SECTOR_SIZE
;
1346 acb
->end_pos
= acb
->cur_pos
+ nb_sectors
* BDRV_SECTOR_SIZE
;
1347 acb
->request
.l2_table
= NULL
;
1348 qemu_iovec_init(&acb
->cur_qiov
, qiov
->niov
);
1351 qed_aio_next_io(acb
, 0);
1352 return &acb
->common
;
1355 static BlockDriverAIOCB
*bdrv_qed_aio_readv(BlockDriverState
*bs
,
1357 QEMUIOVector
*qiov
, int nb_sectors
,
1358 BlockDriverCompletionFunc
*cb
,
1361 return qed_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
1364 static BlockDriverAIOCB
*bdrv_qed_aio_writev(BlockDriverState
*bs
,
1366 QEMUIOVector
*qiov
, int nb_sectors
,
1367 BlockDriverCompletionFunc
*cb
,
1370 return qed_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
,
1371 opaque
, QED_AIOCB_WRITE
);
1380 static void coroutine_fn
qed_co_write_zeroes_cb(void *opaque
, int ret
)
1382 QEDWriteZeroesCB
*cb
= opaque
;
1387 qemu_coroutine_enter(cb
->co
, NULL
);
1391 static int coroutine_fn
bdrv_qed_co_write_zeroes(BlockDriverState
*bs
,
1395 BlockDriverAIOCB
*blockacb
;
1396 BDRVQEDState
*s
= bs
->opaque
;
1397 QEDWriteZeroesCB cb
= { .done
= false };
1401 /* Refuse if there are untouched backing file sectors */
1402 if (bs
->backing_hd
) {
1403 if (qed_offset_into_cluster(s
, sector_num
* BDRV_SECTOR_SIZE
) != 0) {
1406 if (qed_offset_into_cluster(s
, nb_sectors
* BDRV_SECTOR_SIZE
) != 0) {
1411 /* Zero writes start without an I/O buffer. If a buffer becomes necessary
1412 * then it will be allocated during request processing.
1414 iov
.iov_base
= NULL
,
1415 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
1417 qemu_iovec_init_external(&qiov
, &iov
, 1);
1418 blockacb
= qed_aio_setup(bs
, sector_num
, &qiov
, nb_sectors
,
1419 qed_co_write_zeroes_cb
, &cb
,
1420 QED_AIOCB_WRITE
| QED_AIOCB_ZERO
);
1425 cb
.co
= qemu_coroutine_self();
1426 qemu_coroutine_yield();
1432 static int bdrv_qed_truncate(BlockDriverState
*bs
, int64_t offset
)
1434 BDRVQEDState
*s
= bs
->opaque
;
1435 uint64_t old_image_size
;
1438 if (!qed_is_image_size_valid(offset
, s
->header
.cluster_size
,
1439 s
->header
.table_size
)) {
1443 /* Shrinking is currently not supported */
1444 if ((uint64_t)offset
< s
->header
.image_size
) {
1448 old_image_size
= s
->header
.image_size
;
1449 s
->header
.image_size
= offset
;
1450 ret
= qed_write_header_sync(s
);
1452 s
->header
.image_size
= old_image_size
;
1457 static int64_t bdrv_qed_getlength(BlockDriverState
*bs
)
1459 BDRVQEDState
*s
= bs
->opaque
;
1460 return s
->header
.image_size
;
1463 static int bdrv_qed_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
1465 BDRVQEDState
*s
= bs
->opaque
;
1467 memset(bdi
, 0, sizeof(*bdi
));
1468 bdi
->cluster_size
= s
->header
.cluster_size
;
1469 bdi
->is_dirty
= s
->header
.features
& QED_F_NEED_CHECK
;
1473 static int bdrv_qed_change_backing_file(BlockDriverState
*bs
,
1474 const char *backing_file
,
1475 const char *backing_fmt
)
1477 BDRVQEDState
*s
= bs
->opaque
;
1478 QEDHeader new_header
, le_header
;
1480 size_t buffer_len
, backing_file_len
;
1483 /* Refuse to set backing filename if unknown compat feature bits are
1484 * active. If the image uses an unknown compat feature then we may not
1485 * know the layout of data following the header structure and cannot safely
1488 if (backing_file
&& (s
->header
.compat_features
&
1489 ~QED_COMPAT_FEATURE_MASK
)) {
1493 memcpy(&new_header
, &s
->header
, sizeof(new_header
));
1495 new_header
.features
&= ~(QED_F_BACKING_FILE
|
1496 QED_F_BACKING_FORMAT_NO_PROBE
);
1498 /* Adjust feature flags */
1500 new_header
.features
|= QED_F_BACKING_FILE
;
1502 if (qed_fmt_is_raw(backing_fmt
)) {
1503 new_header
.features
|= QED_F_BACKING_FORMAT_NO_PROBE
;
1507 /* Calculate new header size */
1508 backing_file_len
= 0;
1511 backing_file_len
= strlen(backing_file
);
1514 buffer_len
= sizeof(new_header
);
1515 new_header
.backing_filename_offset
= buffer_len
;
1516 new_header
.backing_filename_size
= backing_file_len
;
1517 buffer_len
+= backing_file_len
;
1519 /* Make sure we can rewrite header without failing */
1520 if (buffer_len
> new_header
.header_size
* new_header
.cluster_size
) {
1524 /* Prepare new header */
1525 buffer
= g_malloc(buffer_len
);
1527 qed_header_cpu_to_le(&new_header
, &le_header
);
1528 memcpy(buffer
, &le_header
, sizeof(le_header
));
1529 buffer_len
= sizeof(le_header
);
1532 memcpy(buffer
+ buffer_len
, backing_file
, backing_file_len
);
1533 buffer_len
+= backing_file_len
;
1536 /* Write new header */
1537 ret
= bdrv_pwrite_sync(bs
->file
, 0, buffer
, buffer_len
);
1540 memcpy(&s
->header
, &new_header
, sizeof(new_header
));
1545 static void bdrv_qed_invalidate_cache(BlockDriverState
*bs
)
1547 BDRVQEDState
*s
= bs
->opaque
;
1550 memset(s
, 0, sizeof(BDRVQEDState
));
1551 bdrv_qed_open(bs
, NULL
, bs
->open_flags
, NULL
);
1554 static int bdrv_qed_check(BlockDriverState
*bs
, BdrvCheckResult
*result
,
1557 BDRVQEDState
*s
= bs
->opaque
;
1559 return qed_check(s
, result
, !!fix
);
1562 static QEMUOptionParameter qed_create_options
[] = {
1564 .name
= BLOCK_OPT_SIZE
,
1566 .help
= "Virtual disk size (in bytes)"
1568 .name
= BLOCK_OPT_BACKING_FILE
,
1570 .help
= "File name of a base image"
1572 .name
= BLOCK_OPT_BACKING_FMT
,
1574 .help
= "Image format of the base image"
1576 .name
= BLOCK_OPT_CLUSTER_SIZE
,
1578 .help
= "Cluster size (in bytes)",
1579 .value
= { .n
= QED_DEFAULT_CLUSTER_SIZE
},
1581 .name
= BLOCK_OPT_TABLE_SIZE
,
1583 .help
= "L1/L2 table size (in clusters)"
1585 { /* end of list */ }
1588 static BlockDriver bdrv_qed
= {
1589 .format_name
= "qed",
1590 .instance_size
= sizeof(BDRVQEDState
),
1591 .create_options
= qed_create_options
,
1593 .bdrv_probe
= bdrv_qed_probe
,
1594 .bdrv_rebind
= bdrv_qed_rebind
,
1595 .bdrv_open
= bdrv_qed_open
,
1596 .bdrv_close
= bdrv_qed_close
,
1597 .bdrv_reopen_prepare
= bdrv_qed_reopen_prepare
,
1598 .bdrv_create
= bdrv_qed_create
,
1599 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
1600 .bdrv_co_get_block_status
= bdrv_qed_co_get_block_status
,
1601 .bdrv_make_empty
= bdrv_qed_make_empty
,
1602 .bdrv_aio_readv
= bdrv_qed_aio_readv
,
1603 .bdrv_aio_writev
= bdrv_qed_aio_writev
,
1604 .bdrv_co_write_zeroes
= bdrv_qed_co_write_zeroes
,
1605 .bdrv_truncate
= bdrv_qed_truncate
,
1606 .bdrv_getlength
= bdrv_qed_getlength
,
1607 .bdrv_get_info
= bdrv_qed_get_info
,
1608 .bdrv_change_backing_file
= bdrv_qed_change_backing_file
,
1609 .bdrv_invalidate_cache
= bdrv_qed_invalidate_cache
,
1610 .bdrv_check
= bdrv_qed_check
,
1613 static void bdrv_qed_init(void)
1615 bdrv_register(&bdrv_qed
);
1618 block_init(bdrv_qed_init
);