]>
Commit | Line | Data |
---|---|---|
78368575 DB |
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 "sysemu/block-backend.h" | |
25 | #include "crypto/block.h" | |
26 | #include "qapi/opts-visitor.h" | |
27 | #include "qapi-visit.h" | |
28 | #include "qapi/error.h" | |
29 | ||
30 | #define BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET "key-secret" | |
31 | #define BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG "cipher-alg" | |
32 | #define BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE "cipher-mode" | |
33 | #define BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG "ivgen-alg" | |
34 | #define BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG "ivgen-hash-alg" | |
35 | #define BLOCK_CRYPTO_OPT_LUKS_HASH_ALG "hash-alg" | |
3bd18890 | 36 | #define BLOCK_CRYPTO_OPT_LUKS_ITER_TIME "iter-time" |
78368575 DB |
37 | |
38 | typedef struct BlockCrypto BlockCrypto; | |
39 | ||
40 | struct BlockCrypto { | |
41 | QCryptoBlock *block; | |
42 | }; | |
43 | ||
44 | ||
45 | static int block_crypto_probe_generic(QCryptoBlockFormat format, | |
46 | const uint8_t *buf, | |
47 | int buf_size, | |
48 | const char *filename) | |
49 | { | |
50 | if (qcrypto_block_has_format(format, buf, buf_size)) { | |
51 | return 100; | |
52 | } else { | |
53 | return 0; | |
54 | } | |
55 | } | |
56 | ||
57 | ||
58 | static ssize_t block_crypto_read_func(QCryptoBlock *block, | |
59 | size_t offset, | |
60 | uint8_t *buf, | |
61 | size_t buflen, | |
62 | Error **errp, | |
63 | void *opaque) | |
64 | { | |
65 | BlockDriverState *bs = opaque; | |
66 | ssize_t ret; | |
67 | ||
cf2ab8fc | 68 | ret = bdrv_pread(bs->file, offset, buf, buflen); |
78368575 DB |
69 | if (ret < 0) { |
70 | error_setg_errno(errp, -ret, "Could not read encryption header"); | |
71 | return ret; | |
72 | } | |
73 | return ret; | |
74 | } | |
75 | ||
76 | ||
77 | struct BlockCryptoCreateData { | |
78 | const char *filename; | |
79 | QemuOpts *opts; | |
80 | BlockBackend *blk; | |
81 | uint64_t size; | |
82 | }; | |
83 | ||
84 | ||
85 | static ssize_t block_crypto_write_func(QCryptoBlock *block, | |
86 | size_t offset, | |
87 | const uint8_t *buf, | |
88 | size_t buflen, | |
89 | Error **errp, | |
90 | void *opaque) | |
91 | { | |
92 | struct BlockCryptoCreateData *data = opaque; | |
93 | ssize_t ret; | |
94 | ||
8341f00d | 95 | ret = blk_pwrite(data->blk, offset, buf, buflen, 0); |
78368575 DB |
96 | if (ret < 0) { |
97 | error_setg_errno(errp, -ret, "Could not write encryption header"); | |
98 | return ret; | |
99 | } | |
100 | return ret; | |
101 | } | |
102 | ||
103 | ||
104 | static ssize_t block_crypto_init_func(QCryptoBlock *block, | |
105 | size_t headerlen, | |
106 | Error **errp, | |
107 | void *opaque) | |
108 | { | |
109 | struct BlockCryptoCreateData *data = opaque; | |
110 | int ret; | |
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 | data->size += headerlen; | |
117 | ||
118 | qemu_opt_set_number(data->opts, BLOCK_OPT_SIZE, data->size, &error_abort); | |
119 | ret = bdrv_create_file(data->filename, data->opts, errp); | |
120 | if (ret < 0) { | |
121 | return -1; | |
122 | } | |
123 | ||
124 | data->blk = blk_new_open(data->filename, NULL, NULL, | |
72e775c7 | 125 | BDRV_O_RDWR | BDRV_O_PROTOCOL, errp); |
78368575 DB |
126 | if (!data->blk) { |
127 | return -1; | |
128 | } | |
129 | ||
130 | return 0; | |
131 | } | |
132 | ||
133 | ||
134 | static QemuOptsList block_crypto_runtime_opts_luks = { | |
135 | .name = "crypto", | |
136 | .head = QTAILQ_HEAD_INITIALIZER(block_crypto_runtime_opts_luks.head), | |
137 | .desc = { | |
138 | { | |
139 | .name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET, | |
140 | .type = QEMU_OPT_STRING, | |
141 | .help = "ID of the secret that provides the encryption key", | |
142 | }, | |
143 | { /* end of list */ } | |
144 | }, | |
145 | }; | |
146 | ||
147 | ||
148 | static QemuOptsList block_crypto_create_opts_luks = { | |
149 | .name = "crypto", | |
150 | .head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head), | |
151 | .desc = { | |
152 | { | |
153 | .name = BLOCK_OPT_SIZE, | |
154 | .type = QEMU_OPT_SIZE, | |
155 | .help = "Virtual disk size" | |
156 | }, | |
157 | { | |
158 | .name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET, | |
159 | .type = QEMU_OPT_STRING, | |
160 | .help = "ID of the secret that provides the encryption key", | |
161 | }, | |
162 | { | |
163 | .name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG, | |
164 | .type = QEMU_OPT_STRING, | |
165 | .help = "Name of encryption cipher algorithm", | |
166 | }, | |
167 | { | |
168 | .name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE, | |
169 | .type = QEMU_OPT_STRING, | |
170 | .help = "Name of encryption cipher mode", | |
171 | }, | |
172 | { | |
173 | .name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG, | |
174 | .type = QEMU_OPT_STRING, | |
175 | .help = "Name of IV generator algorithm", | |
176 | }, | |
177 | { | |
178 | .name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG, | |
179 | .type = QEMU_OPT_STRING, | |
180 | .help = "Name of IV generator hash algorithm", | |
181 | }, | |
182 | { | |
183 | .name = BLOCK_CRYPTO_OPT_LUKS_HASH_ALG, | |
184 | .type = QEMU_OPT_STRING, | |
185 | .help = "Name of encryption hash algorithm", | |
186 | }, | |
3bd18890 DB |
187 | { |
188 | .name = BLOCK_CRYPTO_OPT_LUKS_ITER_TIME, | |
189 | .type = QEMU_OPT_NUMBER, | |
190 | .help = "Time to spend in PBKDF in milliseconds", | |
191 | }, | |
78368575 DB |
192 | { /* end of list */ } |
193 | }, | |
194 | }; | |
195 | ||
196 | ||
197 | static QCryptoBlockOpenOptions * | |
198 | block_crypto_open_opts_init(QCryptoBlockFormat format, | |
199 | QemuOpts *opts, | |
200 | Error **errp) | |
201 | { | |
09204eac | 202 | Visitor *v; |
78368575 DB |
203 | QCryptoBlockOpenOptions *ret = NULL; |
204 | Error *local_err = NULL; | |
205 | ||
206 | ret = g_new0(QCryptoBlockOpenOptions, 1); | |
207 | ret->format = format; | |
208 | ||
09204eac | 209 | v = opts_visitor_new(opts); |
78368575 | 210 | |
09204eac | 211 | visit_start_struct(v, NULL, NULL, 0, &local_err); |
78368575 DB |
212 | if (local_err) { |
213 | goto out; | |
214 | } | |
215 | ||
216 | switch (format) { | |
217 | case Q_CRYPTO_BLOCK_FORMAT_LUKS: | |
218 | visit_type_QCryptoBlockOptionsLUKS_members( | |
09204eac | 219 | v, &ret->u.luks, &local_err); |
78368575 DB |
220 | break; |
221 | ||
222 | default: | |
223 | error_setg(&local_err, "Unsupported block format %d", format); | |
224 | break; | |
225 | } | |
15c2f669 | 226 | if (!local_err) { |
09204eac | 227 | visit_check_struct(v, &local_err); |
15c2f669 | 228 | } |
78368575 | 229 | |
09204eac | 230 | visit_end_struct(v, NULL); |
78368575 DB |
231 | |
232 | out: | |
233 | if (local_err) { | |
234 | error_propagate(errp, local_err); | |
235 | qapi_free_QCryptoBlockOpenOptions(ret); | |
236 | ret = NULL; | |
237 | } | |
09204eac | 238 | visit_free(v); |
78368575 DB |
239 | return ret; |
240 | } | |
241 | ||
242 | ||
243 | static QCryptoBlockCreateOptions * | |
244 | block_crypto_create_opts_init(QCryptoBlockFormat format, | |
245 | QemuOpts *opts, | |
246 | Error **errp) | |
247 | { | |
09204eac | 248 | Visitor *v; |
78368575 DB |
249 | QCryptoBlockCreateOptions *ret = NULL; |
250 | Error *local_err = NULL; | |
251 | ||
252 | ret = g_new0(QCryptoBlockCreateOptions, 1); | |
253 | ret->format = format; | |
254 | ||
09204eac | 255 | v = opts_visitor_new(opts); |
78368575 | 256 | |
09204eac | 257 | visit_start_struct(v, NULL, NULL, 0, &local_err); |
78368575 DB |
258 | if (local_err) { |
259 | goto out; | |
260 | } | |
261 | ||
262 | switch (format) { | |
263 | case Q_CRYPTO_BLOCK_FORMAT_LUKS: | |
264 | visit_type_QCryptoBlockCreateOptionsLUKS_members( | |
09204eac | 265 | v, &ret->u.luks, &local_err); |
78368575 DB |
266 | break; |
267 | ||
268 | default: | |
269 | error_setg(&local_err, "Unsupported block format %d", format); | |
270 | break; | |
271 | } | |
15c2f669 | 272 | if (!local_err) { |
09204eac | 273 | visit_check_struct(v, &local_err); |
15c2f669 | 274 | } |
78368575 | 275 | |
09204eac | 276 | visit_end_struct(v, NULL); |
78368575 DB |
277 | |
278 | out: | |
279 | if (local_err) { | |
280 | error_propagate(errp, local_err); | |
281 | qapi_free_QCryptoBlockCreateOptions(ret); | |
282 | ret = NULL; | |
283 | } | |
09204eac | 284 | visit_free(v); |
78368575 DB |
285 | return ret; |
286 | } | |
287 | ||
288 | ||
289 | static int block_crypto_open_generic(QCryptoBlockFormat format, | |
290 | QemuOptsList *opts_spec, | |
291 | BlockDriverState *bs, | |
292 | QDict *options, | |
293 | int flags, | |
294 | Error **errp) | |
295 | { | |
296 | BlockCrypto *crypto = bs->opaque; | |
297 | QemuOpts *opts = NULL; | |
298 | Error *local_err = NULL; | |
299 | int ret = -EINVAL; | |
300 | QCryptoBlockOpenOptions *open_opts = NULL; | |
301 | unsigned int cflags = 0; | |
302 | ||
303 | opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort); | |
304 | qemu_opts_absorb_qdict(opts, options, &local_err); | |
305 | if (local_err) { | |
306 | error_propagate(errp, local_err); | |
307 | goto cleanup; | |
308 | } | |
309 | ||
310 | open_opts = block_crypto_open_opts_init(format, opts, errp); | |
311 | if (!open_opts) { | |
312 | goto cleanup; | |
313 | } | |
314 | ||
315 | if (flags & BDRV_O_NO_IO) { | |
316 | cflags |= QCRYPTO_BLOCK_OPEN_NO_IO; | |
317 | } | |
318 | crypto->block = qcrypto_block_open(open_opts, | |
319 | block_crypto_read_func, | |
320 | bs, | |
321 | cflags, | |
322 | errp); | |
323 | ||
324 | if (!crypto->block) { | |
325 | ret = -EIO; | |
326 | goto cleanup; | |
327 | } | |
328 | ||
54115412 EB |
329 | bs->encrypted = true; |
330 | bs->valid_key = true; | |
78368575 DB |
331 | |
332 | ret = 0; | |
333 | cleanup: | |
334 | qapi_free_QCryptoBlockOpenOptions(open_opts); | |
335 | return ret; | |
336 | } | |
337 | ||
338 | ||
339 | static int block_crypto_create_generic(QCryptoBlockFormat format, | |
340 | const char *filename, | |
341 | QemuOpts *opts, | |
342 | Error **errp) | |
343 | { | |
344 | int ret = -EINVAL; | |
345 | QCryptoBlockCreateOptions *create_opts = NULL; | |
346 | QCryptoBlock *crypto = NULL; | |
347 | struct BlockCryptoCreateData data = { | |
348 | .size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), | |
349 | BDRV_SECTOR_SIZE), | |
350 | .opts = opts, | |
351 | .filename = filename, | |
352 | }; | |
353 | ||
354 | create_opts = block_crypto_create_opts_init(format, opts, errp); | |
355 | if (!create_opts) { | |
356 | return -1; | |
357 | } | |
358 | ||
359 | crypto = qcrypto_block_create(create_opts, | |
360 | block_crypto_init_func, | |
361 | block_crypto_write_func, | |
362 | &data, | |
363 | errp); | |
364 | ||
365 | if (!crypto) { | |
366 | ret = -EIO; | |
367 | goto cleanup; | |
368 | } | |
369 | ||
370 | ret = 0; | |
371 | cleanup: | |
372 | qcrypto_block_free(crypto); | |
373 | blk_unref(data.blk); | |
374 | qapi_free_QCryptoBlockCreateOptions(create_opts); | |
375 | return ret; | |
376 | } | |
377 | ||
378 | static int block_crypto_truncate(BlockDriverState *bs, int64_t offset) | |
379 | { | |
380 | BlockCrypto *crypto = bs->opaque; | |
381 | size_t payload_offset = | |
382 | qcrypto_block_get_payload_offset(crypto->block); | |
383 | ||
384 | offset += payload_offset; | |
385 | ||
386 | return bdrv_truncate(bs->file->bs, offset); | |
387 | } | |
388 | ||
389 | static void block_crypto_close(BlockDriverState *bs) | |
390 | { | |
391 | BlockCrypto *crypto = bs->opaque; | |
392 | qcrypto_block_free(crypto->block); | |
393 | } | |
394 | ||
395 | ||
396 | #define BLOCK_CRYPTO_MAX_SECTORS 32 | |
397 | ||
398 | static coroutine_fn int | |
399 | block_crypto_co_readv(BlockDriverState *bs, int64_t sector_num, | |
400 | int remaining_sectors, QEMUIOVector *qiov) | |
401 | { | |
402 | BlockCrypto *crypto = bs->opaque; | |
403 | int cur_nr_sectors; /* number of sectors in current iteration */ | |
404 | uint64_t bytes_done = 0; | |
405 | uint8_t *cipher_data = NULL; | |
406 | QEMUIOVector hd_qiov; | |
407 | int ret = 0; | |
408 | size_t payload_offset = | |
409 | qcrypto_block_get_payload_offset(crypto->block) / 512; | |
410 | ||
411 | qemu_iovec_init(&hd_qiov, qiov->niov); | |
412 | ||
413 | /* Bounce buffer so we have a linear mem region for | |
414 | * entire sector. XXX optimize so we avoid bounce | |
415 | * buffer in case that qiov->niov == 1 | |
416 | */ | |
417 | cipher_data = | |
418 | qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512, | |
419 | qiov->size)); | |
420 | if (cipher_data == NULL) { | |
421 | ret = -ENOMEM; | |
422 | goto cleanup; | |
423 | } | |
424 | ||
425 | while (remaining_sectors) { | |
426 | cur_nr_sectors = remaining_sectors; | |
427 | ||
428 | if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) { | |
429 | cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS; | |
430 | } | |
431 | ||
432 | qemu_iovec_reset(&hd_qiov); | |
433 | qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512); | |
434 | ||
28b04a8f | 435 | ret = bdrv_co_readv(bs->file, |
78368575 DB |
436 | payload_offset + sector_num, |
437 | cur_nr_sectors, &hd_qiov); | |
438 | if (ret < 0) { | |
439 | goto cleanup; | |
440 | } | |
441 | ||
442 | if (qcrypto_block_decrypt(crypto->block, | |
443 | sector_num, | |
444 | cipher_data, cur_nr_sectors * 512, | |
445 | NULL) < 0) { | |
446 | ret = -EIO; | |
447 | goto cleanup; | |
448 | } | |
449 | ||
450 | qemu_iovec_from_buf(qiov, bytes_done, | |
451 | cipher_data, cur_nr_sectors * 512); | |
452 | ||
453 | remaining_sectors -= cur_nr_sectors; | |
454 | sector_num += cur_nr_sectors; | |
455 | bytes_done += cur_nr_sectors * 512; | |
456 | } | |
457 | ||
458 | cleanup: | |
459 | qemu_iovec_destroy(&hd_qiov); | |
460 | qemu_vfree(cipher_data); | |
461 | ||
462 | return ret; | |
463 | } | |
464 | ||
465 | ||
466 | static coroutine_fn int | |
467 | block_crypto_co_writev(BlockDriverState *bs, int64_t sector_num, | |
468 | int remaining_sectors, QEMUIOVector *qiov) | |
469 | { | |
470 | BlockCrypto *crypto = bs->opaque; | |
471 | int cur_nr_sectors; /* number of sectors in current iteration */ | |
472 | uint64_t bytes_done = 0; | |
473 | uint8_t *cipher_data = NULL; | |
474 | QEMUIOVector hd_qiov; | |
475 | int ret = 0; | |
476 | size_t payload_offset = | |
477 | qcrypto_block_get_payload_offset(crypto->block) / 512; | |
478 | ||
479 | qemu_iovec_init(&hd_qiov, qiov->niov); | |
480 | ||
481 | /* Bounce buffer so we have a linear mem region for | |
482 | * entire sector. XXX optimize so we avoid bounce | |
483 | * buffer in case that qiov->niov == 1 | |
484 | */ | |
485 | cipher_data = | |
486 | qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512, | |
487 | qiov->size)); | |
488 | if (cipher_data == NULL) { | |
489 | ret = -ENOMEM; | |
490 | goto cleanup; | |
491 | } | |
492 | ||
493 | while (remaining_sectors) { | |
494 | cur_nr_sectors = remaining_sectors; | |
495 | ||
496 | if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) { | |
497 | cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS; | |
498 | } | |
499 | ||
500 | qemu_iovec_to_buf(qiov, bytes_done, | |
501 | cipher_data, cur_nr_sectors * 512); | |
502 | ||
503 | if (qcrypto_block_encrypt(crypto->block, | |
504 | sector_num, | |
505 | cipher_data, cur_nr_sectors * 512, | |
506 | NULL) < 0) { | |
507 | ret = -EIO; | |
508 | goto cleanup; | |
509 | } | |
510 | ||
511 | qemu_iovec_reset(&hd_qiov); | |
512 | qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512); | |
513 | ||
25ec177d | 514 | ret = bdrv_co_writev(bs->file, |
78368575 DB |
515 | payload_offset + sector_num, |
516 | cur_nr_sectors, &hd_qiov); | |
517 | if (ret < 0) { | |
518 | goto cleanup; | |
519 | } | |
520 | ||
521 | remaining_sectors -= cur_nr_sectors; | |
522 | sector_num += cur_nr_sectors; | |
523 | bytes_done += cur_nr_sectors * 512; | |
524 | } | |
525 | ||
526 | cleanup: | |
527 | qemu_iovec_destroy(&hd_qiov); | |
528 | qemu_vfree(cipher_data); | |
529 | ||
530 | return ret; | |
531 | } | |
532 | ||
533 | ||
534 | static int64_t block_crypto_getlength(BlockDriverState *bs) | |
535 | { | |
536 | BlockCrypto *crypto = bs->opaque; | |
537 | int64_t len = bdrv_getlength(bs->file->bs); | |
538 | ||
539 | ssize_t offset = qcrypto_block_get_payload_offset(crypto->block); | |
540 | ||
541 | len -= offset; | |
542 | ||
543 | return len; | |
544 | } | |
545 | ||
546 | ||
547 | static int block_crypto_probe_luks(const uint8_t *buf, | |
548 | int buf_size, | |
549 | const char *filename) { | |
550 | return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS, | |
551 | buf, buf_size, filename); | |
552 | } | |
553 | ||
554 | static int block_crypto_open_luks(BlockDriverState *bs, | |
555 | QDict *options, | |
556 | int flags, | |
557 | Error **errp) | |
558 | { | |
559 | return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS, | |
560 | &block_crypto_runtime_opts_luks, | |
561 | bs, options, flags, errp); | |
562 | } | |
563 | ||
564 | static int block_crypto_create_luks(const char *filename, | |
565 | QemuOpts *opts, | |
566 | Error **errp) | |
567 | { | |
568 | return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS, | |
569 | filename, opts, errp); | |
570 | } | |
571 | ||
c7c4cf49 DB |
572 | static int block_crypto_get_info_luks(BlockDriverState *bs, |
573 | BlockDriverInfo *bdi) | |
574 | { | |
575 | BlockDriverInfo subbdi; | |
576 | int ret; | |
577 | ||
578 | ret = bdrv_get_info(bs->file->bs, &subbdi); | |
579 | if (ret != 0) { | |
580 | return ret; | |
581 | } | |
582 | ||
583 | bdi->unallocated_blocks_are_zero = false; | |
584 | bdi->can_write_zeroes_with_unmap = false; | |
585 | bdi->cluster_size = subbdi.cluster_size; | |
586 | ||
587 | return 0; | |
588 | } | |
589 | ||
590 | static ImageInfoSpecific * | |
591 | block_crypto_get_specific_info_luks(BlockDriverState *bs) | |
592 | { | |
593 | BlockCrypto *crypto = bs->opaque; | |
594 | ImageInfoSpecific *spec_info; | |
595 | QCryptoBlockInfo *info; | |
596 | ||
597 | info = qcrypto_block_get_info(crypto->block, NULL); | |
598 | if (!info) { | |
599 | return NULL; | |
600 | } | |
601 | if (info->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) { | |
602 | qapi_free_QCryptoBlockInfo(info); | |
603 | return NULL; | |
604 | } | |
605 | ||
606 | spec_info = g_new(ImageInfoSpecific, 1); | |
607 | spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS; | |
608 | spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1); | |
609 | *spec_info->u.luks.data = info->u.luks; | |
610 | ||
611 | /* Blank out pointers we've just stolen to avoid double free */ | |
612 | memset(&info->u.luks, 0, sizeof(info->u.luks)); | |
613 | ||
614 | qapi_free_QCryptoBlockInfo(info); | |
615 | ||
616 | return spec_info; | |
617 | } | |
618 | ||
78368575 DB |
619 | BlockDriver bdrv_crypto_luks = { |
620 | .format_name = "luks", | |
621 | .instance_size = sizeof(BlockCrypto), | |
622 | .bdrv_probe = block_crypto_probe_luks, | |
623 | .bdrv_open = block_crypto_open_luks, | |
624 | .bdrv_close = block_crypto_close, | |
625 | .bdrv_create = block_crypto_create_luks, | |
626 | .bdrv_truncate = block_crypto_truncate, | |
627 | .create_opts = &block_crypto_create_opts_luks, | |
628 | ||
629 | .bdrv_co_readv = block_crypto_co_readv, | |
630 | .bdrv_co_writev = block_crypto_co_writev, | |
631 | .bdrv_getlength = block_crypto_getlength, | |
c7c4cf49 DB |
632 | .bdrv_get_info = block_crypto_get_info_luks, |
633 | .bdrv_get_specific_info = block_crypto_get_specific_info_luks, | |
78368575 DB |
634 | }; |
635 | ||
636 | static void block_crypto_init(void) | |
637 | { | |
638 | bdrv_register(&bdrv_crypto_luks); | |
639 | } | |
640 | ||
641 | block_init(block_crypto_init); |