qcow2: Rename BDRVQcowState to BDRVQcow2State

[qemu.git] / block / qcow2.c

diff --git a/block/qcow2.c b/block/qcow2.c
index d522ec7d14eaaba766e878dd6f0b6ece517332bd..9b09e01e2248a9f1f4520bbe9df23f2a51a0a251 100644 (file)
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -25,7 +25,6 @@
 #include "block/block_int.h"
 #include "qemu/module.h"
 #include <zlib.h>
 #include "block/block_int.h"
 #include "qemu/module.h"
 #include <zlib.h>

-#include "qemu/aes.h"

 #include "block/qcow2.h"
 #include "qemu/error-report.h"
 #include "qapi/qmp/qerror.h"
 #include "block/qcow2.h"
 #include "qemu/error-report.h"
 #include "qapi/qmp/qerror.h"


@@ -86,7 +85,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                                  uint64_t end_offset, void **p_feature_table,
                                  Error **errp)
 {
                                  uint64_t end_offset, void **p_feature_table,
                                  Error **errp)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     QCowExtension ext;
     uint64_t offset;
     int ret;
     QCowExtension ext;
     uint64_t offset;
     int ret;


@@ -188,7 +187,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
 
 static void cleanup_unknown_header_ext(BlockDriverState *bs)
 {
 
 static void cleanup_unknown_header_ext(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     Qcow2UnknownHeaderExtension *uext, *next;
 
     QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
     Qcow2UnknownHeaderExtension *uext, *next;
 
     QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {


@@ -250,7 +249,7 @@ static void report_unsupported_feature(BlockDriverState *bs,
  */
 int qcow2_mark_dirty(BlockDriverState *bs)
 {
  */
 int qcow2_mark_dirty(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     uint64_t val;
     int ret;
 
     uint64_t val;
     int ret;
 


@@ -283,7 +282,7 @@ int qcow2_mark_dirty(BlockDriverState *bs)
  */
 static int qcow2_mark_clean(BlockDriverState *bs)
 {
  */
 static int qcow2_mark_clean(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

 
     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
         int ret;
 
     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
         int ret;


@@ -305,7 +304,7 @@ static int qcow2_mark_clean(BlockDriverState *bs)
  */
 int qcow2_mark_corrupt(BlockDriverState *bs)
 {
  */
 int qcow2_mark_corrupt(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

 
     s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
     return qcow2_update_header(bs);
 
     s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
     return qcow2_update_header(bs);


@@ -317,7 +316,7 @@ int qcow2_mark_corrupt(BlockDriverState *bs)
  */
 int qcow2_mark_consistent(BlockDriverState *bs)
 {
  */
 int qcow2_mark_consistent(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

 
     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
         int ret = bdrv_flush(bs);
 
     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
         int ret = bdrv_flush(bs);


@@ -352,7 +351,7 @@ static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result,
 static int validate_table_offset(BlockDriverState *bs, uint64_t offset,
                                  uint64_t entries, size_t entry_len)
 {
 static int validate_table_offset(BlockDriverState *bs, uint64_t offset,
                                  uint64_t entries, size_t entry_len)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     uint64_t size;
 
     /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
     uint64_t size;
 
     /* Use signed INT64_MAX as the maximum even for uint64_t header fields,


@@ -468,6 +467,11 @@ static QemuOptsList qcow2_runtime_opts = {
             .type = QEMU_OPT_SIZE,
             .help = "Maximum refcount block cache size",
         },
             .type = QEMU_OPT_SIZE,
             .help = "Maximum refcount block cache size",
         },

+        {
+            .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL,
+            .type = QEMU_OPT_NUMBER,
+            .help = "Clean unused cache entries after this time (in seconds)",
+        },

         { /* end of list */ }
     },
 };
         { /* end of list */ }
     },
 };


@@ -483,11 +487,54 @@ static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = {
     [QCOW2_OL_INACTIVE_L2_BITNR]    = QCOW2_OPT_OVERLAP_INACTIVE_L2,
 };
 
     [QCOW2_OL_INACTIVE_L2_BITNR]    = QCOW2_OPT_OVERLAP_INACTIVE_L2,
 };
 

+static void cache_clean_timer_cb(void *opaque)
+{
+    BlockDriverState *bs = opaque;
+    BDRVQcow2State *s = bs->opaque;
+    qcow2_cache_clean_unused(bs, s->l2_table_cache);
+    qcow2_cache_clean_unused(bs, s->refcount_block_cache);
+    timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
+              (int64_t) s->cache_clean_interval * 1000);
+}
+
+static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context)
+{
+    BDRVQcow2State *s = bs->opaque;
+    if (s->cache_clean_interval > 0) {
+        s->cache_clean_timer = aio_timer_new(context, QEMU_CLOCK_VIRTUAL,
+                                             SCALE_MS, cache_clean_timer_cb,
+                                             bs);
+        timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
+                  (int64_t) s->cache_clean_interval * 1000);
+    }
+}
+
+static void cache_clean_timer_del(BlockDriverState *bs)
+{
+    BDRVQcow2State *s = bs->opaque;
+    if (s->cache_clean_timer) {
+        timer_del(s->cache_clean_timer);
+        timer_free(s->cache_clean_timer);
+        s->cache_clean_timer = NULL;
+    }
+}
+
+static void qcow2_detach_aio_context(BlockDriverState *bs)
+{
+    cache_clean_timer_del(bs);
+}
+
+static void qcow2_attach_aio_context(BlockDriverState *bs,
+                                     AioContext *new_context)
+{
+    cache_clean_timer_init(bs, new_context);
+}
+

 static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
                              uint64_t *l2_cache_size,
                              uint64_t *refcount_cache_size, Error **errp)
 {
 static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
                              uint64_t *l2_cache_size,
                              uint64_t *refcount_cache_size, Error **errp)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     uint64_t combined_cache_size;
     bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
 
     uint64_t combined_cache_size;
     bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
 


@@ -545,7 +592,7 @@ static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
 static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
                       Error **errp)
 {
 static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
                       Error **errp)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     unsigned int len, i;
     int ret = 0;
     QCowHeader header;
     unsigned int len, i;
     int ret = 0;
     QCowHeader header;


@@ -556,6 +603,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
     const char *opt_overlap_check, *opt_overlap_check_template;
     int overlap_check_template = 0;
     uint64_t l2_cache_size, refcount_cache_size;
     const char *opt_overlap_check, *opt_overlap_check_template;
     int overlap_check_template = 0;
     uint64_t l2_cache_size, refcount_cache_size;

+    uint64_t cache_clean_interval;

 
     ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
     if (ret < 0) {
 
     ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
     if (ret < 0) {


@@ -699,6 +747,11 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         ret = -EINVAL;
         goto fail;
     }
         ret = -EINVAL;
         goto fail;
     }

+    if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALG_AES_128)) {
+        error_setg(errp, "AES cipher not available");
+        ret = -EINVAL;
+        goto fail;
+    }

     s->crypt_method_header = header.crypt_method;
     if (s->crypt_method_header) {
         bs->encrypted = 1;
     s->crypt_method_header = header.crypt_method;
     if (s->crypt_method_header) {
         bs->encrypted = 1;


@@ -844,6 +897,16 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
         goto fail;
     }
 

+    cache_clean_interval =
+        qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL, 0);
+    if (cache_clean_interval > UINT_MAX) {
+        error_setg(errp, "Cache clean interval too big");
+        ret = -EINVAL;
+        goto fail;
+    }
+    s->cache_clean_interval = cache_clean_interval;
+    cache_clean_timer_init(bs, bdrv_get_aio_context(bs));
+

     s->cluster_cache = g_malloc(s->cluster_size);
     /* one more sector for decompressed data alignment */
     s->cluster_data = qemu_try_blockalign(bs->file, QCOW_MAX_CRYPT_CLUSTERS
     s->cluster_cache = g_malloc(s->cluster_size);
     /* one more sector for decompressed data alignment */
     s->cluster_data = qemu_try_blockalign(bs->file, QCOW_MAX_CRYPT_CLUSTERS


@@ -1009,6 +1072,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
     qemu_vfree(s->l1_table);
     /* else pre-write overlap checks in cache_destroy may crash */
     s->l1_table = NULL;
     qemu_vfree(s->l1_table);
     /* else pre-write overlap checks in cache_destroy may crash */
     s->l1_table = NULL;

+    cache_clean_timer_del(bs);

     if (s->l2_table_cache) {
         qcow2_cache_destroy(bs, s->l2_table_cache);
     }
     if (s->l2_table_cache) {
         qcow2_cache_destroy(bs, s->l2_table_cache);
     }


@@ -1022,16 +1086,17 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
 
 static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
 {
 
 static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

 
     bs->bl.write_zeroes_alignment = s->cluster_sectors;
 }
 
 static int qcow2_set_key(BlockDriverState *bs, const char *key)
 {
 
     bs->bl.write_zeroes_alignment = s->cluster_sectors;
 }
 
 static int qcow2_set_key(BlockDriverState *bs, const char *key)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     uint8_t keybuf[16];
     int len, i;
     uint8_t keybuf[16];
     int len, i;

+    Error *err = NULL;

 
     memset(keybuf, 0, 16);
     len = strlen(key);
 
     memset(keybuf, 0, 16);
     len = strlen(key);


@@ -1043,30 +1108,21 @@ static int qcow2_set_key(BlockDriverState *bs, const char *key)
         keybuf[i] = key[i];
     }
     assert(bs->encrypted);
         keybuf[i] = key[i];
     }
     assert(bs->encrypted);

