block/crypto.c

   1 /*
   2  * QEMU block full disk encryption
   3  *
   4  * Copyright (c) 2015-2016 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22
  23 #include "block/block_int.h"
  24 #include "block/qdict.h"
  25 #include "sysemu/block-backend.h"
  26 #include "crypto/block.h"
  27 #include "qapi/opts-visitor.h"
  28 #include "qapi/qapi-visit-crypto.h"
  29 #include "qapi/qobject-input-visitor.h"
  30 #include "qapi/error.h"
  31 #include "qemu/module.h"
  32 #include "qemu/option.h"
  33 #include "crypto.h"
  34
  35 typedef struct BlockCrypto BlockCrypto;
  36
  37 struct BlockCrypto {
  38     QCryptoBlock *block;
  39 };
  40
  41
  42 static int block_crypto_probe_generic(QCryptoBlockFormat format,
  43                                       const uint8_t *buf,
  44                                       int buf_size,
  45                                       const char *filename)
  46 {
  47     if (qcrypto_block_has_format(format, buf, buf_size)) {
  48         return 100;
  49     } else {
  50         return 0;
  51     }
  52 }
  53
  54
  55 static ssize_t block_crypto_read_func(QCryptoBlock *block,
  56                                       size_t offset,
  57                                       uint8_t *buf,
  58                                       size_t buflen,
  59                                       void *opaque,
  60                                       Error **errp)
  61 {
  62     BlockDriverState *bs = opaque;
  63     ssize_t ret;
  64
  65     ret = bdrv_pread(bs->file, offset, buf, buflen);
  66     if (ret < 0) {
  67         error_setg_errno(errp, -ret, "Could not read encryption header");
  68         return ret;
  69     }
  70     return ret;
  71 }
  72
  73
  74 struct BlockCryptoCreateData {
  75     BlockBackend *blk;
  76     uint64_t size;
  77     PreallocMode prealloc;
  78 };
  79
  80
  81 static ssize_t block_crypto_write_func(QCryptoBlock *block,
  82                                        size_t offset,
  83                                        const uint8_t *buf,
  84                                        size_t buflen,
  85                                        void *opaque,
  86                                        Error **errp)
  87 {
  88     struct BlockCryptoCreateData *data = opaque;
  89     ssize_t ret;
  90
  91     ret = blk_pwrite(data->blk, offset, buf, buflen, 0);
  92     if (ret < 0) {
  93         error_setg_errno(errp, -ret, "Could not write encryption header");
  94         return ret;
  95     }
  96     return ret;
  97 }
  98
  99
 100 static ssize_t block_crypto_init_func(QCryptoBlock *block,
 101                                       size_t headerlen,
 102                                       void *opaque,
 103                                       Error **errp)
 104 {
 105     struct BlockCryptoCreateData *data = opaque;
 106
 107     if (data->size > INT64_MAX || headerlen > INT64_MAX - data->size) {
 108         error_setg(errp, "The requested file size is too large");
 109         return -EFBIG;
 110     }
 111
 112     /* User provided size should reflect amount of space made
 113      * available to the guest, so we must take account of that
 114      * which will be used by the crypto header
 115      */
 116     return blk_truncate(data->blk, data->size + headerlen, false,
 117                         data->prealloc, errp);
 118 }
 119
 120
 121 static QemuOptsList block_crypto_runtime_opts_luks = {
 122     .name = "crypto",
 123     .head = QTAILQ_HEAD_INITIALIZER(block_crypto_runtime_opts_luks.head),
 124     .desc = {
 125         BLOCK_CRYPTO_OPT_DEF_LUKS_KEY_SECRET(""),
 126         { /* end of list */ }
 127     },
 128 };
 129
 130
 131 static QemuOptsList block_crypto_create_opts_luks = {
 132     .name = "crypto",
 133     .head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head),
 134     .desc = {
 135         {
 136             .name = BLOCK_OPT_SIZE,
 137             .type = QEMU_OPT_SIZE,
 138             .help = "Virtual disk size"
 139         },
 140         BLOCK_CRYPTO_OPT_DEF_LUKS_KEY_SECRET(""),
 141         BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG(""),
 142         BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE(""),
 143         BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG(""),
 144         BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG(""),
 145         BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG(""),
 146         BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME(""),
 147         { /* end of list */ }
 148     },
 149 };
 150
 151
 152 QCryptoBlockOpenOptions *
 153 block_crypto_open_opts_init(QDict *opts, Error **errp)
 154 {
 155     Visitor *v;
 156     QCryptoBlockOpenOptions *ret;
 157
 158     v = qobject_input_visitor_new_flat_confused(opts, errp);
 159     if (!v) {
 160         return NULL;
 161     }
 162
 163     visit_type_QCryptoBlockOpenOptions(v, NULL, &ret, errp);
 164
 165     visit_free(v);
 166     return ret;
 167 }
 168
 169
 170 QCryptoBlockCreateOptions *
 171 block_crypto_create_opts_init(QDict *opts, Error **errp)
 172 {
 173     Visitor *v;
 174     QCryptoBlockCreateOptions *ret;
 175
 176     v = qobject_input_visitor_new_flat_confused(opts, errp);
 177     if (!v) {
 178         return NULL;
 179     }
 180
 181     visit_type_QCryptoBlockCreateOptions(v, NULL, &ret, errp);
 182
 183     visit_free(v);
 184     return ret;
 185 }
 186
 187
 188 static int block_crypto_open_generic(QCryptoBlockFormat format,
 189                                      QemuOptsList *opts_spec,
 190                                      BlockDriverState *bs,
 191                                      QDict *options,
 192                                      int flags,
 193                                      Error **errp)
 194 {
 195     BlockCrypto *crypto = bs->opaque;
 196     QemuOpts *opts = NULL;
 197     Error *local_err = NULL;
 198     int ret = -EINVAL;
 199     QCryptoBlockOpenOptions *open_opts = NULL;
 200     unsigned int cflags = 0;
 201     QDict *cryptoopts = NULL;
 202
 203     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 204                                false, errp);
 205     if (!bs->file) {
 206         return -EINVAL;
 207     }
 208
 209     bs->supported_write_flags = BDRV_REQ_FUA &
 210         bs->file->bs->supported_write_flags;
 211
 212     opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
 213     qemu_opts_absorb_qdict(opts, options, &local_err);
 214     if (local_err) {
 215         error_propagate(errp, local_err);
 216         goto cleanup;
 217     }
 218
 219     cryptoopts = qemu_opts_to_qdict(opts, NULL);
 220     qdict_put_str(cryptoopts, "format", QCryptoBlockFormat_str(format));
 221
 222     open_opts = block_crypto_open_opts_init(cryptoopts, errp);
 223     if (!open_opts) {
 224         goto cleanup;
 225     }
 226
 227     if (flags & BDRV_O_NO_IO) {
 228         cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
 229     }
 230     crypto->block = qcrypto_block_open(open_opts, NULL,
 231                                        block_crypto_read_func,
 232                                        bs,
 233                                        cflags,
 234                                        1,
 235                                        errp);
 236
 237     if (!crypto->block) {
 238         ret = -EIO;
 239         goto cleanup;
 240     }
 241
 242     bs->encrypted = true;
 243
 244     ret = 0;
 245  cleanup:
 246     qobject_unref(cryptoopts);
 247     qapi_free_QCryptoBlockOpenOptions(open_opts);
 248     return ret;
 249 }
 250
 251
 252 static int block_crypto_co_create_generic(BlockDriverState *bs,
 253                                           int64_t size,
 254                                           QCryptoBlockCreateOptions *opts,
 255                                           PreallocMode prealloc,
 256                                           Error **errp)
 257 {
 258     int ret;
 259     BlockBackend *blk;
 260     QCryptoBlock *crypto = NULL;
 261     struct BlockCryptoCreateData data;
 262
 263     blk = blk_new(bdrv_get_aio_context(bs),
 264                   BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 265
 266     ret = blk_insert_bs(blk, bs, errp);
 267     if (ret < 0) {
 268         goto cleanup;
 269     }
 270
 271     if (prealloc == PREALLOC_MODE_METADATA) {
 272         prealloc = PREALLOC_MODE_OFF;
 273     }
 274
 275     data = (struct BlockCryptoCreateData) {
 276         .blk = blk,
 277         .size = size,
 278         .prealloc = prealloc,
 279     };
 280
 281     crypto = qcrypto_block_create(opts, NULL,
 282                                   block_crypto_init_func,
 283                                   block_crypto_write_func,
 284                                   &data,
 285                                   errp);
 286
 287     if (!crypto) {
 288         ret = -EIO;
 289         goto cleanup;
 290     }
 291
 292     ret = 0;
 293  cleanup:
 294     qcrypto_block_free(crypto);
 295     blk_unref(blk);
 296     return ret;
 297 }
 298
 299 static int coroutine_fn
 300 block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 301                          PreallocMode prealloc, Error **errp)
 302 {
 303     BlockCrypto *crypto = bs->opaque;
 304     uint64_t payload_offset =
 305         qcrypto_block_get_payload_offset(crypto->block);
 306
 307     if (payload_offset > INT64_MAX - offset) {
 308         error_setg(errp, "The requested file size is too large");
 309         return -EFBIG;
 310     }
 311
 312     offset += payload_offset;
 313
 314     return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
 315 }
 316
 317 static void block_crypto_close(BlockDriverState *bs)
 318 {
 319     BlockCrypto *crypto = bs->opaque;
 320     qcrypto_block_free(crypto->block);
 321 }
 322
 323 static int block_crypto_reopen_prepare(BDRVReopenState *state,
 324                                        BlockReopenQueue *queue, Error **errp)
 325 {
 326     /* nothing needs checking */
 327     return 0;
 328 }
 329
 330 /*
 331  * 1 MB bounce buffer gives good performance / memory tradeoff
 332  * when using cache=none|directsync.
 333  */
 334 #define BLOCK_CRYPTO_MAX_IO_SIZE (1024 * 1024)
 335
 336 static coroutine_fn int
 337 block_crypto_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 338                        QEMUIOVector *qiov, int flags)
 339 {
 340     BlockCrypto *crypto = bs->opaque;
 341     uint64_t cur_bytes; /* number of bytes in current iteration */
 342     uint64_t bytes_done = 0;
 343     uint8_t *cipher_data = NULL;
 344     QEMUIOVector hd_qiov;
 345     int ret = 0;
 346     uint64_t sector_size = qcrypto_block_get_sector_size(crypto->block);
 347     uint64_t payload_offset = qcrypto_block_get_payload_offset(crypto->block);
 348
 349     assert(!flags);
 350     assert(payload_offset < INT64_MAX);
 351     assert(QEMU_IS_ALIGNED(offset, sector_size));
 352     assert(QEMU_IS_ALIGNED(bytes, sector_size));
 353
 354     qemu_iovec_init(&hd_qiov, qiov->niov);
 355
 356     /* Bounce buffer because we don't wish to expose cipher text
 357      * in qiov which points to guest memory.
 358      */
 359     cipher_data =
 360         qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_IO_SIZE,
 361                                               qiov->size));
 362     if (cipher_data == NULL) {
 363         ret = -ENOMEM;
 364         goto cleanup;
 365     }
 366
 367     while (bytes) {
 368         cur_bytes = MIN(bytes, BLOCK_CRYPTO_MAX_IO_SIZE);
 369
 370         qemu_iovec_reset(&hd_qiov);
 371         qemu_iovec_add(&hd_qiov, cipher_data, cur_bytes);
 372
 373         ret = bdrv_co_preadv(bs->file, payload_offset + offset + bytes_done,
 374                              cur_bytes, &hd_qiov, 0);
 375         if (ret < 0) {
 376             goto cleanup;
 377         }
 378
 379         if (qcrypto_block_decrypt(crypto->block, offset + bytes_done,
 380                                   cipher_data, cur_bytes, NULL) < 0) {
 381             ret = -EIO;
 382             goto cleanup;
 383         }
 384
 385         qemu_iovec_from_buf(qiov, bytes_done, cipher_data, cur_bytes);
 386
 387         bytes -= cur_bytes;
 388         bytes_done += cur_bytes;
 389     }
 390
 391  cleanup:
 392     qemu_iovec_destroy(&hd_qiov);
 393     qemu_vfree(cipher_data);
 394
 395     return ret;
 396 }
 397
 398
 399 static coroutine_fn int
 400 block_crypto_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 401                         QEMUIOVector *qiov, int flags)
 402 {
 403     BlockCrypto *crypto = bs->opaque;
 404     uint64_t cur_bytes; /* number of bytes in current iteration */
 405     uint64_t bytes_done = 0;
 406     uint8_t *cipher_data = NULL;
 407     QEMUIOVector hd_qiov;
 408     int ret = 0;
 409     uint64_t sector_size = qcrypto_block_get_sector_size(crypto->block);
 410     uint64_t payload_offset = qcrypto_block_get_payload_offset(crypto->block);
 411
 412     assert(!(flags & ~BDRV_REQ_FUA));
 413     assert(payload_offset < INT64_MAX);
 414     assert(QEMU_IS_ALIGNED(offset, sector_size));
 415     assert(QEMU_IS_ALIGNED(bytes, sector_size));
 416
 417     qemu_iovec_init(&hd_qiov, qiov->niov);
 418
 419     /* Bounce buffer because we're not permitted to touch
 420      * contents of qiov - it points to guest memory.
 421      */
 422     cipher_data =
 423         qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_IO_SIZE,
 424                                               qiov->size));
 425     if (cipher_data == NULL) {
 426         ret = -ENOMEM;
 427         goto cleanup;
 428     }
 429
 430     while (bytes) {
 431         cur_bytes = MIN(bytes, BLOCK_CRYPTO_MAX_IO_SIZE);
 432
 433         qemu_iovec_to_buf(qiov, bytes_done, cipher_data, cur_bytes);
 434
 435         if (qcrypto_block_encrypt(crypto->block, offset + bytes_done,
 436                                   cipher_data, cur_bytes, NULL) < 0) {
 437             ret = -EIO;
 438             goto cleanup;
 439         }
 440
 441         qemu_iovec_reset(&hd_qiov);
 442         qemu_iovec_add(&hd_qiov, cipher_data, cur_bytes);
 443
 444         ret = bdrv_co_pwritev(bs->file, payload_offset + offset + bytes_done,
 445                               cur_bytes, &hd_qiov, flags);
 446         if (ret < 0) {
 447             goto cleanup;
 448         }
 449
 450         bytes -= cur_bytes;
 451         bytes_done += cur_bytes;
 452     }
 453
 454  cleanup:
 455     qemu_iovec_destroy(&hd_qiov);
 456     qemu_vfree(cipher_data);
 457
 458     return ret;
 459 }
 460
 461 static void block_crypto_refresh_limits(BlockDriverState *bs, Error **errp)
 462 {
 463     BlockCrypto *crypto = bs->opaque;
 464     uint64_t sector_size = qcrypto_block_get_sector_size(crypto->block);
 465     bs->bl.request_alignment = sector_size; /* No sub-sector I/O */
 466 }
 467
 468
 469 static int64_t block_crypto_getlength(BlockDriverState *bs)
 470 {
 471     BlockCrypto *crypto = bs->opaque;
 472     int64_t len = bdrv_getlength(bs->file->bs);
 473
 474     uint64_t offset = qcrypto_block_get_payload_offset(crypto->block);
 475     assert(offset < INT64_MAX);
 476
 477     if (offset > len) {
 478         return -EIO;
 479     }
 480
 481     len -= offset;
 482
 483     return len;
 484 }
 485
 486
 487 static BlockMeasureInfo *block_crypto_measure(QemuOpts *opts,
 488                                               BlockDriverState *in_bs,
 489                                               Error **errp)
 490 {
 491     g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
 492     Error *local_err = NULL;
 493     BlockMeasureInfo *info;
 494     uint64_t size;
 495     size_t luks_payload_size;
 496     QDict *cryptoopts;
 497
 498     /*
 499      * Preallocation mode doesn't affect size requirements but we must consume
 500      * the option.
 501      */
 502     g_free(qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC));
 503
 504     size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
 505
 506     if (in_bs) {
 507         int64_t ssize = bdrv_getlength(in_bs);
 508
 509         if (ssize < 0) {
 510             error_setg_errno(&local_err, -ssize,
 511                              "Unable to get image virtual_size");
 512             goto err;
 513         }
 514
 515         size = ssize;
 516     }
 517
 518     cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
 519             &block_crypto_create_opts_luks, true);
 520     qdict_put_str(cryptoopts, "format", "luks");
 521     create_opts = block_crypto_create_opts_init(cryptoopts, &local_err);
 522     qobject_unref(cryptoopts);
 523     if (!create_opts) {
 524         goto err;
 525     }
 526
 527     if (!qcrypto_block_calculate_payload_offset(create_opts, NULL,
 528                                                 &luks_payload_size,
 529                                                 &local_err)) {
 530         goto err;
 531     }
 532
 533     /*
 534      * Unallocated blocks are still encrypted so allocation status makes no
 535      * difference to the file size.
 536      */
 537     info = g_new(BlockMeasureInfo, 1);
 538     info->fully_allocated = luks_payload_size + size;
 539     info->required = luks_payload_size + size;
 540     return info;
 541
 542 err:
 543     error_propagate(errp, local_err);
 544     return NULL;
 545 }
 546
 547
 548 static int block_crypto_probe_luks(const uint8_t *buf,
 549                                    int buf_size,
 550                                    const char *filename) {
 551     return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
 552                                       buf, buf_size, filename);
 553 }
 554
 555 static int block_crypto_open_luks(BlockDriverState *bs,
 556                                   QDict *options,
 557                                   int flags,
 558                                   Error **errp)
 559 {
 560     return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
 561                                      &block_crypto_runtime_opts_luks,
 562                                      bs, options, flags, errp);
 563 }
 564
 565 static int coroutine_fn
 566 block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
 567 {
 568     BlockdevCreateOptionsLUKS *luks_opts;
 569     BlockDriverState *bs = NULL;
 570     QCryptoBlockCreateOptions create_opts;
 571     PreallocMode preallocation = PREALLOC_MODE_OFF;
 572     int ret;
 573
 574     assert(create_options->driver == BLOCKDEV_DRIVER_LUKS);
 575     luks_opts = &create_options->u.luks;
 576
 577     bs = bdrv_open_blockdev_ref(luks_opts->file, errp);
 578     if (bs == NULL) {
 579         return -EIO;
 580     }
 581
 582     create_opts = (QCryptoBlockCreateOptions) {
 583         .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
 584         .u.luks = *qapi_BlockdevCreateOptionsLUKS_base(luks_opts),
 585     };
 586
 587     if (luks_opts->has_preallocation) {
 588         preallocation = luks_opts->preallocation;
 589     }
 590
 591     ret = block_crypto_co_create_generic(bs, luks_opts->size, &create_opts,
 592                                          preallocation, errp);
 593     if (ret < 0) {
 594         goto fail;
 595     }
 596
 597     ret = 0;
 598 fail:
 599     bdrv_unref(bs);
 600     return ret;
 601 }
 602
 603 static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
 604                                                          QemuOpts *opts,
 605                                                          Error **errp)
 606 {
 607     QCryptoBlockCreateOptions *create_opts = NULL;
 608     BlockDriverState *bs = NULL;
 609     QDict *cryptoopts;
 610     PreallocMode prealloc;
 611     char *buf = NULL;
 612     int64_t size;
 613     int ret;
 614     Error *local_err = NULL;
 615
 616     /* Parse options */
 617     size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
 618
 619     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
 620     prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
 621                                PREALLOC_MODE_OFF, &local_err);
 622     g_free(buf);
 623     if (local_err) {
 624         error_propagate(errp, local_err);
 625         return -EINVAL;
 626     }
 627
 628     cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
 629                                              &block_crypto_create_opts_luks,
 630                                              true);
 631
 632     qdict_put_str(cryptoopts, "format", "luks");
 633     create_opts = block_crypto_create_opts_init(cryptoopts, errp);
 634     if (!create_opts) {
 635         ret = -EINVAL;
 636         goto fail;
 637     }
 638
 639     /* Create protocol layer */
 640     ret = bdrv_create_file(filename, opts, errp);
 641     if (ret < 0) {
 642         goto fail;
 643     }
 644
 645     bs = bdrv_open(filename, NULL, NULL,
 646                    BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
 647     if (!bs) {
 648         ret = -EINVAL;
 649         goto fail;
 650     }
 651
 652     /* Create format layer */
 653     ret = block_crypto_co_create_generic(bs, size, create_opts, prealloc, errp);
 654     if (ret < 0) {
 655         goto fail;
 656     }
 657
 658     ret = 0;
 659 fail:
 660     bdrv_unref(bs);
 661     qapi_free_QCryptoBlockCreateOptions(create_opts);
 662     qobject_unref(cryptoopts);
 663     return ret;
 664 }
 665
 666 static int block_crypto_get_info_luks(BlockDriverState *bs,
 667                                       BlockDriverInfo *bdi)
 668 {
 669     BlockDriverInfo subbdi;
 670     int ret;
 671
 672     ret = bdrv_get_info(bs->file->bs, &subbdi);
 673     if (ret != 0) {
 674         return ret;
 675     }
 676
 677     bdi->unallocated_blocks_are_zero = false;
 678     bdi->cluster_size = subbdi.cluster_size;
 679
 680     return 0;
 681 }
 682
 683 static ImageInfoSpecific *
 684 block_crypto_get_specific_info_luks(BlockDriverState *bs, Error **errp)
 685 {
 686     BlockCrypto *crypto = bs->opaque;
 687     ImageInfoSpecific *spec_info;
 688     QCryptoBlockInfo *info;
 689
 690     info = qcrypto_block_get_info(crypto->block, errp);
 691     if (!info) {
 692         return NULL;
 693     }
 694     assert(info->format == Q_CRYPTO_BLOCK_FORMAT_LUKS);
 695
 696     spec_info = g_new(ImageInfoSpecific, 1);
 697     spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS;
 698     spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1);
 699     *spec_info->u.luks.data = info->u.luks;
 700
 701     /* Blank out pointers we've just stolen to avoid double free */
 702     memset(&info->u.luks, 0, sizeof(info->u.luks));
 703
 704     qapi_free_QCryptoBlockInfo(info);
 705
 706     return spec_info;
 707 }
 708
 709 static const char *const block_crypto_strong_runtime_opts[] = {
 710     BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
 711
 712     NULL
 713 };
 714
 715 static BlockDriver bdrv_crypto_luks = {
 716     .format_name        = "luks",
 717     .instance_size      = sizeof(BlockCrypto),
 718     .bdrv_probe         = block_crypto_probe_luks,
 719     .bdrv_open          = block_crypto_open_luks,
 720     .bdrv_close         = block_crypto_close,
 721     /* This driver doesn't modify LUKS metadata except when creating image.
 722      * Allow share-rw=on as a special case. */
 723     .bdrv_child_perm    = bdrv_filter_default_perms,
 724     .bdrv_co_create     = block_crypto_co_create_luks,
 725     .bdrv_co_create_opts = block_crypto_co_create_opts_luks,
 726     .bdrv_co_truncate   = block_crypto_co_truncate,
 727     .create_opts        = &block_crypto_create_opts_luks,
 728
 729     .bdrv_reopen_prepare = block_crypto_reopen_prepare,
 730     .bdrv_refresh_limits = block_crypto_refresh_limits,
 731     .bdrv_co_preadv     = block_crypto_co_preadv,
 732     .bdrv_co_pwritev    = block_crypto_co_pwritev,
 733     .bdrv_getlength     = block_crypto_getlength,
 734     .bdrv_measure       = block_crypto_measure,
 735     .bdrv_get_info      = block_crypto_get_info_luks,
 736     .bdrv_get_specific_info = block_crypto_get_specific_info_luks,
 737
 738     .strong_runtime_opts = block_crypto_strong_runtime_opts,
 739 };
 740
 741 static void block_crypto_init(void)
 742 {
 743     bdrv_register(&bdrv_crypto_luks);
 744 }
 745
 746 block_init(block_crypto_init);