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