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 , |
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, data->prealloc, |
117 | 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, |
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, 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 int block_crypto_probe_luks(const uint8_t *buf, |
488 | int buf_size, |
489 | const char *filename) { |
490 | return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS, |
491 | buf, buf_size, filename); |
492 | } |
493 | |
494 | static int block_crypto_open_luks(BlockDriverState *bs, |
495 | QDict *options, |
496 | int flags, |
497 | Error **errp) |
498 | { |
499 | return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS, |
500 | &block_crypto_runtime_opts_luks, |
501 | bs, options, flags, errp); |
502 | } |
503 | |
504 | static int coroutine_fn |
505 | block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp) |
506 | { |
507 | BlockdevCreateOptionsLUKS *luks_opts; |
508 | BlockDriverState *bs = NULL; |
509 | QCryptoBlockCreateOptions create_opts; |
510 | PreallocMode preallocation = PREALLOC_MODE_OFF; |
511 | int ret; |
512 | |
513 | assert(create_options->driver == BLOCKDEV_DRIVER_LUKS); |
514 | luks_opts = &create_options->u.luks; |
515 | |
516 | bs = bdrv_open_blockdev_ref(luks_opts->file, errp); |
517 | if (bs == NULL) { |
518 | return -EIO; |
519 | } |
520 | |
521 | create_opts = (QCryptoBlockCreateOptions) { |
522 | .format = Q_CRYPTO_BLOCK_FORMAT_LUKS, |
523 | .u.luks = *qapi_BlockdevCreateOptionsLUKS_base(luks_opts), |
524 | }; |
525 | |
526 | if (luks_opts->has_preallocation) { |
527 | preallocation = luks_opts->preallocation; |
528 | } |
529 | |
530 | ret = block_crypto_co_create_generic(bs, luks_opts->size, &create_opts, |
531 | preallocation, errp); |
532 | if (ret < 0) { |
533 | goto fail; |
534 | } |
535 | |
536 | ret = 0; |
537 | fail: |
538 | bdrv_unref(bs); |
539 | return ret; |
540 | } |
541 | |
542 | static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename, |
543 | QemuOpts *opts, |
544 | Error **errp) |
545 | { |
546 | QCryptoBlockCreateOptions *create_opts = NULL; |
547 | BlockDriverState *bs = NULL; |
548 | QDict *cryptoopts; |
549 | PreallocMode prealloc; |
550 | char *buf = NULL; |
551 | int64_t size; |
552 | int ret; |
553 | Error *local_err = NULL; |
554 | |
555 | /* Parse options */ |
556 | size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0); |
557 | |
558 | buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); |
559 | prealloc = qapi_enum_parse(&PreallocMode_lookup, buf, |
560 | PREALLOC_MODE_OFF, &local_err); |
561 | g_free(buf); |
562 | if (local_err) { |
563 | error_propagate(errp, local_err); |
564 | return -EINVAL; |
565 | } |
566 | |
567 | cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL, |
568 | &block_crypto_create_opts_luks, |
569 | true); |
570 | |
571 | qdict_put_str(cryptoopts, "format" , "luks" ); |
572 | create_opts = block_crypto_create_opts_init(cryptoopts, errp); |
573 | if (!create_opts) { |
574 | ret = -EINVAL; |
575 | goto fail; |
576 | } |
577 | |
578 | /* Create protocol layer */ |
579 | ret = bdrv_create_file(filename, opts, errp); |
580 | if (ret < 0) { |
581 | goto fail; |
582 | } |
583 | |
584 | bs = bdrv_open(filename, NULL, NULL, |
585 | BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp); |
586 | if (!bs) { |
587 | ret = -EINVAL; |
588 | goto fail; |
589 | } |
590 | |
591 | /* Create format layer */ |
592 | ret = block_crypto_co_create_generic(bs, size, create_opts, prealloc, errp); |
593 | if (ret < 0) { |
594 | goto fail; |
595 | } |
596 | |
597 | ret = 0; |
598 | fail: |
599 | bdrv_unref(bs); |
600 | qapi_free_QCryptoBlockCreateOptions(create_opts); |
601 | qobject_unref(cryptoopts); |
602 | return ret; |
603 | } |
604 | |
605 | static int block_crypto_get_info_luks(BlockDriverState *bs, |
606 | BlockDriverInfo *bdi) |
607 | { |
608 | BlockDriverInfo subbdi; |
609 | int ret; |
610 | |
611 | ret = bdrv_get_info(bs->file->bs, &subbdi); |
612 | if (ret != 0) { |
613 | return ret; |
614 | } |
615 | |
616 | bdi->unallocated_blocks_are_zero = false; |
617 | bdi->cluster_size = subbdi.cluster_size; |
618 | |
619 | return 0; |
620 | } |
621 | |
622 | static ImageInfoSpecific * |
623 | block_crypto_get_specific_info_luks(BlockDriverState *bs, Error **errp) |
624 | { |
625 | BlockCrypto *crypto = bs->opaque; |
626 | ImageInfoSpecific *spec_info; |
627 | QCryptoBlockInfo *info; |
628 | |
629 | info = qcrypto_block_get_info(crypto->block, errp); |
630 | if (!info) { |
631 | return NULL; |
632 | } |
633 | assert(info->format == Q_CRYPTO_BLOCK_FORMAT_LUKS); |
634 | |
635 | spec_info = g_new(ImageInfoSpecific, 1); |
636 | spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS; |
637 | spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1); |
638 | *spec_info->u.luks.data = info->u.luks; |
639 | |
640 | /* Blank out pointers we've just stolen to avoid double free */ |
641 | memset(&info->u.luks, 0, sizeof(info->u.luks)); |
642 | |
643 | qapi_free_QCryptoBlockInfo(info); |
644 | |
645 | return spec_info; |
646 | } |
647 | |
648 | static const char *const block_crypto_strong_runtime_opts[] = { |
649 | BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET, |
650 | |
651 | NULL |
652 | }; |
653 | |
654 | static BlockDriver bdrv_crypto_luks = { |
655 | .format_name = "luks" , |
656 | .instance_size = sizeof(BlockCrypto), |
657 | .bdrv_probe = block_crypto_probe_luks, |
658 | .bdrv_open = block_crypto_open_luks, |
659 | .bdrv_close = block_crypto_close, |
660 | /* This driver doesn't modify LUKS metadata except when creating image. |
661 | * Allow share-rw=on as a special case. */ |
662 | .bdrv_child_perm = bdrv_filter_default_perms, |
663 | .bdrv_co_create = block_crypto_co_create_luks, |
664 | .bdrv_co_create_opts = block_crypto_co_create_opts_luks, |
665 | .bdrv_co_truncate = block_crypto_co_truncate, |
666 | .create_opts = &block_crypto_create_opts_luks, |
667 | |
668 | .bdrv_reopen_prepare = block_crypto_reopen_prepare, |
669 | .bdrv_refresh_limits = block_crypto_refresh_limits, |
670 | .bdrv_co_preadv = block_crypto_co_preadv, |
671 | .bdrv_co_pwritev = block_crypto_co_pwritev, |
672 | .bdrv_getlength = block_crypto_getlength, |
673 | .bdrv_get_info = block_crypto_get_info_luks, |
674 | .bdrv_get_specific_info = block_crypto_get_specific_info_luks, |
675 | |
676 | .strong_runtime_opts = block_crypto_strong_runtime_opts, |
677 | }; |
678 | |
679 | static void block_crypto_init(void) |
680 | { |
681 | bdrv_register(&bdrv_crypto_luks); |
682 | } |
683 | |
684 | block_init(block_crypto_init); |
685 | |