-    s->crypt_method = s->crypt_method_header;

 
 

-    if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0)
-        return -1;
-    if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0)
+    qcrypto_cipher_free(s->cipher);
+    s->cipher = qcrypto_cipher_new(
+        QCRYPTO_CIPHER_ALG_AES_128,
+        QCRYPTO_CIPHER_MODE_CBC,
+        keybuf, G_N_ELEMENTS(keybuf),
+        &err);
+
+    if (!s->cipher) {
+        /* XXX would be nice if errors in this method could
+         * be properly propagate to the caller. Would need
+         * the bdrv_set_key() API signature to be fixed. */
+        error_free(err);

         return -1;
         return -1;

-#if 0
-    /* test */
-    {
-        uint8_t in[16];
-        uint8_t out[16];
-        uint8_t tmp[16];
-        for(i=0;i<16;i++)
-            in[i] = i;
-        AES_encrypt(in, tmp, &s->aes_encrypt_key);
-        AES_decrypt(tmp, out, &s->aes_decrypt_key);
-        for(i = 0; i < 16; i++)
-            printf(" %02x", tmp[i]);
-        printf("\n");
-        for(i = 0; i < 16; i++)
-            printf(" %02x", out[i]);
-        printf("\n");

     }
     }

-#endif

     return 0;
 }
 
     return 0;
 }
 


