175411d23SStefan Hajnoczi /* 275411d23SStefan Hajnoczi * QEMU Enhanced Disk Format 375411d23SStefan Hajnoczi * 475411d23SStefan Hajnoczi * Copyright IBM, Corp. 2010 575411d23SStefan Hajnoczi * 675411d23SStefan Hajnoczi * Authors: 775411d23SStefan Hajnoczi * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> 875411d23SStefan Hajnoczi * Anthony Liguori <aliguori@us.ibm.com> 975411d23SStefan Hajnoczi * 1075411d23SStefan Hajnoczi * This work is licensed under the terms of the GNU LGPL, version 2 or later. 1175411d23SStefan Hajnoczi * See the COPYING.LIB file in the top-level directory. 1275411d23SStefan Hajnoczi * 1375411d23SStefan Hajnoczi */ 1475411d23SStefan Hajnoczi 151de7afc9SPaolo Bonzini #include "qemu/timer.h" 16eabba580SStefan Hajnoczi #include "trace.h" 1775411d23SStefan Hajnoczi #include "qed.h" 187b1b5d19SPaolo Bonzini #include "qapi/qmp/qerror.h" 19caf71f86SPaolo Bonzini #include "migration/migration.h" 2075411d23SStefan Hajnoczi 21eabba580SStefan Hajnoczi static void qed_aio_cancel(BlockDriverAIOCB *blockacb) 22eabba580SStefan Hajnoczi { 23eabba580SStefan Hajnoczi QEDAIOCB *acb = (QEDAIOCB *)blockacb; 24eabba580SStefan Hajnoczi bool finished = false; 25eabba580SStefan Hajnoczi 26eabba580SStefan Hajnoczi /* Wait for the request to finish */ 27eabba580SStefan Hajnoczi acb->finished = &finished; 28eabba580SStefan Hajnoczi while (!finished) { 29eabba580SStefan Hajnoczi qemu_aio_wait(); 30eabba580SStefan Hajnoczi } 31eabba580SStefan Hajnoczi } 32eabba580SStefan Hajnoczi 33d7331bedSStefan Hajnoczi static const AIOCBInfo qed_aiocb_info = { 34eabba580SStefan Hajnoczi .aiocb_size = sizeof(QEDAIOCB), 35eabba580SStefan Hajnoczi .cancel = qed_aio_cancel, 36eabba580SStefan Hajnoczi }; 37eabba580SStefan Hajnoczi 3875411d23SStefan Hajnoczi static int bdrv_qed_probe(const uint8_t *buf, int buf_size, 3975411d23SStefan Hajnoczi const char *filename) 4075411d23SStefan Hajnoczi { 4175411d23SStefan Hajnoczi const QEDHeader *header = (const QEDHeader *)buf; 4275411d23SStefan Hajnoczi 4375411d23SStefan Hajnoczi if (buf_size < sizeof(*header)) { 4475411d23SStefan Hajnoczi return 0; 4575411d23SStefan Hajnoczi } 4675411d23SStefan Hajnoczi if (le32_to_cpu(header->magic) != QED_MAGIC) { 4775411d23SStefan Hajnoczi return 0; 4875411d23SStefan Hajnoczi } 4975411d23SStefan Hajnoczi return 100; 5075411d23SStefan Hajnoczi } 5175411d23SStefan Hajnoczi 5275411d23SStefan Hajnoczi /** 5375411d23SStefan Hajnoczi * Check whether an image format is raw 5475411d23SStefan Hajnoczi * 5575411d23SStefan Hajnoczi * @fmt: Backing file format, may be NULL 5675411d23SStefan Hajnoczi */ 5775411d23SStefan Hajnoczi static bool qed_fmt_is_raw(const char *fmt) 5875411d23SStefan Hajnoczi { 5975411d23SStefan Hajnoczi return fmt && strcmp(fmt, "raw") == 0; 6075411d23SStefan Hajnoczi } 6175411d23SStefan Hajnoczi 6275411d23SStefan Hajnoczi static void qed_header_le_to_cpu(const QEDHeader *le, QEDHeader *cpu) 6375411d23SStefan Hajnoczi { 6475411d23SStefan Hajnoczi cpu->magic = le32_to_cpu(le->magic); 6575411d23SStefan Hajnoczi cpu->cluster_size = le32_to_cpu(le->cluster_size); 6675411d23SStefan Hajnoczi cpu->table_size = le32_to_cpu(le->table_size); 6775411d23SStefan Hajnoczi cpu->header_size = le32_to_cpu(le->header_size); 6875411d23SStefan Hajnoczi cpu->features = le64_to_cpu(le->features); 6975411d23SStefan Hajnoczi cpu->compat_features = le64_to_cpu(le->compat_features); 7075411d23SStefan Hajnoczi cpu->autoclear_features = le64_to_cpu(le->autoclear_features); 7175411d23SStefan Hajnoczi cpu->l1_table_offset = le64_to_cpu(le->l1_table_offset); 7275411d23SStefan Hajnoczi cpu->image_size = le64_to_cpu(le->image_size); 7375411d23SStefan Hajnoczi cpu->backing_filename_offset = le32_to_cpu(le->backing_filename_offset); 7475411d23SStefan Hajnoczi cpu->backing_filename_size = le32_to_cpu(le->backing_filename_size); 7575411d23SStefan Hajnoczi } 7675411d23SStefan Hajnoczi 7775411d23SStefan Hajnoczi static void qed_header_cpu_to_le(const QEDHeader *cpu, QEDHeader *le) 7875411d23SStefan Hajnoczi { 7975411d23SStefan Hajnoczi le->magic = cpu_to_le32(cpu->magic); 8075411d23SStefan Hajnoczi le->cluster_size = cpu_to_le32(cpu->cluster_size); 8175411d23SStefan Hajnoczi le->table_size = cpu_to_le32(cpu->table_size); 8275411d23SStefan Hajnoczi le->header_size = cpu_to_le32(cpu->header_size); 8375411d23SStefan Hajnoczi le->features = cpu_to_le64(cpu->features); 8475411d23SStefan Hajnoczi le->compat_features = cpu_to_le64(cpu->compat_features); 8575411d23SStefan Hajnoczi le->autoclear_features = cpu_to_le64(cpu->autoclear_features); 8675411d23SStefan Hajnoczi le->l1_table_offset = cpu_to_le64(cpu->l1_table_offset); 8775411d23SStefan Hajnoczi le->image_size = cpu_to_le64(cpu->image_size); 8875411d23SStefan Hajnoczi le->backing_filename_offset = cpu_to_le32(cpu->backing_filename_offset); 8975411d23SStefan Hajnoczi le->backing_filename_size = cpu_to_le32(cpu->backing_filename_size); 9075411d23SStefan Hajnoczi } 9175411d23SStefan Hajnoczi 92b10170acSStefan Hajnoczi int qed_write_header_sync(BDRVQEDState *s) 9375411d23SStefan Hajnoczi { 9475411d23SStefan Hajnoczi QEDHeader le; 9575411d23SStefan Hajnoczi int ret; 9675411d23SStefan Hajnoczi 9775411d23SStefan Hajnoczi qed_header_cpu_to_le(&s->header, &le); 9875411d23SStefan Hajnoczi ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le)); 9975411d23SStefan Hajnoczi if (ret != sizeof(le)) { 10075411d23SStefan Hajnoczi return ret; 10175411d23SStefan Hajnoczi } 10275411d23SStefan Hajnoczi return 0; 10375411d23SStefan Hajnoczi } 10475411d23SStefan Hajnoczi 10501979a98SStefan Hajnoczi typedef struct { 10601979a98SStefan Hajnoczi GenericCB gencb; 10701979a98SStefan Hajnoczi BDRVQEDState *s; 10801979a98SStefan Hajnoczi struct iovec iov; 10901979a98SStefan Hajnoczi QEMUIOVector qiov; 11001979a98SStefan Hajnoczi int nsectors; 11101979a98SStefan Hajnoczi uint8_t *buf; 11201979a98SStefan Hajnoczi } QEDWriteHeaderCB; 11301979a98SStefan Hajnoczi 11401979a98SStefan Hajnoczi static void qed_write_header_cb(void *opaque, int ret) 11501979a98SStefan Hajnoczi { 11601979a98SStefan Hajnoczi QEDWriteHeaderCB *write_header_cb = opaque; 11701979a98SStefan Hajnoczi 11801979a98SStefan Hajnoczi qemu_vfree(write_header_cb->buf); 11901979a98SStefan Hajnoczi gencb_complete(write_header_cb, ret); 12001979a98SStefan Hajnoczi } 12101979a98SStefan Hajnoczi 12201979a98SStefan Hajnoczi static void qed_write_header_read_cb(void *opaque, int ret) 12301979a98SStefan Hajnoczi { 12401979a98SStefan Hajnoczi QEDWriteHeaderCB *write_header_cb = opaque; 12501979a98SStefan Hajnoczi BDRVQEDState *s = write_header_cb->s; 12601979a98SStefan Hajnoczi 12701979a98SStefan Hajnoczi if (ret) { 12801979a98SStefan Hajnoczi qed_write_header_cb(write_header_cb, ret); 12901979a98SStefan Hajnoczi return; 13001979a98SStefan Hajnoczi } 13101979a98SStefan Hajnoczi 13201979a98SStefan Hajnoczi /* Update header */ 13301979a98SStefan Hajnoczi qed_header_cpu_to_le(&s->header, (QEDHeader *)write_header_cb->buf); 13401979a98SStefan Hajnoczi 135ad54ae80SPaolo Bonzini bdrv_aio_writev(s->bs->file, 0, &write_header_cb->qiov, 13601979a98SStefan Hajnoczi write_header_cb->nsectors, qed_write_header_cb, 13701979a98SStefan Hajnoczi write_header_cb); 13801979a98SStefan Hajnoczi } 13901979a98SStefan Hajnoczi 14001979a98SStefan Hajnoczi /** 14101979a98SStefan Hajnoczi * Update header in-place (does not rewrite backing filename or other strings) 14201979a98SStefan Hajnoczi * 14301979a98SStefan Hajnoczi * This function only updates known header fields in-place and does not affect 14401979a98SStefan Hajnoczi * extra data after the QED header. 14501979a98SStefan Hajnoczi */ 14601979a98SStefan Hajnoczi static void qed_write_header(BDRVQEDState *s, BlockDriverCompletionFunc cb, 14701979a98SStefan Hajnoczi void *opaque) 14801979a98SStefan Hajnoczi { 14901979a98SStefan Hajnoczi /* We must write full sectors for O_DIRECT but cannot necessarily generate 15001979a98SStefan Hajnoczi * the data following the header if an unrecognized compat feature is 15101979a98SStefan Hajnoczi * active. Therefore, first read the sectors containing the header, update 15201979a98SStefan Hajnoczi * them, and write back. 15301979a98SStefan Hajnoczi */ 15401979a98SStefan Hajnoczi 15501979a98SStefan Hajnoczi int nsectors = (sizeof(QEDHeader) + BDRV_SECTOR_SIZE - 1) / 15601979a98SStefan Hajnoczi BDRV_SECTOR_SIZE; 15701979a98SStefan Hajnoczi size_t len = nsectors * BDRV_SECTOR_SIZE; 15801979a98SStefan Hajnoczi QEDWriteHeaderCB *write_header_cb = gencb_alloc(sizeof(*write_header_cb), 15901979a98SStefan Hajnoczi cb, opaque); 16001979a98SStefan Hajnoczi 16101979a98SStefan Hajnoczi write_header_cb->s = s; 16201979a98SStefan Hajnoczi write_header_cb->nsectors = nsectors; 16301979a98SStefan Hajnoczi write_header_cb->buf = qemu_blockalign(s->bs, len); 16401979a98SStefan Hajnoczi write_header_cb->iov.iov_base = write_header_cb->buf; 16501979a98SStefan Hajnoczi write_header_cb->iov.iov_len = len; 16601979a98SStefan Hajnoczi qemu_iovec_init_external(&write_header_cb->qiov, &write_header_cb->iov, 1); 16701979a98SStefan Hajnoczi 168ad54ae80SPaolo Bonzini bdrv_aio_readv(s->bs->file, 0, &write_header_cb->qiov, nsectors, 16901979a98SStefan Hajnoczi qed_write_header_read_cb, write_header_cb); 17001979a98SStefan Hajnoczi } 17101979a98SStefan Hajnoczi 17275411d23SStefan Hajnoczi static uint64_t qed_max_image_size(uint32_t cluster_size, uint32_t table_size) 17375411d23SStefan Hajnoczi { 17475411d23SStefan Hajnoczi uint64_t table_entries; 17575411d23SStefan Hajnoczi uint64_t l2_size; 17675411d23SStefan Hajnoczi 17775411d23SStefan Hajnoczi table_entries = (table_size * cluster_size) / sizeof(uint64_t); 17875411d23SStefan Hajnoczi l2_size = table_entries * cluster_size; 17975411d23SStefan Hajnoczi 18075411d23SStefan Hajnoczi return l2_size * table_entries; 18175411d23SStefan Hajnoczi } 18275411d23SStefan Hajnoczi 18375411d23SStefan Hajnoczi static bool qed_is_cluster_size_valid(uint32_t cluster_size) 18475411d23SStefan Hajnoczi { 18575411d23SStefan Hajnoczi if (cluster_size < QED_MIN_CLUSTER_SIZE || 18675411d23SStefan Hajnoczi cluster_size > QED_MAX_CLUSTER_SIZE) { 18775411d23SStefan Hajnoczi return false; 18875411d23SStefan Hajnoczi } 18975411d23SStefan Hajnoczi if (cluster_size & (cluster_size - 1)) { 19075411d23SStefan Hajnoczi return false; /* not power of 2 */ 19175411d23SStefan Hajnoczi } 19275411d23SStefan Hajnoczi return true; 19375411d23SStefan Hajnoczi } 19475411d23SStefan Hajnoczi 19575411d23SStefan Hajnoczi static bool qed_is_table_size_valid(uint32_t table_size) 19675411d23SStefan Hajnoczi { 19775411d23SStefan Hajnoczi if (table_size < QED_MIN_TABLE_SIZE || 19875411d23SStefan Hajnoczi table_size > QED_MAX_TABLE_SIZE) { 19975411d23SStefan Hajnoczi return false; 20075411d23SStefan Hajnoczi } 20175411d23SStefan Hajnoczi if (table_size & (table_size - 1)) { 20275411d23SStefan Hajnoczi return false; /* not power of 2 */ 20375411d23SStefan Hajnoczi } 20475411d23SStefan Hajnoczi return true; 20575411d23SStefan Hajnoczi } 20675411d23SStefan Hajnoczi 20775411d23SStefan Hajnoczi static bool qed_is_image_size_valid(uint64_t image_size, uint32_t cluster_size, 20875411d23SStefan Hajnoczi uint32_t table_size) 20975411d23SStefan Hajnoczi { 21075411d23SStefan Hajnoczi if (image_size % BDRV_SECTOR_SIZE != 0) { 21175411d23SStefan Hajnoczi return false; /* not multiple of sector size */ 21275411d23SStefan Hajnoczi } 21375411d23SStefan Hajnoczi if (image_size > qed_max_image_size(cluster_size, table_size)) { 21475411d23SStefan Hajnoczi return false; /* image is too large */ 21575411d23SStefan Hajnoczi } 21675411d23SStefan Hajnoczi return true; 21775411d23SStefan Hajnoczi } 21875411d23SStefan Hajnoczi 21975411d23SStefan Hajnoczi /** 22075411d23SStefan Hajnoczi * Read a string of known length from the image file 22175411d23SStefan Hajnoczi * 22275411d23SStefan Hajnoczi * @file: Image file 22375411d23SStefan Hajnoczi * @offset: File offset to start of string, in bytes 22475411d23SStefan Hajnoczi * @n: String length in bytes 22575411d23SStefan Hajnoczi * @buf: Destination buffer 22675411d23SStefan Hajnoczi * @buflen: Destination buffer length in bytes 22775411d23SStefan Hajnoczi * @ret: 0 on success, -errno on failure 22875411d23SStefan Hajnoczi * 22975411d23SStefan Hajnoczi * The string is NUL-terminated. 23075411d23SStefan Hajnoczi */ 23175411d23SStefan Hajnoczi static int qed_read_string(BlockDriverState *file, uint64_t offset, size_t n, 23275411d23SStefan Hajnoczi char *buf, size_t buflen) 23375411d23SStefan Hajnoczi { 23475411d23SStefan Hajnoczi int ret; 23575411d23SStefan Hajnoczi if (n >= buflen) { 23675411d23SStefan Hajnoczi return -EINVAL; 23775411d23SStefan Hajnoczi } 23875411d23SStefan Hajnoczi ret = bdrv_pread(file, offset, buf, n); 23975411d23SStefan Hajnoczi if (ret < 0) { 24075411d23SStefan Hajnoczi return ret; 24175411d23SStefan Hajnoczi } 24275411d23SStefan Hajnoczi buf[n] = '\0'; 24375411d23SStefan Hajnoczi return 0; 24475411d23SStefan Hajnoczi } 24575411d23SStefan Hajnoczi 246eabba580SStefan Hajnoczi /** 247eabba580SStefan Hajnoczi * Allocate new clusters 248eabba580SStefan Hajnoczi * 249eabba580SStefan Hajnoczi * @s: QED state 250eabba580SStefan Hajnoczi * @n: Number of contiguous clusters to allocate 251eabba580SStefan Hajnoczi * @ret: Offset of first allocated cluster 252eabba580SStefan Hajnoczi * 253eabba580SStefan Hajnoczi * This function only produces the offset where the new clusters should be 254eabba580SStefan Hajnoczi * written. It updates BDRVQEDState but does not make any changes to the image 255eabba580SStefan Hajnoczi * file. 256eabba580SStefan Hajnoczi */ 257eabba580SStefan Hajnoczi static uint64_t qed_alloc_clusters(BDRVQEDState *s, unsigned int n) 258eabba580SStefan Hajnoczi { 259eabba580SStefan Hajnoczi uint64_t offset = s->file_size; 260eabba580SStefan Hajnoczi s->file_size += n * s->header.cluster_size; 261eabba580SStefan Hajnoczi return offset; 262eabba580SStefan Hajnoczi } 263eabba580SStefan Hajnoczi 264298800caSStefan Hajnoczi QEDTable *qed_alloc_table(BDRVQEDState *s) 265298800caSStefan Hajnoczi { 266298800caSStefan Hajnoczi /* Honor O_DIRECT memory alignment requirements */ 267298800caSStefan Hajnoczi return qemu_blockalign(s->bs, 268298800caSStefan Hajnoczi s->header.cluster_size * s->header.table_size); 269298800caSStefan Hajnoczi } 270298800caSStefan Hajnoczi 271eabba580SStefan Hajnoczi /** 272eabba580SStefan Hajnoczi * Allocate a new zeroed L2 table 273eabba580SStefan Hajnoczi */ 274eabba580SStefan Hajnoczi static CachedL2Table *qed_new_l2_table(BDRVQEDState *s) 275eabba580SStefan Hajnoczi { 276eabba580SStefan Hajnoczi CachedL2Table *l2_table = qed_alloc_l2_cache_entry(&s->l2_cache); 277eabba580SStefan Hajnoczi 278eabba580SStefan Hajnoczi l2_table->table = qed_alloc_table(s); 279eabba580SStefan Hajnoczi l2_table->offset = qed_alloc_clusters(s, s->header.table_size); 280eabba580SStefan Hajnoczi 281eabba580SStefan Hajnoczi memset(l2_table->table->offsets, 0, 282eabba580SStefan Hajnoczi s->header.cluster_size * s->header.table_size); 283eabba580SStefan Hajnoczi return l2_table; 284eabba580SStefan Hajnoczi } 285eabba580SStefan Hajnoczi 286eabba580SStefan Hajnoczi static void qed_aio_next_io(void *opaque, int ret); 287eabba580SStefan Hajnoczi 2886f321e93SStefan Hajnoczi static void qed_plug_allocating_write_reqs(BDRVQEDState *s) 2896f321e93SStefan Hajnoczi { 2906f321e93SStefan Hajnoczi assert(!s->allocating_write_reqs_plugged); 2916f321e93SStefan Hajnoczi 2926f321e93SStefan Hajnoczi s->allocating_write_reqs_plugged = true; 2936f321e93SStefan Hajnoczi } 2946f321e93SStefan Hajnoczi 2956f321e93SStefan Hajnoczi static void qed_unplug_allocating_write_reqs(BDRVQEDState *s) 2966f321e93SStefan Hajnoczi { 2976f321e93SStefan Hajnoczi QEDAIOCB *acb; 2986f321e93SStefan Hajnoczi 2996f321e93SStefan Hajnoczi assert(s->allocating_write_reqs_plugged); 3006f321e93SStefan Hajnoczi 3016f321e93SStefan Hajnoczi s->allocating_write_reqs_plugged = false; 3026f321e93SStefan Hajnoczi 3036f321e93SStefan Hajnoczi acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs); 3046f321e93SStefan Hajnoczi if (acb) { 3056f321e93SStefan Hajnoczi qed_aio_next_io(acb, 0); 3066f321e93SStefan Hajnoczi } 3076f321e93SStefan Hajnoczi } 3086f321e93SStefan Hajnoczi 3096f321e93SStefan Hajnoczi static void qed_finish_clear_need_check(void *opaque, int ret) 3106f321e93SStefan Hajnoczi { 3116f321e93SStefan Hajnoczi /* Do nothing */ 3126f321e93SStefan Hajnoczi } 3136f321e93SStefan Hajnoczi 3146f321e93SStefan Hajnoczi static void qed_flush_after_clear_need_check(void *opaque, int ret) 3156f321e93SStefan Hajnoczi { 3166f321e93SStefan Hajnoczi BDRVQEDState *s = opaque; 3176f321e93SStefan Hajnoczi 3186f321e93SStefan Hajnoczi bdrv_aio_flush(s->bs, qed_finish_clear_need_check, s); 3196f321e93SStefan Hajnoczi 3206f321e93SStefan Hajnoczi /* No need to wait until flush completes */ 3216f321e93SStefan Hajnoczi qed_unplug_allocating_write_reqs(s); 3226f321e93SStefan Hajnoczi } 3236f321e93SStefan Hajnoczi 3246f321e93SStefan Hajnoczi static void qed_clear_need_check(void *opaque, int ret) 3256f321e93SStefan Hajnoczi { 3266f321e93SStefan Hajnoczi BDRVQEDState *s = opaque; 3276f321e93SStefan Hajnoczi 3286f321e93SStefan Hajnoczi if (ret) { 3296f321e93SStefan Hajnoczi qed_unplug_allocating_write_reqs(s); 3306f321e93SStefan Hajnoczi return; 3316f321e93SStefan Hajnoczi } 3326f321e93SStefan Hajnoczi 3336f321e93SStefan Hajnoczi s->header.features &= ~QED_F_NEED_CHECK; 3346f321e93SStefan Hajnoczi qed_write_header(s, qed_flush_after_clear_need_check, s); 3356f321e93SStefan Hajnoczi } 3366f321e93SStefan Hajnoczi 3376f321e93SStefan Hajnoczi static void qed_need_check_timer_cb(void *opaque) 3386f321e93SStefan Hajnoczi { 3396f321e93SStefan Hajnoczi BDRVQEDState *s = opaque; 3406f321e93SStefan Hajnoczi 3416f321e93SStefan Hajnoczi /* The timer should only fire when allocating writes have drained */ 3426f321e93SStefan Hajnoczi assert(!QSIMPLEQ_FIRST(&s->allocating_write_reqs)); 3436f321e93SStefan Hajnoczi 3446f321e93SStefan Hajnoczi trace_qed_need_check_timer_cb(s); 3456f321e93SStefan Hajnoczi 3466f321e93SStefan Hajnoczi qed_plug_allocating_write_reqs(s); 3476f321e93SStefan Hajnoczi 3486f321e93SStefan Hajnoczi /* Ensure writes are on disk before clearing flag */ 3496f321e93SStefan Hajnoczi bdrv_aio_flush(s->bs, qed_clear_need_check, s); 3506f321e93SStefan Hajnoczi } 3516f321e93SStefan Hajnoczi 3526f321e93SStefan Hajnoczi static void qed_start_need_check_timer(BDRVQEDState *s) 3536f321e93SStefan Hajnoczi { 3546f321e93SStefan Hajnoczi trace_qed_start_need_check_timer(s); 3556f321e93SStefan Hajnoczi 356bc72ad67SAlex Bligh /* Use QEMU_CLOCK_VIRTUAL so we don't alter the image file while suspended for 3576f321e93SStefan Hajnoczi * migration. 3586f321e93SStefan Hajnoczi */ 359bc72ad67SAlex Bligh timer_mod(s->need_check_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 3606f321e93SStefan Hajnoczi get_ticks_per_sec() * QED_NEED_CHECK_TIMEOUT); 3616f321e93SStefan Hajnoczi } 3626f321e93SStefan Hajnoczi 3636f321e93SStefan Hajnoczi /* It's okay to call this multiple times or when no timer is started */ 3646f321e93SStefan Hajnoczi static void qed_cancel_need_check_timer(BDRVQEDState *s) 3656f321e93SStefan Hajnoczi { 3666f321e93SStefan Hajnoczi trace_qed_cancel_need_check_timer(s); 367bc72ad67SAlex Bligh timer_del(s->need_check_timer); 3686f321e93SStefan Hajnoczi } 3696f321e93SStefan Hajnoczi 370e023b2e2SPaolo Bonzini static void bdrv_qed_rebind(BlockDriverState *bs) 371e023b2e2SPaolo Bonzini { 372e023b2e2SPaolo Bonzini BDRVQEDState *s = bs->opaque; 373e023b2e2SPaolo Bonzini s->bs = bs; 374e023b2e2SPaolo Bonzini } 375e023b2e2SPaolo Bonzini 376015a1036SMax Reitz static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags, 377015a1036SMax Reitz Error **errp) 37875411d23SStefan Hajnoczi { 37975411d23SStefan Hajnoczi BDRVQEDState *s = bs->opaque; 38075411d23SStefan Hajnoczi QEDHeader le_header; 38175411d23SStefan Hajnoczi int64_t file_size; 38275411d23SStefan Hajnoczi int ret; 38375411d23SStefan Hajnoczi 38475411d23SStefan Hajnoczi s->bs = bs; 385eabba580SStefan Hajnoczi QSIMPLEQ_INIT(&s->allocating_write_reqs); 38675411d23SStefan Hajnoczi 38775411d23SStefan Hajnoczi ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header)); 38875411d23SStefan Hajnoczi if (ret < 0) { 38975411d23SStefan Hajnoczi return ret; 39075411d23SStefan Hajnoczi } 39175411d23SStefan Hajnoczi qed_header_le_to_cpu(&le_header, &s->header); 39275411d23SStefan Hajnoczi 39375411d23SStefan Hajnoczi if (s->header.magic != QED_MAGIC) { 39476abe407SPaolo Bonzini error_setg(errp, "Image not in QED format"); 39576abe407SPaolo Bonzini return -EINVAL; 39675411d23SStefan Hajnoczi } 39775411d23SStefan Hajnoczi if (s->header.features & ~QED_FEATURE_MASK) { 39810b758e8SKevin Wolf /* image uses unsupported feature bits */ 39910b758e8SKevin Wolf char buf[64]; 40010b758e8SKevin Wolf snprintf(buf, sizeof(buf), "%" PRIx64, 40110b758e8SKevin Wolf s->header.features & ~QED_FEATURE_MASK); 4020fea6b79SPaolo Bonzini error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, 40310b758e8SKevin Wolf bs->device_name, "QED", buf); 40410b758e8SKevin Wolf return -ENOTSUP; 40575411d23SStefan Hajnoczi } 40675411d23SStefan Hajnoczi if (!qed_is_cluster_size_valid(s->header.cluster_size)) { 40775411d23SStefan Hajnoczi return -EINVAL; 40875411d23SStefan Hajnoczi } 40975411d23SStefan Hajnoczi 41075411d23SStefan Hajnoczi /* Round down file size to the last cluster */ 41175411d23SStefan Hajnoczi file_size = bdrv_getlength(bs->file); 41275411d23SStefan Hajnoczi if (file_size < 0) { 41375411d23SStefan Hajnoczi return file_size; 41475411d23SStefan Hajnoczi } 41575411d23SStefan Hajnoczi s->file_size = qed_start_of_cluster(s, file_size); 41675411d23SStefan Hajnoczi 41775411d23SStefan Hajnoczi if (!qed_is_table_size_valid(s->header.table_size)) { 41875411d23SStefan Hajnoczi return -EINVAL; 41975411d23SStefan Hajnoczi } 42075411d23SStefan Hajnoczi if (!qed_is_image_size_valid(s->header.image_size, 42175411d23SStefan Hajnoczi s->header.cluster_size, 42275411d23SStefan Hajnoczi s->header.table_size)) { 42375411d23SStefan Hajnoczi return -EINVAL; 42475411d23SStefan Hajnoczi } 42575411d23SStefan Hajnoczi if (!qed_check_table_offset(s, s->header.l1_table_offset)) { 42675411d23SStefan Hajnoczi return -EINVAL; 42775411d23SStefan Hajnoczi } 42875411d23SStefan Hajnoczi 42975411d23SStefan Hajnoczi s->table_nelems = (s->header.cluster_size * s->header.table_size) / 43075411d23SStefan Hajnoczi sizeof(uint64_t); 43175411d23SStefan Hajnoczi s->l2_shift = ffs(s->header.cluster_size) - 1; 43275411d23SStefan Hajnoczi s->l2_mask = s->table_nelems - 1; 43375411d23SStefan Hajnoczi s->l1_shift = s->l2_shift + ffs(s->table_nelems) - 1; 43475411d23SStefan Hajnoczi 43575411d23SStefan Hajnoczi if ((s->header.features & QED_F_BACKING_FILE)) { 43675411d23SStefan Hajnoczi if ((uint64_t)s->header.backing_filename_offset + 43775411d23SStefan Hajnoczi s->header.backing_filename_size > 43875411d23SStefan Hajnoczi s->header.cluster_size * s->header.header_size) { 43975411d23SStefan Hajnoczi return -EINVAL; 44075411d23SStefan Hajnoczi } 44175411d23SStefan Hajnoczi 44275411d23SStefan Hajnoczi ret = qed_read_string(bs->file, s->header.backing_filename_offset, 44375411d23SStefan Hajnoczi s->header.backing_filename_size, bs->backing_file, 44475411d23SStefan Hajnoczi sizeof(bs->backing_file)); 44575411d23SStefan Hajnoczi if (ret < 0) { 44675411d23SStefan Hajnoczi return ret; 44775411d23SStefan Hajnoczi } 44875411d23SStefan Hajnoczi 44975411d23SStefan Hajnoczi if (s->header.features & QED_F_BACKING_FORMAT_NO_PROBE) { 45075411d23SStefan Hajnoczi pstrcpy(bs->backing_format, sizeof(bs->backing_format), "raw"); 45175411d23SStefan Hajnoczi } 45275411d23SStefan Hajnoczi } 45375411d23SStefan Hajnoczi 45475411d23SStefan Hajnoczi /* Reset unknown autoclear feature bits. This is a backwards 45575411d23SStefan Hajnoczi * compatibility mechanism that allows images to be opened by older 45675411d23SStefan Hajnoczi * programs, which "knock out" unknown feature bits. When an image is 45775411d23SStefan Hajnoczi * opened by a newer program again it can detect that the autoclear 45875411d23SStefan Hajnoczi * feature is no longer valid. 45975411d23SStefan Hajnoczi */ 46075411d23SStefan Hajnoczi if ((s->header.autoclear_features & ~QED_AUTOCLEAR_FEATURE_MASK) != 0 && 4612d1f3c23SBenoît Canet !bdrv_is_read_only(bs->file) && !(flags & BDRV_O_INCOMING)) { 46275411d23SStefan Hajnoczi s->header.autoclear_features &= QED_AUTOCLEAR_FEATURE_MASK; 46375411d23SStefan Hajnoczi 46475411d23SStefan Hajnoczi ret = qed_write_header_sync(s); 46575411d23SStefan Hajnoczi if (ret) { 46675411d23SStefan Hajnoczi return ret; 46775411d23SStefan Hajnoczi } 46875411d23SStefan Hajnoczi 46975411d23SStefan Hajnoczi /* From here on only known autoclear feature bits are valid */ 47075411d23SStefan Hajnoczi bdrv_flush(bs->file); 47175411d23SStefan Hajnoczi } 47275411d23SStefan Hajnoczi 473298800caSStefan Hajnoczi s->l1_table = qed_alloc_table(s); 474298800caSStefan Hajnoczi qed_init_l2_cache(&s->l2_cache); 475298800caSStefan Hajnoczi 476298800caSStefan Hajnoczi ret = qed_read_l1_table_sync(s); 477298800caSStefan Hajnoczi if (ret) { 47801979a98SStefan Hajnoczi goto out; 47901979a98SStefan Hajnoczi } 48001979a98SStefan Hajnoczi 48101979a98SStefan Hajnoczi /* If image was not closed cleanly, check consistency */ 482058f8f16SStefan Hajnoczi if (!(flags & BDRV_O_CHECK) && (s->header.features & QED_F_NEED_CHECK)) { 48301979a98SStefan Hajnoczi /* Read-only images cannot be fixed. There is no risk of corruption 48401979a98SStefan Hajnoczi * since write operations are not possible. Therefore, allow 48501979a98SStefan Hajnoczi * potentially inconsistent images to be opened read-only. This can 48601979a98SStefan Hajnoczi * aid data recovery from an otherwise inconsistent image. 48701979a98SStefan Hajnoczi */ 4882d1f3c23SBenoît Canet if (!bdrv_is_read_only(bs->file) && 4892d1f3c23SBenoît Canet !(flags & BDRV_O_INCOMING)) { 49001979a98SStefan Hajnoczi BdrvCheckResult result = {0}; 49101979a98SStefan Hajnoczi 49201979a98SStefan Hajnoczi ret = qed_check(s, &result, true); 4936f321e93SStefan Hajnoczi if (ret) { 4946f321e93SStefan Hajnoczi goto out; 4956f321e93SStefan Hajnoczi } 49601979a98SStefan Hajnoczi } 49701979a98SStefan Hajnoczi } 49801979a98SStefan Hajnoczi 499bc72ad67SAlex Bligh s->need_check_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, 5006f321e93SStefan Hajnoczi qed_need_check_timer_cb, s); 5016f321e93SStefan Hajnoczi 50201979a98SStefan Hajnoczi out: 50301979a98SStefan Hajnoczi if (ret) { 504298800caSStefan Hajnoczi qed_free_l2_cache(&s->l2_cache); 505298800caSStefan Hajnoczi qemu_vfree(s->l1_table); 506298800caSStefan Hajnoczi } 50775411d23SStefan Hajnoczi return ret; 50875411d23SStefan Hajnoczi } 50975411d23SStefan Hajnoczi 510d34682cdSKevin Wolf static int bdrv_qed_refresh_limits(BlockDriverState *bs) 511d34682cdSKevin Wolf { 512d34682cdSKevin Wolf BDRVQEDState *s = bs->opaque; 513d34682cdSKevin Wolf 514d34682cdSKevin Wolf bs->bl.write_zeroes_alignment = s->header.cluster_size >> BDRV_SECTOR_BITS; 515d34682cdSKevin Wolf 516d34682cdSKevin Wolf return 0; 517d34682cdSKevin Wolf } 518d34682cdSKevin Wolf 519f9cb20f1SJeff Cody /* We have nothing to do for QED reopen, stubs just return 520f9cb20f1SJeff Cody * success */ 521f9cb20f1SJeff Cody static int bdrv_qed_reopen_prepare(BDRVReopenState *state, 522f9cb20f1SJeff Cody BlockReopenQueue *queue, Error **errp) 523f9cb20f1SJeff Cody { 524f9cb20f1SJeff Cody return 0; 525f9cb20f1SJeff Cody } 526f9cb20f1SJeff Cody 52775411d23SStefan Hajnoczi static void bdrv_qed_close(BlockDriverState *bs) 52875411d23SStefan Hajnoczi { 529298800caSStefan Hajnoczi BDRVQEDState *s = bs->opaque; 530298800caSStefan Hajnoczi 5316f321e93SStefan Hajnoczi qed_cancel_need_check_timer(s); 532bc72ad67SAlex Bligh timer_free(s->need_check_timer); 5336f321e93SStefan Hajnoczi 53401979a98SStefan Hajnoczi /* Ensure writes reach stable storage */ 53501979a98SStefan Hajnoczi bdrv_flush(bs->file); 53601979a98SStefan Hajnoczi 53701979a98SStefan Hajnoczi /* Clean shutdown, no check required on next open */ 53801979a98SStefan Hajnoczi if (s->header.features & QED_F_NEED_CHECK) { 53901979a98SStefan Hajnoczi s->header.features &= ~QED_F_NEED_CHECK; 54001979a98SStefan Hajnoczi qed_write_header_sync(s); 54101979a98SStefan Hajnoczi } 54201979a98SStefan Hajnoczi 543298800caSStefan Hajnoczi qed_free_l2_cache(&s->l2_cache); 544298800caSStefan Hajnoczi qemu_vfree(s->l1_table); 54575411d23SStefan Hajnoczi } 54675411d23SStefan Hajnoczi 54775411d23SStefan Hajnoczi static int qed_create(const char *filename, uint32_t cluster_size, 54875411d23SStefan Hajnoczi uint64_t image_size, uint32_t table_size, 5490fea6b79SPaolo Bonzini const char *backing_file, const char *backing_fmt, 5500fea6b79SPaolo Bonzini Error **errp) 55175411d23SStefan Hajnoczi { 55275411d23SStefan Hajnoczi QEDHeader header = { 55375411d23SStefan Hajnoczi .magic = QED_MAGIC, 55475411d23SStefan Hajnoczi .cluster_size = cluster_size, 55575411d23SStefan Hajnoczi .table_size = table_size, 55675411d23SStefan Hajnoczi .header_size = 1, 55775411d23SStefan Hajnoczi .features = 0, 55875411d23SStefan Hajnoczi .compat_features = 0, 55975411d23SStefan Hajnoczi .l1_table_offset = cluster_size, 56075411d23SStefan Hajnoczi .image_size = image_size, 56175411d23SStefan Hajnoczi }; 56275411d23SStefan Hajnoczi QEDHeader le_header; 56375411d23SStefan Hajnoczi uint8_t *l1_table = NULL; 56475411d23SStefan Hajnoczi size_t l1_size = header.cluster_size * header.table_size; 56534b5d2c6SMax Reitz Error *local_err = NULL; 56675411d23SStefan Hajnoczi int ret = 0; 5672e40134bSMax Reitz BlockDriverState *bs; 56875411d23SStefan Hajnoczi 569cc84d90fSMax Reitz ret = bdrv_create_file(filename, NULL, &local_err); 57075411d23SStefan Hajnoczi if (ret < 0) { 5710fea6b79SPaolo Bonzini error_propagate(errp, local_err); 57275411d23SStefan Hajnoczi return ret; 57375411d23SStefan Hajnoczi } 57475411d23SStefan Hajnoczi 5752e40134bSMax Reitz bs = NULL; 5762e40134bSMax Reitz ret = bdrv_open(&bs, filename, NULL, NULL, 5772e40134bSMax Reitz BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_PROTOCOL, NULL, 5782e40134bSMax Reitz &local_err); 57975411d23SStefan Hajnoczi if (ret < 0) { 5800fea6b79SPaolo Bonzini error_propagate(errp, local_err); 58175411d23SStefan Hajnoczi return ret; 58275411d23SStefan Hajnoczi } 58375411d23SStefan Hajnoczi 584c743849bSStefan Hajnoczi /* File must start empty and grow, check truncate is supported */ 585c743849bSStefan Hajnoczi ret = bdrv_truncate(bs, 0); 586c743849bSStefan Hajnoczi if (ret < 0) { 587c743849bSStefan Hajnoczi goto out; 588c743849bSStefan Hajnoczi } 589c743849bSStefan Hajnoczi 59075411d23SStefan Hajnoczi if (backing_file) { 59175411d23SStefan Hajnoczi header.features |= QED_F_BACKING_FILE; 59275411d23SStefan Hajnoczi header.backing_filename_offset = sizeof(le_header); 59375411d23SStefan Hajnoczi header.backing_filename_size = strlen(backing_file); 59475411d23SStefan Hajnoczi 59575411d23SStefan Hajnoczi if (qed_fmt_is_raw(backing_fmt)) { 59675411d23SStefan Hajnoczi header.features |= QED_F_BACKING_FORMAT_NO_PROBE; 59775411d23SStefan Hajnoczi } 59875411d23SStefan Hajnoczi } 59975411d23SStefan Hajnoczi 60075411d23SStefan Hajnoczi qed_header_cpu_to_le(&header, &le_header); 60175411d23SStefan Hajnoczi ret = bdrv_pwrite(bs, 0, &le_header, sizeof(le_header)); 60275411d23SStefan Hajnoczi if (ret < 0) { 60375411d23SStefan Hajnoczi goto out; 60475411d23SStefan Hajnoczi } 60575411d23SStefan Hajnoczi ret = bdrv_pwrite(bs, sizeof(le_header), backing_file, 60675411d23SStefan Hajnoczi header.backing_filename_size); 60775411d23SStefan Hajnoczi if (ret < 0) { 60875411d23SStefan Hajnoczi goto out; 60975411d23SStefan Hajnoczi } 61075411d23SStefan Hajnoczi 6117267c094SAnthony Liguori l1_table = g_malloc0(l1_size); 61275411d23SStefan Hajnoczi ret = bdrv_pwrite(bs, header.l1_table_offset, l1_table, l1_size); 61375411d23SStefan Hajnoczi if (ret < 0) { 61475411d23SStefan Hajnoczi goto out; 61575411d23SStefan Hajnoczi } 61675411d23SStefan Hajnoczi 61775411d23SStefan Hajnoczi ret = 0; /* success */ 61875411d23SStefan Hajnoczi out: 6197267c094SAnthony Liguori g_free(l1_table); 6204f6fd349SFam Zheng bdrv_unref(bs); 62175411d23SStefan Hajnoczi return ret; 62275411d23SStefan Hajnoczi } 62375411d23SStefan Hajnoczi 624d5124c00SMax Reitz static int bdrv_qed_create(const char *filename, QEMUOptionParameter *options, 625d5124c00SMax Reitz Error **errp) 62675411d23SStefan Hajnoczi { 62775411d23SStefan Hajnoczi uint64_t image_size = 0; 62875411d23SStefan Hajnoczi uint32_t cluster_size = QED_DEFAULT_CLUSTER_SIZE; 62975411d23SStefan Hajnoczi uint32_t table_size = QED_DEFAULT_TABLE_SIZE; 63075411d23SStefan Hajnoczi const char *backing_file = NULL; 63175411d23SStefan Hajnoczi const char *backing_fmt = NULL; 63275411d23SStefan Hajnoczi 63375411d23SStefan Hajnoczi while (options && options->name) { 63475411d23SStefan Hajnoczi if (!strcmp(options->name, BLOCK_OPT_SIZE)) { 63575411d23SStefan Hajnoczi image_size = options->value.n; 63675411d23SStefan Hajnoczi } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { 63775411d23SStefan Hajnoczi backing_file = options->value.s; 63875411d23SStefan Hajnoczi } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) { 63975411d23SStefan Hajnoczi backing_fmt = options->value.s; 64075411d23SStefan Hajnoczi } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { 64175411d23SStefan Hajnoczi if (options->value.n) { 64275411d23SStefan Hajnoczi cluster_size = options->value.n; 64375411d23SStefan Hajnoczi } 64475411d23SStefan Hajnoczi } else if (!strcmp(options->name, BLOCK_OPT_TABLE_SIZE)) { 64575411d23SStefan Hajnoczi if (options->value.n) { 64675411d23SStefan Hajnoczi table_size = options->value.n; 64775411d23SStefan Hajnoczi } 64875411d23SStefan Hajnoczi } 64975411d23SStefan Hajnoczi options++; 65075411d23SStefan Hajnoczi } 65175411d23SStefan Hajnoczi 65275411d23SStefan Hajnoczi if (!qed_is_cluster_size_valid(cluster_size)) { 653*5ff679b4SAakriti Gupta error_setg(errp, "QED cluster size must be within range [%u, %u] " 654*5ff679b4SAakriti Gupta "and power of 2", 65575411d23SStefan Hajnoczi QED_MIN_CLUSTER_SIZE, QED_MAX_CLUSTER_SIZE); 65675411d23SStefan Hajnoczi return -EINVAL; 65775411d23SStefan Hajnoczi } 65875411d23SStefan Hajnoczi if (!qed_is_table_size_valid(table_size)) { 659*5ff679b4SAakriti Gupta error_setg(errp, "QED table size must be within range [%u, %u] " 660*5ff679b4SAakriti Gupta "and power of 2", 66175411d23SStefan Hajnoczi QED_MIN_TABLE_SIZE, QED_MAX_TABLE_SIZE); 66275411d23SStefan Hajnoczi return -EINVAL; 66375411d23SStefan Hajnoczi } 66475411d23SStefan Hajnoczi if (!qed_is_image_size_valid(image_size, cluster_size, table_size)) { 665*5ff679b4SAakriti Gupta error_setg(errp, "QED image size must be a non-zero multiple of " 666*5ff679b4SAakriti Gupta "cluster size and less than %" PRIu64 " bytes", 66775411d23SStefan Hajnoczi qed_max_image_size(cluster_size, table_size)); 66875411d23SStefan Hajnoczi return -EINVAL; 66975411d23SStefan Hajnoczi } 67075411d23SStefan Hajnoczi 67175411d23SStefan Hajnoczi return qed_create(filename, cluster_size, image_size, table_size, 6720fea6b79SPaolo Bonzini backing_file, backing_fmt, errp); 67375411d23SStefan Hajnoczi } 67475411d23SStefan Hajnoczi 675298800caSStefan Hajnoczi typedef struct { 6764bc74be9SPaolo Bonzini BlockDriverState *bs; 677b7d5a5b8SStefan Hajnoczi Coroutine *co; 6784bc74be9SPaolo Bonzini uint64_t pos; 6794bc74be9SPaolo Bonzini int64_t status; 680298800caSStefan Hajnoczi int *pnum; 681298800caSStefan Hajnoczi } QEDIsAllocatedCB; 682298800caSStefan Hajnoczi 683298800caSStefan Hajnoczi static void qed_is_allocated_cb(void *opaque, int ret, uint64_t offset, size_t len) 684298800caSStefan Hajnoczi { 685298800caSStefan Hajnoczi QEDIsAllocatedCB *cb = opaque; 6864bc74be9SPaolo Bonzini BDRVQEDState *s = cb->bs->opaque; 687298800caSStefan Hajnoczi *cb->pnum = len / BDRV_SECTOR_SIZE; 6884bc74be9SPaolo Bonzini switch (ret) { 6894bc74be9SPaolo Bonzini case QED_CLUSTER_FOUND: 6904bc74be9SPaolo Bonzini offset |= qed_offset_into_cluster(s, cb->pos); 6914bc74be9SPaolo Bonzini cb->status = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | offset; 6924bc74be9SPaolo Bonzini break; 6934bc74be9SPaolo Bonzini case QED_CLUSTER_ZERO: 6944bc74be9SPaolo Bonzini cb->status = BDRV_BLOCK_ZERO; 6954bc74be9SPaolo Bonzini break; 6964bc74be9SPaolo Bonzini case QED_CLUSTER_L2: 6974bc74be9SPaolo Bonzini case QED_CLUSTER_L1: 6984bc74be9SPaolo Bonzini cb->status = 0; 6994bc74be9SPaolo Bonzini break; 7004bc74be9SPaolo Bonzini default: 7014bc74be9SPaolo Bonzini assert(ret < 0); 7024bc74be9SPaolo Bonzini cb->status = ret; 7034bc74be9SPaolo Bonzini break; 7044bc74be9SPaolo Bonzini } 7054bc74be9SPaolo Bonzini 706b7d5a5b8SStefan Hajnoczi if (cb->co) { 707b7d5a5b8SStefan Hajnoczi qemu_coroutine_enter(cb->co, NULL); 708b7d5a5b8SStefan Hajnoczi } 709298800caSStefan Hajnoczi } 710298800caSStefan Hajnoczi 711b6b8a333SPaolo Bonzini static int64_t coroutine_fn bdrv_qed_co_get_block_status(BlockDriverState *bs, 712b7d5a5b8SStefan Hajnoczi int64_t sector_num, 71375411d23SStefan Hajnoczi int nb_sectors, int *pnum) 71475411d23SStefan Hajnoczi { 715298800caSStefan Hajnoczi BDRVQEDState *s = bs->opaque; 716298800caSStefan Hajnoczi size_t len = (size_t)nb_sectors * BDRV_SECTOR_SIZE; 717298800caSStefan Hajnoczi QEDIsAllocatedCB cb = { 7184bc74be9SPaolo Bonzini .bs = bs, 7194bc74be9SPaolo Bonzini .pos = (uint64_t)sector_num * BDRV_SECTOR_SIZE, 7204bc74be9SPaolo Bonzini .status = BDRV_BLOCK_OFFSET_MASK, 721298800caSStefan Hajnoczi .pnum = pnum, 722298800caSStefan Hajnoczi }; 723298800caSStefan Hajnoczi QEDRequest request = { .l2_table = NULL }; 724298800caSStefan Hajnoczi 7254bc74be9SPaolo Bonzini qed_find_cluster(s, &request, cb.pos, len, qed_is_allocated_cb, &cb); 726298800caSStefan Hajnoczi 727b7d5a5b8SStefan Hajnoczi /* Now sleep if the callback wasn't invoked immediately */ 7284bc74be9SPaolo Bonzini while (cb.status == BDRV_BLOCK_OFFSET_MASK) { 729b7d5a5b8SStefan Hajnoczi cb.co = qemu_coroutine_self(); 730b7d5a5b8SStefan Hajnoczi qemu_coroutine_yield(); 731298800caSStefan Hajnoczi } 732298800caSStefan Hajnoczi 733298800caSStefan Hajnoczi qed_unref_l2_cache_entry(request.l2_table); 734298800caSStefan Hajnoczi 7354bc74be9SPaolo Bonzini return cb.status; 73675411d23SStefan Hajnoczi } 73775411d23SStefan Hajnoczi 738eabba580SStefan Hajnoczi static BDRVQEDState *acb_to_s(QEDAIOCB *acb) 739eabba580SStefan Hajnoczi { 740eabba580SStefan Hajnoczi return acb->common.bs->opaque; 741eabba580SStefan Hajnoczi } 742eabba580SStefan Hajnoczi 743eabba580SStefan Hajnoczi /** 744eabba580SStefan Hajnoczi * Read from the backing file or zero-fill if no backing file 745eabba580SStefan Hajnoczi * 746eabba580SStefan Hajnoczi * @s: QED state 747eabba580SStefan Hajnoczi * @pos: Byte position in device 748eabba580SStefan Hajnoczi * @qiov: Destination I/O vector 749eabba580SStefan Hajnoczi * @cb: Completion function 750eabba580SStefan Hajnoczi * @opaque: User data for completion function 751eabba580SStefan Hajnoczi * 752eabba580SStefan Hajnoczi * This function reads qiov->size bytes starting at pos from the backing file. 753eabba580SStefan Hajnoczi * If there is no backing file then zeroes are read. 754eabba580SStefan Hajnoczi */ 755eabba580SStefan Hajnoczi static void qed_read_backing_file(BDRVQEDState *s, uint64_t pos, 756eabba580SStefan Hajnoczi QEMUIOVector *qiov, 757eabba580SStefan Hajnoczi BlockDriverCompletionFunc *cb, void *opaque) 758eabba580SStefan Hajnoczi { 759eabba580SStefan Hajnoczi uint64_t backing_length = 0; 760eabba580SStefan Hajnoczi size_t size; 761eabba580SStefan Hajnoczi 762eabba580SStefan Hajnoczi /* If there is a backing file, get its length. Treat the absence of a 763eabba580SStefan Hajnoczi * backing file like a zero length backing file. 764eabba580SStefan Hajnoczi */ 765eabba580SStefan Hajnoczi if (s->bs->backing_hd) { 766eabba580SStefan Hajnoczi int64_t l = bdrv_getlength(s->bs->backing_hd); 767eabba580SStefan Hajnoczi if (l < 0) { 768eabba580SStefan Hajnoczi cb(opaque, l); 769eabba580SStefan Hajnoczi return; 770eabba580SStefan Hajnoczi } 771eabba580SStefan Hajnoczi backing_length = l; 772eabba580SStefan Hajnoczi } 773eabba580SStefan Hajnoczi 774eabba580SStefan Hajnoczi /* Zero all sectors if reading beyond the end of the backing file */ 775eabba580SStefan Hajnoczi if (pos >= backing_length || 776eabba580SStefan Hajnoczi pos + qiov->size > backing_length) { 7773d9b4925SMichael Tokarev qemu_iovec_memset(qiov, 0, 0, qiov->size); 778eabba580SStefan Hajnoczi } 779eabba580SStefan Hajnoczi 780eabba580SStefan Hajnoczi /* Complete now if there are no backing file sectors to read */ 781eabba580SStefan Hajnoczi if (pos >= backing_length) { 782eabba580SStefan Hajnoczi cb(opaque, 0); 783eabba580SStefan Hajnoczi return; 784eabba580SStefan Hajnoczi } 785eabba580SStefan Hajnoczi 786eabba580SStefan Hajnoczi /* If the read straddles the end of the backing file, shorten it */ 787eabba580SStefan Hajnoczi size = MIN((uint64_t)backing_length - pos, qiov->size); 788eabba580SStefan Hajnoczi 789820100fdSPaolo Bonzini BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO); 790ad54ae80SPaolo Bonzini bdrv_aio_readv(s->bs->backing_hd, pos / BDRV_SECTOR_SIZE, 791eabba580SStefan Hajnoczi qiov, size / BDRV_SECTOR_SIZE, cb, opaque); 792eabba580SStefan Hajnoczi } 793eabba580SStefan Hajnoczi 794eabba580SStefan Hajnoczi typedef struct { 795eabba580SStefan Hajnoczi GenericCB gencb; 796eabba580SStefan Hajnoczi BDRVQEDState *s; 797eabba580SStefan Hajnoczi QEMUIOVector qiov; 798eabba580SStefan Hajnoczi struct iovec iov; 799eabba580SStefan Hajnoczi uint64_t offset; 800eabba580SStefan Hajnoczi } CopyFromBackingFileCB; 801eabba580SStefan Hajnoczi 802eabba580SStefan Hajnoczi static void qed_copy_from_backing_file_cb(void *opaque, int ret) 803eabba580SStefan Hajnoczi { 804eabba580SStefan Hajnoczi CopyFromBackingFileCB *copy_cb = opaque; 805eabba580SStefan Hajnoczi qemu_vfree(copy_cb->iov.iov_base); 806eabba580SStefan Hajnoczi gencb_complete(©_cb->gencb, ret); 807eabba580SStefan Hajnoczi } 808eabba580SStefan Hajnoczi 809eabba580SStefan Hajnoczi static void qed_copy_from_backing_file_write(void *opaque, int ret) 810eabba580SStefan Hajnoczi { 811eabba580SStefan Hajnoczi CopyFromBackingFileCB *copy_cb = opaque; 812eabba580SStefan Hajnoczi BDRVQEDState *s = copy_cb->s; 813eabba580SStefan Hajnoczi 814eabba580SStefan Hajnoczi if (ret) { 815eabba580SStefan Hajnoczi qed_copy_from_backing_file_cb(copy_cb, ret); 816eabba580SStefan Hajnoczi return; 817eabba580SStefan Hajnoczi } 818eabba580SStefan Hajnoczi 819eabba580SStefan Hajnoczi BLKDBG_EVENT(s->bs->file, BLKDBG_COW_WRITE); 820ad54ae80SPaolo Bonzini bdrv_aio_writev(s->bs->file, copy_cb->offset / BDRV_SECTOR_SIZE, 821ad54ae80SPaolo Bonzini ©_cb->qiov, copy_cb->qiov.size / BDRV_SECTOR_SIZE, 822eabba580SStefan Hajnoczi qed_copy_from_backing_file_cb, copy_cb); 823eabba580SStefan Hajnoczi } 824eabba580SStefan Hajnoczi 825eabba580SStefan Hajnoczi /** 826eabba580SStefan Hajnoczi * Copy data from backing file into the image 827eabba580SStefan Hajnoczi * 828eabba580SStefan Hajnoczi * @s: QED state 829eabba580SStefan Hajnoczi * @pos: Byte position in device 830eabba580SStefan Hajnoczi * @len: Number of bytes 831eabba580SStefan Hajnoczi * @offset: Byte offset in image file 832eabba580SStefan Hajnoczi * @cb: Completion function 833eabba580SStefan Hajnoczi * @opaque: User data for completion function 834eabba580SStefan Hajnoczi */ 835eabba580SStefan Hajnoczi static void qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos, 836eabba580SStefan Hajnoczi uint64_t len, uint64_t offset, 837eabba580SStefan Hajnoczi BlockDriverCompletionFunc *cb, 838eabba580SStefan Hajnoczi void *opaque) 839eabba580SStefan Hajnoczi { 840eabba580SStefan Hajnoczi CopyFromBackingFileCB *copy_cb; 841eabba580SStefan Hajnoczi 842eabba580SStefan Hajnoczi /* Skip copy entirely if there is no work to do */ 843eabba580SStefan Hajnoczi if (len == 0) { 844eabba580SStefan Hajnoczi cb(opaque, 0); 845eabba580SStefan Hajnoczi return; 846eabba580SStefan Hajnoczi } 847eabba580SStefan Hajnoczi 848eabba580SStefan Hajnoczi copy_cb = gencb_alloc(sizeof(*copy_cb), cb, opaque); 849eabba580SStefan Hajnoczi copy_cb->s = s; 850eabba580SStefan Hajnoczi copy_cb->offset = offset; 851eabba580SStefan Hajnoczi copy_cb->iov.iov_base = qemu_blockalign(s->bs, len); 852eabba580SStefan Hajnoczi copy_cb->iov.iov_len = len; 853eabba580SStefan Hajnoczi qemu_iovec_init_external(©_cb->qiov, ©_cb->iov, 1); 854eabba580SStefan Hajnoczi 855eabba580SStefan Hajnoczi qed_read_backing_file(s, pos, ©_cb->qiov, 856eabba580SStefan Hajnoczi qed_copy_from_backing_file_write, copy_cb); 857eabba580SStefan Hajnoczi } 858eabba580SStefan Hajnoczi 859eabba580SStefan Hajnoczi /** 860eabba580SStefan Hajnoczi * Link one or more contiguous clusters into a table 861eabba580SStefan Hajnoczi * 862eabba580SStefan Hajnoczi * @s: QED state 863eabba580SStefan Hajnoczi * @table: L2 table 864eabba580SStefan Hajnoczi * @index: First cluster index 865eabba580SStefan Hajnoczi * @n: Number of contiguous clusters 86621df65b6SAnthony Liguori * @cluster: First cluster offset 86721df65b6SAnthony Liguori * 86821df65b6SAnthony Liguori * The cluster offset may be an allocated byte offset in the image file, the 86921df65b6SAnthony Liguori * zero cluster marker, or the unallocated cluster marker. 870eabba580SStefan Hajnoczi */ 871eabba580SStefan Hajnoczi static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index, 872eabba580SStefan Hajnoczi unsigned int n, uint64_t cluster) 873eabba580SStefan Hajnoczi { 874eabba580SStefan Hajnoczi int i; 875eabba580SStefan Hajnoczi for (i = index; i < index + n; i++) { 876eabba580SStefan Hajnoczi table->offsets[i] = cluster; 87721df65b6SAnthony Liguori if (!qed_offset_is_unalloc_cluster(cluster) && 87821df65b6SAnthony Liguori !qed_offset_is_zero_cluster(cluster)) { 879eabba580SStefan Hajnoczi cluster += s->header.cluster_size; 880eabba580SStefan Hajnoczi } 881eabba580SStefan Hajnoczi } 88221df65b6SAnthony Liguori } 883eabba580SStefan Hajnoczi 884eabba580SStefan Hajnoczi static void qed_aio_complete_bh(void *opaque) 885eabba580SStefan Hajnoczi { 886eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 887eabba580SStefan Hajnoczi BlockDriverCompletionFunc *cb = acb->common.cb; 888eabba580SStefan Hajnoczi void *user_opaque = acb->common.opaque; 889eabba580SStefan Hajnoczi int ret = acb->bh_ret; 890eabba580SStefan Hajnoczi bool *finished = acb->finished; 891eabba580SStefan Hajnoczi 892eabba580SStefan Hajnoczi qemu_bh_delete(acb->bh); 893eabba580SStefan Hajnoczi qemu_aio_release(acb); 894eabba580SStefan Hajnoczi 895eabba580SStefan Hajnoczi /* Invoke callback */ 896eabba580SStefan Hajnoczi cb(user_opaque, ret); 897eabba580SStefan Hajnoczi 898eabba580SStefan Hajnoczi /* Signal cancel completion */ 899eabba580SStefan Hajnoczi if (finished) { 900eabba580SStefan Hajnoczi *finished = true; 901eabba580SStefan Hajnoczi } 902eabba580SStefan Hajnoczi } 903eabba580SStefan Hajnoczi 904eabba580SStefan Hajnoczi static void qed_aio_complete(QEDAIOCB *acb, int ret) 905eabba580SStefan Hajnoczi { 906eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 907eabba580SStefan Hajnoczi 908eabba580SStefan Hajnoczi trace_qed_aio_complete(s, acb, ret); 909eabba580SStefan Hajnoczi 910eabba580SStefan Hajnoczi /* Free resources */ 911eabba580SStefan Hajnoczi qemu_iovec_destroy(&acb->cur_qiov); 912eabba580SStefan Hajnoczi qed_unref_l2_cache_entry(acb->request.l2_table); 913eabba580SStefan Hajnoczi 9140e71be19SStefan Hajnoczi /* Free the buffer we may have allocated for zero writes */ 9150e71be19SStefan Hajnoczi if (acb->flags & QED_AIOCB_ZERO) { 9160e71be19SStefan Hajnoczi qemu_vfree(acb->qiov->iov[0].iov_base); 9170e71be19SStefan Hajnoczi acb->qiov->iov[0].iov_base = NULL; 9180e71be19SStefan Hajnoczi } 9190e71be19SStefan Hajnoczi 920eabba580SStefan Hajnoczi /* Arrange for a bh to invoke the completion function */ 921eabba580SStefan Hajnoczi acb->bh_ret = ret; 922eabba580SStefan Hajnoczi acb->bh = qemu_bh_new(qed_aio_complete_bh, acb); 923eabba580SStefan Hajnoczi qemu_bh_schedule(acb->bh); 924eabba580SStefan Hajnoczi 925eabba580SStefan Hajnoczi /* Start next allocating write request waiting behind this one. Note that 926eabba580SStefan Hajnoczi * requests enqueue themselves when they first hit an unallocated cluster 927eabba580SStefan Hajnoczi * but they wait until the entire request is finished before waking up the 928eabba580SStefan Hajnoczi * next request in the queue. This ensures that we don't cycle through 929eabba580SStefan Hajnoczi * requests multiple times but rather finish one at a time completely. 930eabba580SStefan Hajnoczi */ 931eabba580SStefan Hajnoczi if (acb == QSIMPLEQ_FIRST(&s->allocating_write_reqs)) { 932eabba580SStefan Hajnoczi QSIMPLEQ_REMOVE_HEAD(&s->allocating_write_reqs, next); 933eabba580SStefan Hajnoczi acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs); 934eabba580SStefan Hajnoczi if (acb) { 935eabba580SStefan Hajnoczi qed_aio_next_io(acb, 0); 9366f321e93SStefan Hajnoczi } else if (s->header.features & QED_F_NEED_CHECK) { 9376f321e93SStefan Hajnoczi qed_start_need_check_timer(s); 938eabba580SStefan Hajnoczi } 939eabba580SStefan Hajnoczi } 940eabba580SStefan Hajnoczi } 941eabba580SStefan Hajnoczi 942eabba580SStefan Hajnoczi /** 943eabba580SStefan Hajnoczi * Commit the current L2 table to the cache 944eabba580SStefan Hajnoczi */ 945eabba580SStefan Hajnoczi static void qed_commit_l2_update(void *opaque, int ret) 946eabba580SStefan Hajnoczi { 947eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 948eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 949eabba580SStefan Hajnoczi CachedL2Table *l2_table = acb->request.l2_table; 950e4fc8781SStefan Hajnoczi uint64_t l2_offset = l2_table->offset; 951eabba580SStefan Hajnoczi 952eabba580SStefan Hajnoczi qed_commit_l2_cache_entry(&s->l2_cache, l2_table); 953eabba580SStefan Hajnoczi 954eabba580SStefan Hajnoczi /* This is guaranteed to succeed because we just committed the entry to the 955eabba580SStefan Hajnoczi * cache. 956eabba580SStefan Hajnoczi */ 957e4fc8781SStefan Hajnoczi acb->request.l2_table = qed_find_l2_cache_entry(&s->l2_cache, l2_offset); 958eabba580SStefan Hajnoczi assert(acb->request.l2_table != NULL); 959eabba580SStefan Hajnoczi 960eabba580SStefan Hajnoczi qed_aio_next_io(opaque, ret); 961eabba580SStefan Hajnoczi } 962eabba580SStefan Hajnoczi 963eabba580SStefan Hajnoczi /** 964eabba580SStefan Hajnoczi * Update L1 table with new L2 table offset and write it out 965eabba580SStefan Hajnoczi */ 966eabba580SStefan Hajnoczi static void qed_aio_write_l1_update(void *opaque, int ret) 967eabba580SStefan Hajnoczi { 968eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 969eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 970eabba580SStefan Hajnoczi int index; 971eabba580SStefan Hajnoczi 972eabba580SStefan Hajnoczi if (ret) { 973eabba580SStefan Hajnoczi qed_aio_complete(acb, ret); 974eabba580SStefan Hajnoczi return; 975eabba580SStefan Hajnoczi } 976eabba580SStefan Hajnoczi 977eabba580SStefan Hajnoczi index = qed_l1_index(s, acb->cur_pos); 978eabba580SStefan Hajnoczi s->l1_table->offsets[index] = acb->request.l2_table->offset; 979eabba580SStefan Hajnoczi 980eabba580SStefan Hajnoczi qed_write_l1_table(s, index, 1, qed_commit_l2_update, acb); 981eabba580SStefan Hajnoczi } 982eabba580SStefan Hajnoczi 983eabba580SStefan Hajnoczi /** 984eabba580SStefan Hajnoczi * Update L2 table with new cluster offsets and write them out 985eabba580SStefan Hajnoczi */ 9860e71be19SStefan Hajnoczi static void qed_aio_write_l2_update(QEDAIOCB *acb, int ret, uint64_t offset) 987eabba580SStefan Hajnoczi { 988eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 989eabba580SStefan Hajnoczi bool need_alloc = acb->find_cluster_ret == QED_CLUSTER_L1; 990eabba580SStefan Hajnoczi int index; 991eabba580SStefan Hajnoczi 992eabba580SStefan Hajnoczi if (ret) { 993eabba580SStefan Hajnoczi goto err; 994eabba580SStefan Hajnoczi } 995eabba580SStefan Hajnoczi 996eabba580SStefan Hajnoczi if (need_alloc) { 997eabba580SStefan Hajnoczi qed_unref_l2_cache_entry(acb->request.l2_table); 998eabba580SStefan Hajnoczi acb->request.l2_table = qed_new_l2_table(s); 999eabba580SStefan Hajnoczi } 1000eabba580SStefan Hajnoczi 1001eabba580SStefan Hajnoczi index = qed_l2_index(s, acb->cur_pos); 1002eabba580SStefan Hajnoczi qed_update_l2_table(s, acb->request.l2_table->table, index, acb->cur_nclusters, 10030e71be19SStefan Hajnoczi offset); 1004eabba580SStefan Hajnoczi 1005eabba580SStefan Hajnoczi if (need_alloc) { 1006eabba580SStefan Hajnoczi /* Write out the whole new L2 table */ 1007eabba580SStefan Hajnoczi qed_write_l2_table(s, &acb->request, 0, s->table_nelems, true, 1008eabba580SStefan Hajnoczi qed_aio_write_l1_update, acb); 1009eabba580SStefan Hajnoczi } else { 1010eabba580SStefan Hajnoczi /* Write out only the updated part of the L2 table */ 1011eabba580SStefan Hajnoczi qed_write_l2_table(s, &acb->request, index, acb->cur_nclusters, false, 1012eabba580SStefan Hajnoczi qed_aio_next_io, acb); 1013eabba580SStefan Hajnoczi } 1014eabba580SStefan Hajnoczi return; 1015eabba580SStefan Hajnoczi 1016eabba580SStefan Hajnoczi err: 1017eabba580SStefan Hajnoczi qed_aio_complete(acb, ret); 1018eabba580SStefan Hajnoczi } 1019eabba580SStefan Hajnoczi 10200e71be19SStefan Hajnoczi static void qed_aio_write_l2_update_cb(void *opaque, int ret) 10210e71be19SStefan Hajnoczi { 10220e71be19SStefan Hajnoczi QEDAIOCB *acb = opaque; 10230e71be19SStefan Hajnoczi qed_aio_write_l2_update(acb, ret, acb->cur_cluster); 10240e71be19SStefan Hajnoczi } 10250e71be19SStefan Hajnoczi 1026eabba580SStefan Hajnoczi /** 1027eabba580SStefan Hajnoczi * Flush new data clusters before updating the L2 table 1028eabba580SStefan Hajnoczi * 1029eabba580SStefan Hajnoczi * This flush is necessary when a backing file is in use. A crash during an 1030eabba580SStefan Hajnoczi * allocating write could result in empty clusters in the image. If the write 1031eabba580SStefan Hajnoczi * only touched a subregion of the cluster, then backing image sectors have 1032eabba580SStefan Hajnoczi * been lost in the untouched region. The solution is to flush after writing a 1033eabba580SStefan Hajnoczi * new data cluster and before updating the L2 table. 1034eabba580SStefan Hajnoczi */ 1035eabba580SStefan Hajnoczi static void qed_aio_write_flush_before_l2_update(void *opaque, int ret) 1036eabba580SStefan Hajnoczi { 1037eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 1038eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 1039eabba580SStefan Hajnoczi 10400e71be19SStefan Hajnoczi if (!bdrv_aio_flush(s->bs->file, qed_aio_write_l2_update_cb, opaque)) { 1041eabba580SStefan Hajnoczi qed_aio_complete(acb, -EIO); 1042eabba580SStefan Hajnoczi } 1043eabba580SStefan Hajnoczi } 1044eabba580SStefan Hajnoczi 1045eabba580SStefan Hajnoczi /** 1046eabba580SStefan Hajnoczi * Write data to the image file 1047eabba580SStefan Hajnoczi */ 1048eabba580SStefan Hajnoczi static void qed_aio_write_main(void *opaque, int ret) 1049eabba580SStefan Hajnoczi { 1050eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 1051eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 1052eabba580SStefan Hajnoczi uint64_t offset = acb->cur_cluster + 1053eabba580SStefan Hajnoczi qed_offset_into_cluster(s, acb->cur_pos); 1054eabba580SStefan Hajnoczi BlockDriverCompletionFunc *next_fn; 1055eabba580SStefan Hajnoczi 1056eabba580SStefan Hajnoczi trace_qed_aio_write_main(s, acb, ret, offset, acb->cur_qiov.size); 1057eabba580SStefan Hajnoczi 1058eabba580SStefan Hajnoczi if (ret) { 1059eabba580SStefan Hajnoczi qed_aio_complete(acb, ret); 1060eabba580SStefan Hajnoczi return; 1061eabba580SStefan Hajnoczi } 1062eabba580SStefan Hajnoczi 1063eabba580SStefan Hajnoczi if (acb->find_cluster_ret == QED_CLUSTER_FOUND) { 1064eabba580SStefan Hajnoczi next_fn = qed_aio_next_io; 1065eabba580SStefan Hajnoczi } else { 1066eabba580SStefan Hajnoczi if (s->bs->backing_hd) { 1067eabba580SStefan Hajnoczi next_fn = qed_aio_write_flush_before_l2_update; 1068eabba580SStefan Hajnoczi } else { 10690e71be19SStefan Hajnoczi next_fn = qed_aio_write_l2_update_cb; 1070eabba580SStefan Hajnoczi } 1071eabba580SStefan Hajnoczi } 1072eabba580SStefan Hajnoczi 1073eabba580SStefan Hajnoczi BLKDBG_EVENT(s->bs->file, BLKDBG_WRITE_AIO); 1074ad54ae80SPaolo Bonzini bdrv_aio_writev(s->bs->file, offset / BDRV_SECTOR_SIZE, 1075ad54ae80SPaolo Bonzini &acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE, 1076eabba580SStefan Hajnoczi next_fn, acb); 1077eabba580SStefan Hajnoczi } 1078eabba580SStefan Hajnoczi 1079eabba580SStefan Hajnoczi /** 1080eabba580SStefan Hajnoczi * Populate back untouched region of new data cluster 1081eabba580SStefan Hajnoczi */ 1082eabba580SStefan Hajnoczi static void qed_aio_write_postfill(void *opaque, int ret) 1083eabba580SStefan Hajnoczi { 1084eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 1085eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 1086eabba580SStefan Hajnoczi uint64_t start = acb->cur_pos + acb->cur_qiov.size; 1087eabba580SStefan Hajnoczi uint64_t len = 1088eabba580SStefan Hajnoczi qed_start_of_cluster(s, start + s->header.cluster_size - 1) - start; 1089eabba580SStefan Hajnoczi uint64_t offset = acb->cur_cluster + 1090eabba580SStefan Hajnoczi qed_offset_into_cluster(s, acb->cur_pos) + 1091eabba580SStefan Hajnoczi acb->cur_qiov.size; 1092eabba580SStefan Hajnoczi 1093eabba580SStefan Hajnoczi if (ret) { 1094eabba580SStefan Hajnoczi qed_aio_complete(acb, ret); 1095eabba580SStefan Hajnoczi return; 1096eabba580SStefan Hajnoczi } 1097eabba580SStefan Hajnoczi 1098eabba580SStefan Hajnoczi trace_qed_aio_write_postfill(s, acb, start, len, offset); 1099eabba580SStefan Hajnoczi qed_copy_from_backing_file(s, start, len, offset, 1100eabba580SStefan Hajnoczi qed_aio_write_main, acb); 1101eabba580SStefan Hajnoczi } 1102eabba580SStefan Hajnoczi 1103eabba580SStefan Hajnoczi /** 1104eabba580SStefan Hajnoczi * Populate front untouched region of new data cluster 1105eabba580SStefan Hajnoczi */ 1106eabba580SStefan Hajnoczi static void qed_aio_write_prefill(void *opaque, int ret) 1107eabba580SStefan Hajnoczi { 1108eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 1109eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 1110eabba580SStefan Hajnoczi uint64_t start = qed_start_of_cluster(s, acb->cur_pos); 1111eabba580SStefan Hajnoczi uint64_t len = qed_offset_into_cluster(s, acb->cur_pos); 1112eabba580SStefan Hajnoczi 1113eabba580SStefan Hajnoczi trace_qed_aio_write_prefill(s, acb, start, len, acb->cur_cluster); 1114eabba580SStefan Hajnoczi qed_copy_from_backing_file(s, start, len, acb->cur_cluster, 1115eabba580SStefan Hajnoczi qed_aio_write_postfill, acb); 1116eabba580SStefan Hajnoczi } 1117eabba580SStefan Hajnoczi 1118eabba580SStefan Hajnoczi /** 11190d09c797SStefan Hajnoczi * Check if the QED_F_NEED_CHECK bit should be set during allocating write 11200d09c797SStefan Hajnoczi */ 11210d09c797SStefan Hajnoczi static bool qed_should_set_need_check(BDRVQEDState *s) 11220d09c797SStefan Hajnoczi { 11230d09c797SStefan Hajnoczi /* The flush before L2 update path ensures consistency */ 11240d09c797SStefan Hajnoczi if (s->bs->backing_hd) { 11250d09c797SStefan Hajnoczi return false; 11260d09c797SStefan Hajnoczi } 11270d09c797SStefan Hajnoczi 11280d09c797SStefan Hajnoczi return !(s->header.features & QED_F_NEED_CHECK); 11290d09c797SStefan Hajnoczi } 11300d09c797SStefan Hajnoczi 11310e71be19SStefan Hajnoczi static void qed_aio_write_zero_cluster(void *opaque, int ret) 11320e71be19SStefan Hajnoczi { 11330e71be19SStefan Hajnoczi QEDAIOCB *acb = opaque; 11340e71be19SStefan Hajnoczi 11350e71be19SStefan Hajnoczi if (ret) { 11360e71be19SStefan Hajnoczi qed_aio_complete(acb, ret); 11370e71be19SStefan Hajnoczi return; 11380e71be19SStefan Hajnoczi } 11390e71be19SStefan Hajnoczi 11400e71be19SStefan Hajnoczi qed_aio_write_l2_update(acb, 0, 1); 11410e71be19SStefan Hajnoczi } 11420e71be19SStefan Hajnoczi 11430d09c797SStefan Hajnoczi /** 1144eabba580SStefan Hajnoczi * Write new data cluster 1145eabba580SStefan Hajnoczi * 1146eabba580SStefan Hajnoczi * @acb: Write request 1147eabba580SStefan Hajnoczi * @len: Length in bytes 1148eabba580SStefan Hajnoczi * 1149eabba580SStefan Hajnoczi * This path is taken when writing to previously unallocated clusters. 1150eabba580SStefan Hajnoczi */ 1151eabba580SStefan Hajnoczi static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len) 1152eabba580SStefan Hajnoczi { 1153eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 11540e71be19SStefan Hajnoczi BlockDriverCompletionFunc *cb; 1155eabba580SStefan Hajnoczi 11566f321e93SStefan Hajnoczi /* Cancel timer when the first allocating request comes in */ 11576f321e93SStefan Hajnoczi if (QSIMPLEQ_EMPTY(&s->allocating_write_reqs)) { 11586f321e93SStefan Hajnoczi qed_cancel_need_check_timer(s); 11596f321e93SStefan Hajnoczi } 11606f321e93SStefan Hajnoczi 1161eabba580SStefan Hajnoczi /* Freeze this request if another allocating write is in progress */ 1162eabba580SStefan Hajnoczi if (acb != QSIMPLEQ_FIRST(&s->allocating_write_reqs)) { 1163eabba580SStefan Hajnoczi QSIMPLEQ_INSERT_TAIL(&s->allocating_write_reqs, acb, next); 1164eabba580SStefan Hajnoczi } 11656f321e93SStefan Hajnoczi if (acb != QSIMPLEQ_FIRST(&s->allocating_write_reqs) || 11666f321e93SStefan Hajnoczi s->allocating_write_reqs_plugged) { 1167eabba580SStefan Hajnoczi return; /* wait for existing request to finish */ 1168eabba580SStefan Hajnoczi } 1169eabba580SStefan Hajnoczi 1170eabba580SStefan Hajnoczi acb->cur_nclusters = qed_bytes_to_clusters(s, 1171eabba580SStefan Hajnoczi qed_offset_into_cluster(s, acb->cur_pos) + len); 11721b093c48SMichael Tokarev qemu_iovec_concat(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len); 1173eabba580SStefan Hajnoczi 11740e71be19SStefan Hajnoczi if (acb->flags & QED_AIOCB_ZERO) { 11750e71be19SStefan Hajnoczi /* Skip ahead if the clusters are already zero */ 11760e71be19SStefan Hajnoczi if (acb->find_cluster_ret == QED_CLUSTER_ZERO) { 11770e71be19SStefan Hajnoczi qed_aio_next_io(acb, 0); 11780e71be19SStefan Hajnoczi return; 11790e71be19SStefan Hajnoczi } 11800e71be19SStefan Hajnoczi 11810e71be19SStefan Hajnoczi cb = qed_aio_write_zero_cluster; 11820e71be19SStefan Hajnoczi } else { 11830e71be19SStefan Hajnoczi cb = qed_aio_write_prefill; 11840e71be19SStefan Hajnoczi acb->cur_cluster = qed_alloc_clusters(s, acb->cur_nclusters); 11850e71be19SStefan Hajnoczi } 11860e71be19SStefan Hajnoczi 11870d09c797SStefan Hajnoczi if (qed_should_set_need_check(s)) { 118801979a98SStefan Hajnoczi s->header.features |= QED_F_NEED_CHECK; 11890e71be19SStefan Hajnoczi qed_write_header(s, cb, acb); 11900d09c797SStefan Hajnoczi } else { 11910e71be19SStefan Hajnoczi cb(acb, 0); 11920d09c797SStefan Hajnoczi } 1193eabba580SStefan Hajnoczi } 1194eabba580SStefan Hajnoczi 1195eabba580SStefan Hajnoczi /** 1196eabba580SStefan Hajnoczi * Write data cluster in place 1197eabba580SStefan Hajnoczi * 1198eabba580SStefan Hajnoczi * @acb: Write request 1199eabba580SStefan Hajnoczi * @offset: Cluster offset in bytes 1200eabba580SStefan Hajnoczi * @len: Length in bytes 1201eabba580SStefan Hajnoczi * 1202eabba580SStefan Hajnoczi * This path is taken when writing to already allocated clusters. 1203eabba580SStefan Hajnoczi */ 1204eabba580SStefan Hajnoczi static void qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len) 1205eabba580SStefan Hajnoczi { 12060e71be19SStefan Hajnoczi /* Allocate buffer for zero writes */ 12070e71be19SStefan Hajnoczi if (acb->flags & QED_AIOCB_ZERO) { 12080e71be19SStefan Hajnoczi struct iovec *iov = acb->qiov->iov; 12090e71be19SStefan Hajnoczi 12100e71be19SStefan Hajnoczi if (!iov->iov_base) { 12110e71be19SStefan Hajnoczi iov->iov_base = qemu_blockalign(acb->common.bs, iov->iov_len); 12120e71be19SStefan Hajnoczi memset(iov->iov_base, 0, iov->iov_len); 12130e71be19SStefan Hajnoczi } 12140e71be19SStefan Hajnoczi } 12150e71be19SStefan Hajnoczi 1216eabba580SStefan Hajnoczi /* Calculate the I/O vector */ 1217eabba580SStefan Hajnoczi acb->cur_cluster = offset; 12181b093c48SMichael Tokarev qemu_iovec_concat(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len); 1219eabba580SStefan Hajnoczi 1220eabba580SStefan Hajnoczi /* Do the actual write */ 1221eabba580SStefan Hajnoczi qed_aio_write_main(acb, 0); 1222eabba580SStefan Hajnoczi } 1223eabba580SStefan Hajnoczi 1224eabba580SStefan Hajnoczi /** 1225eabba580SStefan Hajnoczi * Write data cluster 1226eabba580SStefan Hajnoczi * 1227eabba580SStefan Hajnoczi * @opaque: Write request 1228eabba580SStefan Hajnoczi * @ret: QED_CLUSTER_FOUND, QED_CLUSTER_L2, QED_CLUSTER_L1, 1229eabba580SStefan Hajnoczi * or -errno 1230eabba580SStefan Hajnoczi * @offset: Cluster offset in bytes 1231eabba580SStefan Hajnoczi * @len: Length in bytes 1232eabba580SStefan Hajnoczi * 1233eabba580SStefan Hajnoczi * Callback from qed_find_cluster(). 1234eabba580SStefan Hajnoczi */ 1235eabba580SStefan Hajnoczi static void qed_aio_write_data(void *opaque, int ret, 1236eabba580SStefan Hajnoczi uint64_t offset, size_t len) 1237eabba580SStefan Hajnoczi { 1238eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 1239eabba580SStefan Hajnoczi 1240eabba580SStefan Hajnoczi trace_qed_aio_write_data(acb_to_s(acb), acb, ret, offset, len); 1241eabba580SStefan Hajnoczi 1242eabba580SStefan Hajnoczi acb->find_cluster_ret = ret; 1243eabba580SStefan Hajnoczi 1244eabba580SStefan Hajnoczi switch (ret) { 1245eabba580SStefan Hajnoczi case QED_CLUSTER_FOUND: 1246eabba580SStefan Hajnoczi qed_aio_write_inplace(acb, offset, len); 1247eabba580SStefan Hajnoczi break; 1248eabba580SStefan Hajnoczi 1249eabba580SStefan Hajnoczi case QED_CLUSTER_L2: 1250eabba580SStefan Hajnoczi case QED_CLUSTER_L1: 125121df65b6SAnthony Liguori case QED_CLUSTER_ZERO: 1252eabba580SStefan Hajnoczi qed_aio_write_alloc(acb, len); 1253eabba580SStefan Hajnoczi break; 1254eabba580SStefan Hajnoczi 1255eabba580SStefan Hajnoczi default: 1256eabba580SStefan Hajnoczi qed_aio_complete(acb, ret); 1257eabba580SStefan Hajnoczi break; 1258eabba580SStefan Hajnoczi } 1259eabba580SStefan Hajnoczi } 1260eabba580SStefan Hajnoczi 1261eabba580SStefan Hajnoczi /** 1262eabba580SStefan Hajnoczi * Read data cluster 1263eabba580SStefan Hajnoczi * 1264eabba580SStefan Hajnoczi * @opaque: Read request 1265eabba580SStefan Hajnoczi * @ret: QED_CLUSTER_FOUND, QED_CLUSTER_L2, QED_CLUSTER_L1, 1266eabba580SStefan Hajnoczi * or -errno 1267eabba580SStefan Hajnoczi * @offset: Cluster offset in bytes 1268eabba580SStefan Hajnoczi * @len: Length in bytes 1269eabba580SStefan Hajnoczi * 1270eabba580SStefan Hajnoczi * Callback from qed_find_cluster(). 1271eabba580SStefan Hajnoczi */ 1272eabba580SStefan Hajnoczi static void qed_aio_read_data(void *opaque, int ret, 1273eabba580SStefan Hajnoczi uint64_t offset, size_t len) 1274eabba580SStefan Hajnoczi { 1275eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 1276eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 1277eabba580SStefan Hajnoczi BlockDriverState *bs = acb->common.bs; 1278eabba580SStefan Hajnoczi 1279eabba580SStefan Hajnoczi /* Adjust offset into cluster */ 1280eabba580SStefan Hajnoczi offset += qed_offset_into_cluster(s, acb->cur_pos); 1281eabba580SStefan Hajnoczi 1282eabba580SStefan Hajnoczi trace_qed_aio_read_data(s, acb, ret, offset, len); 1283eabba580SStefan Hajnoczi 1284eabba580SStefan Hajnoczi if (ret < 0) { 1285eabba580SStefan Hajnoczi goto err; 1286eabba580SStefan Hajnoczi } 1287eabba580SStefan Hajnoczi 12881b093c48SMichael Tokarev qemu_iovec_concat(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len); 1289eabba580SStefan Hajnoczi 129021df65b6SAnthony Liguori /* Handle zero cluster and backing file reads */ 129121df65b6SAnthony Liguori if (ret == QED_CLUSTER_ZERO) { 12923d9b4925SMichael Tokarev qemu_iovec_memset(&acb->cur_qiov, 0, 0, acb->cur_qiov.size); 129321df65b6SAnthony Liguori qed_aio_next_io(acb, 0); 129421df65b6SAnthony Liguori return; 129521df65b6SAnthony Liguori } else if (ret != QED_CLUSTER_FOUND) { 1296eabba580SStefan Hajnoczi qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov, 1297eabba580SStefan Hajnoczi qed_aio_next_io, acb); 1298eabba580SStefan Hajnoczi return; 1299eabba580SStefan Hajnoczi } 1300eabba580SStefan Hajnoczi 1301eabba580SStefan Hajnoczi BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 1302ad54ae80SPaolo Bonzini bdrv_aio_readv(bs->file, offset / BDRV_SECTOR_SIZE, 1303ad54ae80SPaolo Bonzini &acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE, 1304eabba580SStefan Hajnoczi qed_aio_next_io, acb); 1305eabba580SStefan Hajnoczi return; 1306eabba580SStefan Hajnoczi 1307eabba580SStefan Hajnoczi err: 1308eabba580SStefan Hajnoczi qed_aio_complete(acb, ret); 1309eabba580SStefan Hajnoczi } 1310eabba580SStefan Hajnoczi 1311eabba580SStefan Hajnoczi /** 1312eabba580SStefan Hajnoczi * Begin next I/O or complete the request 1313eabba580SStefan Hajnoczi */ 1314eabba580SStefan Hajnoczi static void qed_aio_next_io(void *opaque, int ret) 1315eabba580SStefan Hajnoczi { 1316eabba580SStefan Hajnoczi QEDAIOCB *acb = opaque; 1317eabba580SStefan Hajnoczi BDRVQEDState *s = acb_to_s(acb); 13186e4f59bdSStefan Hajnoczi QEDFindClusterFunc *io_fn = (acb->flags & QED_AIOCB_WRITE) ? 13196e4f59bdSStefan Hajnoczi qed_aio_write_data : qed_aio_read_data; 1320eabba580SStefan Hajnoczi 1321eabba580SStefan Hajnoczi trace_qed_aio_next_io(s, acb, ret, acb->cur_pos + acb->cur_qiov.size); 1322eabba580SStefan Hajnoczi 1323eabba580SStefan Hajnoczi /* Handle I/O error */ 1324eabba580SStefan Hajnoczi if (ret) { 1325eabba580SStefan Hajnoczi qed_aio_complete(acb, ret); 1326eabba580SStefan Hajnoczi return; 1327eabba580SStefan Hajnoczi } 1328eabba580SStefan Hajnoczi 1329eabba580SStefan Hajnoczi acb->qiov_offset += acb->cur_qiov.size; 1330eabba580SStefan Hajnoczi acb->cur_pos += acb->cur_qiov.size; 1331eabba580SStefan Hajnoczi qemu_iovec_reset(&acb->cur_qiov); 1332eabba580SStefan Hajnoczi 1333eabba580SStefan Hajnoczi /* Complete request */ 1334eabba580SStefan Hajnoczi if (acb->cur_pos >= acb->end_pos) { 1335eabba580SStefan Hajnoczi qed_aio_complete(acb, 0); 1336eabba580SStefan Hajnoczi return; 1337eabba580SStefan Hajnoczi } 1338eabba580SStefan Hajnoczi 1339eabba580SStefan Hajnoczi /* Find next cluster and start I/O */ 1340eabba580SStefan Hajnoczi qed_find_cluster(s, &acb->request, 1341eabba580SStefan Hajnoczi acb->cur_pos, acb->end_pos - acb->cur_pos, 1342eabba580SStefan Hajnoczi io_fn, acb); 1343eabba580SStefan Hajnoczi } 1344eabba580SStefan Hajnoczi 1345eabba580SStefan Hajnoczi static BlockDriverAIOCB *qed_aio_setup(BlockDriverState *bs, 1346eabba580SStefan Hajnoczi int64_t sector_num, 1347eabba580SStefan Hajnoczi QEMUIOVector *qiov, int nb_sectors, 1348eabba580SStefan Hajnoczi BlockDriverCompletionFunc *cb, 13496e4f59bdSStefan Hajnoczi void *opaque, int flags) 1350eabba580SStefan Hajnoczi { 1351d7331bedSStefan Hajnoczi QEDAIOCB *acb = qemu_aio_get(&qed_aiocb_info, bs, cb, opaque); 1352eabba580SStefan Hajnoczi 1353eabba580SStefan Hajnoczi trace_qed_aio_setup(bs->opaque, acb, sector_num, nb_sectors, 13546e4f59bdSStefan Hajnoczi opaque, flags); 1355eabba580SStefan Hajnoczi 13566e4f59bdSStefan Hajnoczi acb->flags = flags; 1357eabba580SStefan Hajnoczi acb->finished = NULL; 1358eabba580SStefan Hajnoczi acb->qiov = qiov; 1359eabba580SStefan Hajnoczi acb->qiov_offset = 0; 1360eabba580SStefan Hajnoczi acb->cur_pos = (uint64_t)sector_num * BDRV_SECTOR_SIZE; 1361eabba580SStefan Hajnoczi acb->end_pos = acb->cur_pos + nb_sectors * BDRV_SECTOR_SIZE; 1362eabba580SStefan Hajnoczi acb->request.l2_table = NULL; 1363eabba580SStefan Hajnoczi qemu_iovec_init(&acb->cur_qiov, qiov->niov); 1364eabba580SStefan Hajnoczi 1365eabba580SStefan Hajnoczi /* Start request */ 1366eabba580SStefan Hajnoczi qed_aio_next_io(acb, 0); 1367eabba580SStefan Hajnoczi return &acb->common; 1368eabba580SStefan Hajnoczi } 1369eabba580SStefan Hajnoczi 137075411d23SStefan Hajnoczi static BlockDriverAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs, 137175411d23SStefan Hajnoczi int64_t sector_num, 137275411d23SStefan Hajnoczi QEMUIOVector *qiov, int nb_sectors, 137375411d23SStefan Hajnoczi BlockDriverCompletionFunc *cb, 137475411d23SStefan Hajnoczi void *opaque) 137575411d23SStefan Hajnoczi { 13766e4f59bdSStefan Hajnoczi return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); 137775411d23SStefan Hajnoczi } 137875411d23SStefan Hajnoczi 137975411d23SStefan Hajnoczi static BlockDriverAIOCB *bdrv_qed_aio_writev(BlockDriverState *bs, 138075411d23SStefan Hajnoczi int64_t sector_num, 138175411d23SStefan Hajnoczi QEMUIOVector *qiov, int nb_sectors, 138275411d23SStefan Hajnoczi BlockDriverCompletionFunc *cb, 138375411d23SStefan Hajnoczi void *opaque) 138475411d23SStefan Hajnoczi { 13856e4f59bdSStefan Hajnoczi return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, 13866e4f59bdSStefan Hajnoczi opaque, QED_AIOCB_WRITE); 138775411d23SStefan Hajnoczi } 138875411d23SStefan Hajnoczi 13890e71be19SStefan Hajnoczi typedef struct { 13900e71be19SStefan Hajnoczi Coroutine *co; 13910e71be19SStefan Hajnoczi int ret; 13920e71be19SStefan Hajnoczi bool done; 13930e71be19SStefan Hajnoczi } QEDWriteZeroesCB; 13940e71be19SStefan Hajnoczi 13950e71be19SStefan Hajnoczi static void coroutine_fn qed_co_write_zeroes_cb(void *opaque, int ret) 13960e71be19SStefan Hajnoczi { 13970e71be19SStefan Hajnoczi QEDWriteZeroesCB *cb = opaque; 13980e71be19SStefan Hajnoczi 13990e71be19SStefan Hajnoczi cb->done = true; 14000e71be19SStefan Hajnoczi cb->ret = ret; 14010e71be19SStefan Hajnoczi if (cb->co) { 14020e71be19SStefan Hajnoczi qemu_coroutine_enter(cb->co, NULL); 14030e71be19SStefan Hajnoczi } 14040e71be19SStefan Hajnoczi } 14050e71be19SStefan Hajnoczi 14060e71be19SStefan Hajnoczi static int coroutine_fn bdrv_qed_co_write_zeroes(BlockDriverState *bs, 14070e71be19SStefan Hajnoczi int64_t sector_num, 1408aa7bfbffSPeter Lieven int nb_sectors, 1409aa7bfbffSPeter Lieven BdrvRequestFlags flags) 14100e71be19SStefan Hajnoczi { 14110e71be19SStefan Hajnoczi BlockDriverAIOCB *blockacb; 1412ef72f76eSStefan Hajnoczi BDRVQEDState *s = bs->opaque; 14130e71be19SStefan Hajnoczi QEDWriteZeroesCB cb = { .done = false }; 14140e71be19SStefan Hajnoczi QEMUIOVector qiov; 14150e71be19SStefan Hajnoczi struct iovec iov; 14160e71be19SStefan Hajnoczi 1417ef72f76eSStefan Hajnoczi /* Refuse if there are untouched backing file sectors */ 1418ef72f76eSStefan Hajnoczi if (bs->backing_hd) { 1419ef72f76eSStefan Hajnoczi if (qed_offset_into_cluster(s, sector_num * BDRV_SECTOR_SIZE) != 0) { 1420ef72f76eSStefan Hajnoczi return -ENOTSUP; 1421ef72f76eSStefan Hajnoczi } 1422ef72f76eSStefan Hajnoczi if (qed_offset_into_cluster(s, nb_sectors * BDRV_SECTOR_SIZE) != 0) { 1423ef72f76eSStefan Hajnoczi return -ENOTSUP; 1424ef72f76eSStefan Hajnoczi } 1425ef72f76eSStefan Hajnoczi } 1426ef72f76eSStefan Hajnoczi 14270e71be19SStefan Hajnoczi /* Zero writes start without an I/O buffer. If a buffer becomes necessary 14280e71be19SStefan Hajnoczi * then it will be allocated during request processing. 14290e71be19SStefan Hajnoczi */ 14300e71be19SStefan Hajnoczi iov.iov_base = NULL, 14310e71be19SStefan Hajnoczi iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE, 14320e71be19SStefan Hajnoczi 14330e71be19SStefan Hajnoczi qemu_iovec_init_external(&qiov, &iov, 1); 14340e71be19SStefan Hajnoczi blockacb = qed_aio_setup(bs, sector_num, &qiov, nb_sectors, 14350e71be19SStefan Hajnoczi qed_co_write_zeroes_cb, &cb, 14360e71be19SStefan Hajnoczi QED_AIOCB_WRITE | QED_AIOCB_ZERO); 14370e71be19SStefan Hajnoczi if (!blockacb) { 14380e71be19SStefan Hajnoczi return -EIO; 14390e71be19SStefan Hajnoczi } 14400e71be19SStefan Hajnoczi if (!cb.done) { 14410e71be19SStefan Hajnoczi cb.co = qemu_coroutine_self(); 14420e71be19SStefan Hajnoczi qemu_coroutine_yield(); 14430e71be19SStefan Hajnoczi } 14440e71be19SStefan Hajnoczi assert(cb.done); 14450e71be19SStefan Hajnoczi return cb.ret; 14460e71be19SStefan Hajnoczi } 14470e71be19SStefan Hajnoczi 144875411d23SStefan Hajnoczi static int bdrv_qed_truncate(BlockDriverState *bs, int64_t offset) 144975411d23SStefan Hajnoczi { 145077a5a000SStefan Hajnoczi BDRVQEDState *s = bs->opaque; 145177a5a000SStefan Hajnoczi uint64_t old_image_size; 145277a5a000SStefan Hajnoczi int ret; 145377a5a000SStefan Hajnoczi 145477a5a000SStefan Hajnoczi if (!qed_is_image_size_valid(offset, s->header.cluster_size, 145577a5a000SStefan Hajnoczi s->header.table_size)) { 145677a5a000SStefan Hajnoczi return -EINVAL; 145777a5a000SStefan Hajnoczi } 145877a5a000SStefan Hajnoczi 145977a5a000SStefan Hajnoczi /* Shrinking is currently not supported */ 146077a5a000SStefan Hajnoczi if ((uint64_t)offset < s->header.image_size) { 146175411d23SStefan Hajnoczi return -ENOTSUP; 146275411d23SStefan Hajnoczi } 146375411d23SStefan Hajnoczi 146477a5a000SStefan Hajnoczi old_image_size = s->header.image_size; 146577a5a000SStefan Hajnoczi s->header.image_size = offset; 146677a5a000SStefan Hajnoczi ret = qed_write_header_sync(s); 146777a5a000SStefan Hajnoczi if (ret < 0) { 146877a5a000SStefan Hajnoczi s->header.image_size = old_image_size; 146977a5a000SStefan Hajnoczi } 147077a5a000SStefan Hajnoczi return ret; 147177a5a000SStefan Hajnoczi } 147277a5a000SStefan Hajnoczi 147375411d23SStefan Hajnoczi static int64_t bdrv_qed_getlength(BlockDriverState *bs) 147475411d23SStefan Hajnoczi { 147575411d23SStefan Hajnoczi BDRVQEDState *s = bs->opaque; 147675411d23SStefan Hajnoczi return s->header.image_size; 147775411d23SStefan Hajnoczi } 147875411d23SStefan Hajnoczi 147975411d23SStefan Hajnoczi static int bdrv_qed_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 148075411d23SStefan Hajnoczi { 148175411d23SStefan Hajnoczi BDRVQEDState *s = bs->opaque; 148275411d23SStefan Hajnoczi 148375411d23SStefan Hajnoczi memset(bdi, 0, sizeof(*bdi)); 148475411d23SStefan Hajnoczi bdi->cluster_size = s->header.cluster_size; 1485d68dbee8SDong Xu Wang bdi->is_dirty = s->header.features & QED_F_NEED_CHECK; 148695de6d70SPaolo Bonzini bdi->unallocated_blocks_are_zero = true; 148795de6d70SPaolo Bonzini bdi->can_write_zeroes_with_unmap = true; 148875411d23SStefan Hajnoczi return 0; 148975411d23SStefan Hajnoczi } 149075411d23SStefan Hajnoczi 149175411d23SStefan Hajnoczi static int bdrv_qed_change_backing_file(BlockDriverState *bs, 149275411d23SStefan Hajnoczi const char *backing_file, 149375411d23SStefan Hajnoczi const char *backing_fmt) 149475411d23SStefan Hajnoczi { 149575411d23SStefan Hajnoczi BDRVQEDState *s = bs->opaque; 149675411d23SStefan Hajnoczi QEDHeader new_header, le_header; 149775411d23SStefan Hajnoczi void *buffer; 149875411d23SStefan Hajnoczi size_t buffer_len, backing_file_len; 149975411d23SStefan Hajnoczi int ret; 150075411d23SStefan Hajnoczi 150175411d23SStefan Hajnoczi /* Refuse to set backing filename if unknown compat feature bits are 150275411d23SStefan Hajnoczi * active. If the image uses an unknown compat feature then we may not 150375411d23SStefan Hajnoczi * know the layout of data following the header structure and cannot safely 150475411d23SStefan Hajnoczi * add a new string. 150575411d23SStefan Hajnoczi */ 150675411d23SStefan Hajnoczi if (backing_file && (s->header.compat_features & 150775411d23SStefan Hajnoczi ~QED_COMPAT_FEATURE_MASK)) { 150875411d23SStefan Hajnoczi return -ENOTSUP; 150975411d23SStefan Hajnoczi } 151075411d23SStefan Hajnoczi 151175411d23SStefan Hajnoczi memcpy(&new_header, &s->header, sizeof(new_header)); 151275411d23SStefan Hajnoczi 151375411d23SStefan Hajnoczi new_header.features &= ~(QED_F_BACKING_FILE | 151475411d23SStefan Hajnoczi QED_F_BACKING_FORMAT_NO_PROBE); 151575411d23SStefan Hajnoczi 151675411d23SStefan Hajnoczi /* Adjust feature flags */ 151775411d23SStefan Hajnoczi if (backing_file) { 151875411d23SStefan Hajnoczi new_header.features |= QED_F_BACKING_FILE; 151975411d23SStefan Hajnoczi 152075411d23SStefan Hajnoczi if (qed_fmt_is_raw(backing_fmt)) { 152175411d23SStefan Hajnoczi new_header.features |= QED_F_BACKING_FORMAT_NO_PROBE; 152275411d23SStefan Hajnoczi } 152375411d23SStefan Hajnoczi } 152475411d23SStefan Hajnoczi 152575411d23SStefan Hajnoczi /* Calculate new header size */ 152675411d23SStefan Hajnoczi backing_file_len = 0; 152775411d23SStefan Hajnoczi 152875411d23SStefan Hajnoczi if (backing_file) { 152975411d23SStefan Hajnoczi backing_file_len = strlen(backing_file); 153075411d23SStefan Hajnoczi } 153175411d23SStefan Hajnoczi 153275411d23SStefan Hajnoczi buffer_len = sizeof(new_header); 153375411d23SStefan Hajnoczi new_header.backing_filename_offset = buffer_len; 153475411d23SStefan Hajnoczi new_header.backing_filename_size = backing_file_len; 153575411d23SStefan Hajnoczi buffer_len += backing_file_len; 153675411d23SStefan Hajnoczi 153775411d23SStefan Hajnoczi /* Make sure we can rewrite header without failing */ 153875411d23SStefan Hajnoczi if (buffer_len > new_header.header_size * new_header.cluster_size) { 153975411d23SStefan Hajnoczi return -ENOSPC; 154075411d23SStefan Hajnoczi } 154175411d23SStefan Hajnoczi 154275411d23SStefan Hajnoczi /* Prepare new header */ 15437267c094SAnthony Liguori buffer = g_malloc(buffer_len); 154475411d23SStefan Hajnoczi 154575411d23SStefan Hajnoczi qed_header_cpu_to_le(&new_header, &le_header); 154675411d23SStefan Hajnoczi memcpy(buffer, &le_header, sizeof(le_header)); 154775411d23SStefan Hajnoczi buffer_len = sizeof(le_header); 154875411d23SStefan Hajnoczi 1549feba23b1SPavel Borzenkov if (backing_file) { 155075411d23SStefan Hajnoczi memcpy(buffer + buffer_len, backing_file, backing_file_len); 155175411d23SStefan Hajnoczi buffer_len += backing_file_len; 1552feba23b1SPavel Borzenkov } 155375411d23SStefan Hajnoczi 155475411d23SStefan Hajnoczi /* Write new header */ 155575411d23SStefan Hajnoczi ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len); 15567267c094SAnthony Liguori g_free(buffer); 155775411d23SStefan Hajnoczi if (ret == 0) { 155875411d23SStefan Hajnoczi memcpy(&s->header, &new_header, sizeof(new_header)); 155975411d23SStefan Hajnoczi } 156075411d23SStefan Hajnoczi return ret; 156175411d23SStefan Hajnoczi } 156275411d23SStefan Hajnoczi 15635a8a30dbSKevin Wolf static void bdrv_qed_invalidate_cache(BlockDriverState *bs, Error **errp) 1564c82954e5SBenoît Canet { 1565c82954e5SBenoît Canet BDRVQEDState *s = bs->opaque; 15665a8a30dbSKevin Wolf Error *local_err = NULL; 15675a8a30dbSKevin Wolf int ret; 1568c82954e5SBenoît Canet 1569c82954e5SBenoît Canet bdrv_qed_close(bs); 15703456a8d1SKevin Wolf 15715a8a30dbSKevin Wolf bdrv_invalidate_cache(bs->file, &local_err); 15725a8a30dbSKevin Wolf if (local_err) { 15735a8a30dbSKevin Wolf error_propagate(errp, local_err); 15745a8a30dbSKevin Wolf return; 15755a8a30dbSKevin Wolf } 15763456a8d1SKevin Wolf 1577c82954e5SBenoît Canet memset(s, 0, sizeof(BDRVQEDState)); 15785a8a30dbSKevin Wolf ret = bdrv_qed_open(bs, NULL, bs->open_flags, &local_err); 15795a8a30dbSKevin Wolf if (local_err) { 15805a8a30dbSKevin Wolf error_setg(errp, "Could not reopen qed layer: %s", 15815a8a30dbSKevin Wolf error_get_pretty(local_err)); 15825a8a30dbSKevin Wolf error_free(local_err); 15835a8a30dbSKevin Wolf return; 15845a8a30dbSKevin Wolf } else if (ret < 0) { 15855a8a30dbSKevin Wolf error_setg_errno(errp, -ret, "Could not reopen qed layer"); 15865a8a30dbSKevin Wolf return; 15875a8a30dbSKevin Wolf } 1588c82954e5SBenoît Canet } 1589c82954e5SBenoît Canet 15904534ff54SKevin Wolf static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result, 15914534ff54SKevin Wolf BdrvCheckMode fix) 159275411d23SStefan Hajnoczi { 159301979a98SStefan Hajnoczi BDRVQEDState *s = bs->opaque; 159401979a98SStefan Hajnoczi 15954534ff54SKevin Wolf return qed_check(s, result, !!fix); 159675411d23SStefan Hajnoczi } 159775411d23SStefan Hajnoczi 159875411d23SStefan Hajnoczi static QEMUOptionParameter qed_create_options[] = { 159975411d23SStefan Hajnoczi { 160075411d23SStefan Hajnoczi .name = BLOCK_OPT_SIZE, 160175411d23SStefan Hajnoczi .type = OPT_SIZE, 160275411d23SStefan Hajnoczi .help = "Virtual disk size (in bytes)" 160375411d23SStefan Hajnoczi }, { 160475411d23SStefan Hajnoczi .name = BLOCK_OPT_BACKING_FILE, 160575411d23SStefan Hajnoczi .type = OPT_STRING, 160675411d23SStefan Hajnoczi .help = "File name of a base image" 160775411d23SStefan Hajnoczi }, { 160875411d23SStefan Hajnoczi .name = BLOCK_OPT_BACKING_FMT, 160975411d23SStefan Hajnoczi .type = OPT_STRING, 161075411d23SStefan Hajnoczi .help = "Image format of the base image" 161175411d23SStefan Hajnoczi }, { 161275411d23SStefan Hajnoczi .name = BLOCK_OPT_CLUSTER_SIZE, 161375411d23SStefan Hajnoczi .type = OPT_SIZE, 161499cce9faSKevin Wolf .help = "Cluster size (in bytes)", 161599cce9faSKevin Wolf .value = { .n = QED_DEFAULT_CLUSTER_SIZE }, 161675411d23SStefan Hajnoczi }, { 161775411d23SStefan Hajnoczi .name = BLOCK_OPT_TABLE_SIZE, 161875411d23SStefan Hajnoczi .type = OPT_SIZE, 161975411d23SStefan Hajnoczi .help = "L1/L2 table size (in clusters)" 162075411d23SStefan Hajnoczi }, 162175411d23SStefan Hajnoczi { /* end of list */ } 162275411d23SStefan Hajnoczi }; 162375411d23SStefan Hajnoczi 162475411d23SStefan Hajnoczi static BlockDriver bdrv_qed = { 162575411d23SStefan Hajnoczi .format_name = "qed", 162675411d23SStefan Hajnoczi .instance_size = sizeof(BDRVQEDState), 162775411d23SStefan Hajnoczi .create_options = qed_create_options, 162875411d23SStefan Hajnoczi 162975411d23SStefan Hajnoczi .bdrv_probe = bdrv_qed_probe, 1630e023b2e2SPaolo Bonzini .bdrv_rebind = bdrv_qed_rebind, 163175411d23SStefan Hajnoczi .bdrv_open = bdrv_qed_open, 163275411d23SStefan Hajnoczi .bdrv_close = bdrv_qed_close, 1633f9cb20f1SJeff Cody .bdrv_reopen_prepare = bdrv_qed_reopen_prepare, 163475411d23SStefan Hajnoczi .bdrv_create = bdrv_qed_create, 16353ac21627SPeter Lieven .bdrv_has_zero_init = bdrv_has_zero_init_1, 1636b6b8a333SPaolo Bonzini .bdrv_co_get_block_status = bdrv_qed_co_get_block_status, 163775411d23SStefan Hajnoczi .bdrv_aio_readv = bdrv_qed_aio_readv, 163875411d23SStefan Hajnoczi .bdrv_aio_writev = bdrv_qed_aio_writev, 16390e71be19SStefan Hajnoczi .bdrv_co_write_zeroes = bdrv_qed_co_write_zeroes, 164075411d23SStefan Hajnoczi .bdrv_truncate = bdrv_qed_truncate, 164175411d23SStefan Hajnoczi .bdrv_getlength = bdrv_qed_getlength, 164275411d23SStefan Hajnoczi .bdrv_get_info = bdrv_qed_get_info, 1643d34682cdSKevin Wolf .bdrv_refresh_limits = bdrv_qed_refresh_limits, 164475411d23SStefan Hajnoczi .bdrv_change_backing_file = bdrv_qed_change_backing_file, 1645c82954e5SBenoît Canet .bdrv_invalidate_cache = bdrv_qed_invalidate_cache, 164675411d23SStefan Hajnoczi .bdrv_check = bdrv_qed_check, 164775411d23SStefan Hajnoczi }; 164875411d23SStefan Hajnoczi 164975411d23SStefan Hajnoczi static void bdrv_qed_init(void) 165075411d23SStefan Hajnoczi { 165175411d23SStefan Hajnoczi bdrv_register(&bdrv_qed); 165275411d23SStefan Hajnoczi } 165375411d23SStefan Hajnoczi 165475411d23SStefan Hajnoczi block_init(bdrv_qed_init); 1655