@@ -1095,7 +1151,7 @@ static int qcow2_reopen_prepare(BDRVReopenState *state,
 static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
         int64_t sector_num, int nb_sectors, int *pnum)
 {
 static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
         int64_t sector_num, int nb_sectors, int *pnum)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     uint64_t cluster_offset;
     int index_in_cluster, ret;
     int64_t status = 0;
     uint64_t cluster_offset;
     int index_in_cluster, ret;
     int64_t status = 0;


@@ -1109,7 +1165,7 @@ static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
     }
 
     if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&
     }
 
     if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&

-        !s->crypt_method) {
+        !s->cipher) {

         index_in_cluster = sector_num & (s->cluster_sectors - 1);
         cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
         status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset;
         index_in_cluster = sector_num & (s->cluster_sectors - 1);
         cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
         status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset;


@@ -1142,7 +1198,7 @@ int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
 static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
                           int remaining_sectors, QEMUIOVector *qiov)
 {
 static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
                           int remaining_sectors, QEMUIOVector *qiov)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int index_in_cluster, n1;
     int ret;
     int cur_nr_sectors; /* number of sectors in current iteration */
     int index_in_cluster, n1;
     int ret;
     int cur_nr_sectors; /* number of sectors in current iteration */


@@ -1159,7 +1215,7 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
 
         /* prepare next request */
         cur_nr_sectors = remaining_sectors;
 
         /* prepare next request */
         cur_nr_sectors = remaining_sectors;

-        if (s->crypt_method) {
+        if (s->cipher) {

             cur_nr_sectors = MIN(cur_nr_sectors,
                 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
         }
             cur_nr_sectors = MIN(cur_nr_sectors,
                 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
         }


@@ -1231,7 +1287,7 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
             }
 
             if (bs->encrypted) {
             }
 
             if (bs->encrypted) {

-                assert(s->crypt_method);
+                assert(s->cipher);

 
                 /*
                  * For encrypted images, read everything into a temporary
 
                 /*
                  * For encrypted images, read everything into a temporary


@@ -1264,9 +1320,15 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
                 goto fail;
             }
             if (bs->encrypted) {
                 goto fail;
             }
             if (bs->encrypted) {

-                assert(s->crypt_method);
-                qcow2_encrypt_sectors(s, sector_num,  cluster_data,
-                    cluster_data, cur_nr_sectors, 0, &s->aes_decrypt_key);
+                assert(s->cipher);
+                Error *err = NULL;
+                if (qcow2_encrypt_sectors(s, sector_num,  cluster_data,
+                                          cluster_data, cur_nr_sectors, false,
+                                          &err) < 0) {
+                    error_free(err);
+                    ret = -EIO;
+                    goto fail;
+                }

                 qemu_iovec_from_buf(qiov, bytes_done,
                     cluster_data, 512 * cur_nr_sectors);
             }
                 qemu_iovec_from_buf(qiov, bytes_done,
                     cluster_data, 512 * cur_nr_sectors);
             }


@@ -1298,7 +1360,7 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
                            int remaining_sectors,
                            QEMUIOVector *qiov)
 {
                            int remaining_sectors,
                            QEMUIOVector *qiov)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int index_in_cluster;
     int ret;
     int cur_nr_sectors; /* number of sectors in current iteration */
     int index_in_cluster;
     int ret;
     int cur_nr_sectors; /* number of sectors in current iteration */


@@ -1344,7 +1406,8 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
             cur_nr_sectors * 512);
 
         if (bs->encrypted) {
             cur_nr_sectors * 512);
 
         if (bs->encrypted) {

-            assert(s->crypt_method);
+            Error *err = NULL;
+            assert(s->cipher);

             if (!cluster_data) {
                 cluster_data = qemu_try_blockalign(bs->file,
                                                    QCOW_MAX_CRYPT_CLUSTERS
             if (!cluster_data) {
                 cluster_data = qemu_try_blockalign(bs->file,
                                                    QCOW_MAX_CRYPT_CLUSTERS


@@ -1359,8 +1422,13 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
             qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
 
                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
             qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
 

-            qcow2_encrypt_sectors(s, sector_num, cluster_data,
-                cluster_data, cur_nr_sectors, 1, &s->aes_encrypt_key);
+            if (qcow2_encrypt_sectors(s, sector_num, cluster_data,
+                                      cluster_data, cur_nr_sectors,
+                                      true, &err) < 0) {
+                error_free(err);
+                ret = -EIO;
+                goto fail;
+            }

 
             qemu_iovec_reset(&hd_qiov);
             qemu_iovec_add(&hd_qiov, cluster_data,
 
             qemu_iovec_reset(&hd_qiov);
             qemu_iovec_add(&hd_qiov, cluster_data,


@@ -1438,7 +1506,7 @@ fail:
 
 static void qcow2_close(BlockDriverState *bs)
 {
 
 static void qcow2_close(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     qemu_vfree(s->l1_table);
     /* else pre-write overlap checks in cache_destroy may crash */
     s->l1_table = NULL;
     qemu_vfree(s->l1_table);
     /* else pre-write overlap checks in cache_destroy may crash */
     s->l1_table = NULL;


@@ -1463,9 +1531,13 @@ static void qcow2_close(BlockDriverState *bs)
         }
     }
 
         }
     }
 

+    cache_clean_timer_del(bs);

     qcow2_cache_destroy(bs, s->l2_table_cache);
     qcow2_cache_destroy(bs, s->refcount_block_cache);
 
     qcow2_cache_destroy(bs, s->l2_table_cache);
     qcow2_cache_destroy(bs, s->refcount_block_cache);
 

+    qcrypto_cipher_free(s->cipher);
+    s->cipher = NULL;
+

     g_free(s->unknown_header_fields);
     cleanup_unknown_header_ext(bs);
 
     g_free(s->unknown_header_fields);
     cleanup_unknown_header_ext(bs);
 


@@ -1480,11 +1552,9 @@ static void qcow2_close(BlockDriverState *bs)
 
 static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
 {
 
 static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int flags = s->flags;
     int flags = s->flags;

-    AES_KEY aes_encrypt_key;
-    AES_KEY aes_decrypt_key;
-    uint32_t crypt_method = 0;
+    QCryptoCipher *cipher = NULL;

     QDict *options;
     Error *local_err = NULL;
     int ret;
     QDict *options;
     Error *local_err = NULL;
     int ret;


@@ -1494,12 +1564,8 @@ static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
      * that means we don't have to worry about reopening them here.
      */
 
      * that means we don't have to worry about reopening them here.
      */
 

-    if (bs->encrypted) {
-        assert(s->crypt_method);
-        crypt_method = s->crypt_method;
-        memcpy(&aes_encrypt_key, &s->aes_encrypt_key, sizeof(aes_encrypt_key));
-        memcpy(&aes_decrypt_key, &s->aes_decrypt_key, sizeof(aes_decrypt_key));
-    }
+    cipher = s->cipher;
+    s->cipher = NULL;

 
     qcow2_close(bs);
 
 
     qcow2_close(bs);
 


@@ -1509,7 +1575,7 @@ static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
         return;
     }
 
         return;
     }
 

-    memset(s, 0, sizeof(BDRVQcowState));
+    memset(s, 0, sizeof(BDRVQcow2State));

     options = qdict_clone_shallow(bs->options);
 
     ret = qcow2_open(bs, options, flags, &local_err);
     options = qdict_clone_shallow(bs->options);
 
     ret = qcow2_open(bs, options, flags, &local_err);


@@ -1524,11 +1590,7 @@ static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
         return;
     }
 
         return;
     }
 

-    if (bs->encrypted) {
-        s->crypt_method = crypt_method;
-        memcpy(&s->aes_encrypt_key, &aes_encrypt_key, sizeof(aes_encrypt_key));
-        memcpy(&s->aes_decrypt_key, &aes_decrypt_key, sizeof(aes_decrypt_key));
-    }
+    s->cipher = cipher;

 }
 
 static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
 }
 
 static size_t header_ext_add(char *buf, uint32_t magic, const void *s,


@@ -1560,7 +1622,7 @@ static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
  */
 int qcow2_update_header(BlockDriverState *bs)
 {
  */
 int qcow2_update_header(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     QCowHeader *header;
     char *buf;
     size_t buflen = s->cluster_size;
     QCowHeader *header;
     char *buf;
     size_t buflen = s->cluster_size;


@@ -1729,7 +1791,7 @@ fail:
 static int qcow2_change_backing_file(BlockDriverState *bs,
     const char *backing_file, const char *backing_fmt)
 {
 static int qcow2_change_backing_file(BlockDriverState *bs,
     const char *backing_file, const char *backing_fmt)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

 
     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
     pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
 
     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
     pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");


@@ -1811,8 +1873,10 @@ static int qcow2_create2(const char *filename, int64_t total_size,
                          QemuOpts *opts, int version, int refcount_order,
                          Error **errp)
 {
                          QemuOpts *opts, int version, int refcount_order,
                          Error **errp)
 {

-    /* Calculate cluster_bits */

     int cluster_bits;
     int cluster_bits;

+    QDict *options;
+
+    /* Calculate cluster_bits */

     cluster_bits = ctz32(cluster_size);
     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
         (1 << cluster_bits) != cluster_size)
     cluster_bits = ctz32(cluster_size);
     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
         (1 << cluster_bits) != cluster_size)


@@ -1911,7 +1975,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,
 
     bs = NULL;
     ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
 
     bs = NULL;
     ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,

-                    NULL, &local_err);
+                    &local_err);

     if (ret < 0) {
         error_propagate(errp, local_err);
         return ret;
     if (ret < 0) {
         error_propagate(errp, local_err);
         return ret;


@@ -1970,9 +2034,11 @@ static int qcow2_create2(const char *filename, int64_t total_size,
      * refcount of the cluster that is occupied by the header and the refcount
      * table)
      */
      * refcount of the cluster that is occupied by the header and the refcount
      * table)
      */

-    ret = bdrv_open(&bs, filename, NULL, NULL,
+    options = qdict_new();
+    qdict_put(options, "driver", qstring_from_str("qcow2"));
+    ret = bdrv_open(&bs, filename, NULL, options,

                     BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH,
                     BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH,

-                    &bdrv_qcow2, &local_err);
+                    &local_err);

     if (ret < 0) {
         error_propagate(errp, local_err);
         goto out;
     if (ret < 0) {
         error_propagate(errp, local_err);
         goto out;


@@ -2008,7 +2074,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,
 
     /* And if we're supposed to preallocate metadata, do that now */
     if (prealloc != PREALLOC_MODE_OFF) {
 
     /* And if we're supposed to preallocate metadata, do that now */
     if (prealloc != PREALLOC_MODE_OFF) {

-        BDRVQcowState *s = bs->opaque;
+        BDRVQcow2State *s = bs->opaque;

         qemu_co_mutex_lock(&s->lock);
         ret = preallocate(bs);
         qemu_co_mutex_unlock(&s->lock);
         qemu_co_mutex_lock(&s->lock);
         ret = preallocate(bs);
         qemu_co_mutex_unlock(&s->lock);


@@ -2022,9 +2088,11 @@ static int qcow2_create2(const char *filename, int64_t total_size,
     bs = NULL;
 
     /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */
     bs = NULL;
 
     /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */

-    ret = bdrv_open(&bs, filename, NULL, NULL,
+    options = qdict_new();
+    qdict_put(options, "driver", qstring_from_str("qcow2"));
+    ret = bdrv_open(&bs, filename, NULL, options,

                     BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_BACKING,
                     BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_BACKING,

-                    &bdrv_qcow2, &local_err);
+                    &local_err);

     if (local_err) {
         error_propagate(errp, local_err);
         goto out;
     if (local_err) {
         error_propagate(errp, local_err);
         goto out;


@@ -2141,7 +2209,7 @@ static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs,
     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
 {
     int ret;
     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
 {
     int ret;

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

 
     /* Emulate misaligned zero writes */
     if (sector_num % s->cluster_sectors || nb_sectors % s->cluster_sectors) {
 
     /* Emulate misaligned zero writes */
     if (sector_num % s->cluster_sectors || nb_sectors % s->cluster_sectors) {


@@ -2161,7 +2229,7 @@ static coroutine_fn int qcow2_co_discard(BlockDriverState *bs,
     int64_t sector_num, int nb_sectors)
 {
     int ret;
     int64_t sector_num, int nb_sectors)
 {
     int ret;

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

 
     qemu_co_mutex_lock(&s->lock);
     ret = qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS,
 
     qemu_co_mutex_lock(&s->lock);
     ret = qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS,


@@ -2172,7 +2240,7 @@ static coroutine_fn int qcow2_co_discard(BlockDriverState *bs,
 
 static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
 {
 
 static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int64_t new_l1_size;
     int ret;
 
     int64_t new_l1_size;
     int ret;
 


@@ -2216,7 +2284,7 @@ static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
 static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
                                   const uint8_t *buf, int nb_sectors)
 {
 static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
                                   const uint8_t *buf, int nb_sectors)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     z_stream strm;
     int ret, out_len;
     uint8_t *out_buf;
     z_stream strm;
     int ret, out_len;
     uint8_t *out_buf;


@@ -2307,7 +2375,7 @@ fail:
 
 static int make_completely_empty(BlockDriverState *bs)
 {
 
 static int make_completely_empty(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int ret, l1_clusters;
     int64_t offset;
     uint64_t *new_reftable = NULL;
     int ret, l1_clusters;
     int64_t offset;
     uint64_t *new_reftable = NULL;


@@ -2455,7 +2523,7 @@ fail:
 
 static int qcow2_make_empty(BlockDriverState *bs)
 {
 
 static int qcow2_make_empty(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     uint64_t start_sector;
     int sector_step = INT_MAX / BDRV_SECTOR_SIZE;
     int l1_clusters, ret = 0;
     uint64_t start_sector;
     int sector_step = INT_MAX / BDRV_SECTOR_SIZE;
     int l1_clusters, ret = 0;


@@ -2496,7 +2564,7 @@ static int qcow2_make_empty(BlockDriverState *bs)
 
 static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
 {
 
 static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int ret;
 
     qemu_co_mutex_lock(&s->lock);
     int ret;
 
     qemu_co_mutex_lock(&s->lock);


@@ -2520,7 +2588,7 @@ static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
 
 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 {
 
 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     bdi->unallocated_blocks_are_zero = true;
     bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3);
     bdi->cluster_size = s->cluster_size;
     bdi->unallocated_blocks_are_zero = true;
     bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3);
     bdi->cluster_size = s->cluster_size;


@@ -2530,7 +2598,7 @@ static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 
 static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
 {
 
 static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);
 
     *spec_info = (ImageInfoSpecific){
     ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);
 
     *spec_info = (ImageInfoSpecific){


@@ -2563,7 +2631,7 @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
 #if 0
 static void dump_refcounts(BlockDriverState *bs)
 {
 #if 0
 static void dump_refcounts(BlockDriverState *bs)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int64_t nb_clusters, k, k1, size;
     int refcount;
 
     int64_t nb_clusters, k, k1, size;
     int refcount;
 


@@ -2584,7 +2652,7 @@ static void dump_refcounts(BlockDriverState *bs)
 static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
                               int64_t pos)
 {
 static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
                               int64_t pos)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int64_t total_sectors = bs->total_sectors;
     bool zero_beyond_eof = bs->zero_beyond_eof;
     int ret;
     int64_t total_sectors = bs->total_sectors;
     bool zero_beyond_eof = bs->zero_beyond_eof;
     int ret;


@@ -2605,7 +2673,7 @@ static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
 static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                               int64_t pos, int size)
 {
 static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                               int64_t pos, int size)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     bool zero_beyond_eof = bs->zero_beyond_eof;
     int ret;
 
     bool zero_beyond_eof = bs->zero_beyond_eof;
     int ret;
 


@@ -2624,7 +2692,7 @@ static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,
 static int qcow2_downgrade(BlockDriverState *bs, int target_version,
                            BlockDriverAmendStatusCB *status_cb)
 {
 static int qcow2_downgrade(BlockDriverState *bs, int target_version,
                            BlockDriverAmendStatusCB *status_cb)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int current_version = s->qcow_version;
     int ret;
 
     int current_version = s->qcow_version;
     int ret;
 


@@ -2688,7 +2756,7 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version,
 static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
                                BlockDriverAmendStatusCB *status_cb)
 {
 static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
                                BlockDriverAmendStatusCB *status_cb)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     int old_version = s->qcow_version, new_version = old_version;
     uint64_t new_size = 0;
     const char *backing_file = NULL, *backing_format = NULL;
     int old_version = s->qcow_version, new_version = old_version;
     uint64_t new_size = 0;
     const char *backing_file = NULL, *backing_format = NULL;


@@ -2729,8 +2797,9 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
             backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
         } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) {
             encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT,
             backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
         } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) {
             encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT,

-                                        s->crypt_method);
-            if (encrypt != !!s->crypt_method) {
+                                        !!s->cipher);
+
+            if (encrypt != !!s->cipher) {

                 fprintf(stderr, "Changing the encryption flag is not "
                         "supported.\n");
                 return -ENOTSUP;
                 fprintf(stderr, "Changing the encryption flag is not "
                         "supported.\n");
                 return -ENOTSUP;


@@ -2834,7 +2903,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
 void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
                              int64_t size, const char *message_format, ...)
 {
 void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
                              int64_t size, const char *message_format, ...)
 {

-    BDRVQcowState *s = bs->opaque;
+    BDRVQcow2State *s = bs->opaque;

     const char *node_name;
     char *message;
     va_list ap;
     const char *node_name;
     char *message;
     va_list ap;


@@ -2935,7 +3004,7 @@ static QemuOptsList qcow2_create_opts = {
 
 BlockDriver bdrv_qcow2 = {
     .format_name        = "qcow2",
 
 BlockDriver bdrv_qcow2 = {
     .format_name        = "qcow2",

-    .instance_size      = sizeof(BDRVQcowState),
+    .instance_size      = sizeof(BDRVQcow2State),

     .bdrv_probe         = qcow2_probe,
     .bdrv_open          = qcow2_open,
     .bdrv_close         = qcow2_close,
     .bdrv_probe         = qcow2_probe,
     .bdrv_open          = qcow2_open,
     .bdrv_close         = qcow2_close,


@@ -2975,6 +3044,9 @@ BlockDriver bdrv_qcow2 = {
     .create_opts         = &qcow2_create_opts,
     .bdrv_check          = qcow2_check,
     .bdrv_amend_options  = qcow2_amend_options,
     .create_opts         = &qcow2_create_opts,
     .bdrv_check          = qcow2_check,
     .bdrv_amend_options  = qcow2_amend_options,

+
+    .bdrv_detach_aio_context  = qcow2_detach_aio_context,
+    .bdrv_attach_aio_context  = qcow2_attach_aio_context,

 };
 
 static void bdrv_qcow2_init(void)
 };
 
 static void bdrv_qcow2_init(void)