2 * Copyright (C) 2003 Christophe Saout <christophe@saout.de>
3 * Copyright (C) 2004 Clemens Fruhwirth <clemens@endorphin.org>
4 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.
6 * This file is released under the GPL.
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/bio.h>
14 #include <linux/blkdev.h>
15 #include <linux/mempool.h>
16 #include <linux/slab.h>
17 #include <linux/crypto.h>
18 #include <linux/workqueue.h>
19 #include <asm/atomic.h>
20 #include <linux/scatterlist.h>
25 #define DM_MSG_PREFIX "crypt"
26 #define MESG_STR(x) x, sizeof(x)
29 * per bio private data
32 struct dm_target
*target
;
34 struct bio
*first_clone
;
35 struct work_struct work
;
42 * context holding the current state of a multi-part conversion
44 struct convert_context
{
47 unsigned int offset_in
;
48 unsigned int offset_out
;
57 struct crypt_iv_operations
{
58 int (*ctr
)(struct crypt_config
*cc
, struct dm_target
*ti
,
60 void (*dtr
)(struct crypt_config
*cc
);
61 const char *(*status
)(struct crypt_config
*cc
);
62 int (*generator
)(struct crypt_config
*cc
, u8
*iv
, sector_t sector
);
66 * Crypt: maps a linear range of a block device
67 * and encrypts / decrypts at the same time.
69 enum flags
{ DM_CRYPT_SUSPENDED
, DM_CRYPT_KEY_VALID
};
75 * pool for per bio private data and
76 * for encryption buffer pages
85 struct crypt_iv_operations
*iv_gen_ops
;
87 struct crypto_cipher
*iv_gen_private
;
91 char cipher
[CRYPTO_MAX_ALG_NAME
];
92 char chainmode
[CRYPTO_MAX_ALG_NAME
];
93 struct crypto_blkcipher
*tfm
;
95 unsigned int key_size
;
100 #define MIN_POOL_PAGES 32
101 #define MIN_BIO_PAGES 8
103 static kmem_cache_t
*_crypt_io_pool
;
106 * Different IV generation algorithms:
108 * plain: the initial vector is the 32-bit little-endian version of the sector
109 * number, padded with zeros if neccessary.
111 * essiv: "encrypted sector|salt initial vector", the sector number is
112 * encrypted with the bulk cipher using a salt as key. The salt
113 * should be derived from the bulk cipher's key via hashing.
115 * plumb: unimplemented, see:
116 * http://article.gmane.org/gmane.linux.kernel.device-mapper.dm-crypt/454
119 static int crypt_iv_plain_gen(struct crypt_config
*cc
, u8
*iv
, sector_t sector
)
121 memset(iv
, 0, cc
->iv_size
);
122 *(u32
*)iv
= cpu_to_le32(sector
& 0xffffffff);
127 static int crypt_iv_essiv_ctr(struct crypt_config
*cc
, struct dm_target
*ti
,
130 struct crypto_cipher
*essiv_tfm
;
131 struct crypto_hash
*hash_tfm
;
132 struct hash_desc desc
;
133 struct scatterlist sg
;
134 unsigned int saltsize
;
139 ti
->error
= "Digest algorithm missing for ESSIV mode";
143 /* Hash the cipher key with the given hash algorithm */
144 hash_tfm
= crypto_alloc_hash(opts
, 0, CRYPTO_ALG_ASYNC
);
145 if (IS_ERR(hash_tfm
)) {
146 ti
->error
= "Error initializing ESSIV hash";
147 return PTR_ERR(hash_tfm
);
150 saltsize
= crypto_hash_digestsize(hash_tfm
);
151 salt
= kmalloc(saltsize
, GFP_KERNEL
);
153 ti
->error
= "Error kmallocing salt storage in ESSIV";
154 crypto_free_hash(hash_tfm
);
158 sg_set_buf(&sg
, cc
->key
, cc
->key_size
);
160 desc
.flags
= CRYPTO_TFM_REQ_MAY_SLEEP
;
161 err
= crypto_hash_digest(&desc
, &sg
, cc
->key_size
, salt
);
162 crypto_free_hash(hash_tfm
);
165 ti
->error
= "Error calculating hash in ESSIV";
169 /* Setup the essiv_tfm with the given salt */
170 essiv_tfm
= crypto_alloc_cipher(cc
->cipher
, 0, CRYPTO_ALG_ASYNC
);
171 if (IS_ERR(essiv_tfm
)) {
172 ti
->error
= "Error allocating crypto tfm for ESSIV";
174 return PTR_ERR(essiv_tfm
);
176 if (crypto_cipher_blocksize(essiv_tfm
) !=
177 crypto_blkcipher_ivsize(cc
->tfm
)) {
178 ti
->error
= "Block size of ESSIV cipher does "
179 "not match IV size of block cipher";
180 crypto_free_cipher(essiv_tfm
);
184 err
= crypto_cipher_setkey(essiv_tfm
, salt
, saltsize
);
186 ti
->error
= "Failed to set key for ESSIV cipher";
187 crypto_free_cipher(essiv_tfm
);
193 cc
->iv_gen_private
= essiv_tfm
;
197 static void crypt_iv_essiv_dtr(struct crypt_config
*cc
)
199 crypto_free_cipher(cc
->iv_gen_private
);
200 cc
->iv_gen_private
= NULL
;
203 static int crypt_iv_essiv_gen(struct crypt_config
*cc
, u8
*iv
, sector_t sector
)
205 memset(iv
, 0, cc
->iv_size
);
206 *(u64
*)iv
= cpu_to_le64(sector
);
207 crypto_cipher_encrypt_one(cc
->iv_gen_private
, iv
, iv
);
211 static struct crypt_iv_operations crypt_iv_plain_ops
= {
212 .generator
= crypt_iv_plain_gen
215 static struct crypt_iv_operations crypt_iv_essiv_ops
= {
216 .ctr
= crypt_iv_essiv_ctr
,
217 .dtr
= crypt_iv_essiv_dtr
,
218 .generator
= crypt_iv_essiv_gen
223 crypt_convert_scatterlist(struct crypt_config
*cc
, struct scatterlist
*out
,
224 struct scatterlist
*in
, unsigned int length
,
225 int write
, sector_t sector
)
228 struct blkcipher_desc desc
= {
231 .flags
= CRYPTO_TFM_REQ_MAY_SLEEP
,
235 if (cc
->iv_gen_ops
) {
236 r
= cc
->iv_gen_ops
->generator(cc
, iv
, sector
);
241 r
= crypto_blkcipher_encrypt_iv(&desc
, out
, in
, length
);
243 r
= crypto_blkcipher_decrypt_iv(&desc
, out
, in
, length
);
246 r
= crypto_blkcipher_encrypt(&desc
, out
, in
, length
);
248 r
= crypto_blkcipher_decrypt(&desc
, out
, in
, length
);
255 crypt_convert_init(struct crypt_config
*cc
, struct convert_context
*ctx
,
256 struct bio
*bio_out
, struct bio
*bio_in
,
257 sector_t sector
, int write
)
259 ctx
->bio_in
= bio_in
;
260 ctx
->bio_out
= bio_out
;
263 ctx
->idx_in
= bio_in
? bio_in
->bi_idx
: 0;
264 ctx
->idx_out
= bio_out
? bio_out
->bi_idx
: 0;
265 ctx
->sector
= sector
+ cc
->iv_offset
;
270 * Encrypt / decrypt data from one bio to another one (can be the same one)
272 static int crypt_convert(struct crypt_config
*cc
,
273 struct convert_context
*ctx
)
277 while(ctx
->idx_in
< ctx
->bio_in
->bi_vcnt
&&
278 ctx
->idx_out
< ctx
->bio_out
->bi_vcnt
) {
279 struct bio_vec
*bv_in
= bio_iovec_idx(ctx
->bio_in
, ctx
->idx_in
);
280 struct bio_vec
*bv_out
= bio_iovec_idx(ctx
->bio_out
, ctx
->idx_out
);
281 struct scatterlist sg_in
= {
282 .page
= bv_in
->bv_page
,
283 .offset
= bv_in
->bv_offset
+ ctx
->offset_in
,
284 .length
= 1 << SECTOR_SHIFT
286 struct scatterlist sg_out
= {
287 .page
= bv_out
->bv_page
,
288 .offset
= bv_out
->bv_offset
+ ctx
->offset_out
,
289 .length
= 1 << SECTOR_SHIFT
292 ctx
->offset_in
+= sg_in
.length
;
293 if (ctx
->offset_in
>= bv_in
->bv_len
) {
298 ctx
->offset_out
+= sg_out
.length
;
299 if (ctx
->offset_out
>= bv_out
->bv_len
) {
304 r
= crypt_convert_scatterlist(cc
, &sg_out
, &sg_in
, sg_in
.length
,
305 ctx
->write
, ctx
->sector
);
315 static void dm_crypt_bio_destructor(struct bio
*bio
)
317 struct crypt_io
*io
= bio
->bi_private
;
318 struct crypt_config
*cc
= io
->target
->private;
320 bio_free(bio
, cc
->bs
);
324 * Generate a new unfragmented bio with the given size
325 * This should never violate the device limitations
326 * May return a smaller bio when running out of pages
329 crypt_alloc_buffer(struct crypt_config
*cc
, unsigned int size
,
330 struct bio
*base_bio
, unsigned int *bio_vec_idx
)
333 unsigned int nr_iovecs
= (size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
334 gfp_t gfp_mask
= GFP_NOIO
| __GFP_HIGHMEM
;
338 clone
= bio_alloc_bioset(GFP_NOIO
, base_bio
->bi_max_vecs
, cc
->bs
);
339 __bio_clone(clone
, base_bio
);
341 clone
= bio_alloc_bioset(GFP_NOIO
, nr_iovecs
, cc
->bs
);
346 clone
->bi_destructor
= dm_crypt_bio_destructor
;
348 /* if the last bio was not complete, continue where that one ended */
349 clone
->bi_idx
= *bio_vec_idx
;
350 clone
->bi_vcnt
= *bio_vec_idx
;
352 clone
->bi_flags
&= ~(1 << BIO_SEG_VALID
);
354 /* clone->bi_idx pages have already been allocated */
355 size
-= clone
->bi_idx
* PAGE_SIZE
;
357 for (i
= clone
->bi_idx
; i
< nr_iovecs
; i
++) {
358 struct bio_vec
*bv
= bio_iovec_idx(clone
, i
);
360 bv
->bv_page
= mempool_alloc(cc
->page_pool
, gfp_mask
);
365 * if additional pages cannot be allocated without waiting,
366 * return a partially allocated bio, the caller will then try
367 * to allocate additional bios while submitting this partial bio
369 if ((i
- clone
->bi_idx
) == (MIN_BIO_PAGES
- 1))
370 gfp_mask
= (gfp_mask
| __GFP_NOWARN
) & ~__GFP_WAIT
;
373 if (size
> PAGE_SIZE
)
374 bv
->bv_len
= PAGE_SIZE
;
378 clone
->bi_size
+= bv
->bv_len
;
383 if (!clone
->bi_size
) {
389 * Remember the last bio_vec allocated to be able
390 * to correctly continue after the splitting.
392 *bio_vec_idx
= clone
->bi_vcnt
;
397 static void crypt_free_buffer_pages(struct crypt_config
*cc
,
398 struct bio
*clone
, unsigned int bytes
)
400 unsigned int i
, start
, end
;
404 * This is ugly, but Jens Axboe thinks that using bi_idx in the
405 * endio function is too dangerous at the moment, so I calculate the
406 * correct position using bi_vcnt and bi_size.
407 * The bv_offset and bv_len fields might already be modified but we
408 * know that we always allocated whole pages.
409 * A fix to the bi_idx issue in the kernel is in the works, so
410 * we will hopefully be able to revert to the cleaner solution soon.
412 i
= clone
->bi_vcnt
- 1;
413 bv
= bio_iovec_idx(clone
, i
);
414 end
= (i
<< PAGE_SHIFT
) + (bv
->bv_offset
+ bv
->bv_len
) - clone
->bi_size
;
417 start
>>= PAGE_SHIFT
;
419 end
= clone
->bi_vcnt
;
423 for (i
= start
; i
< end
; i
++) {
424 bv
= bio_iovec_idx(clone
, i
);
425 BUG_ON(!bv
->bv_page
);
426 mempool_free(bv
->bv_page
, cc
->page_pool
);
432 * One of the bios was finished. Check for completion of
433 * the whole request and correctly clean up the buffer.
435 static void dec_pending(struct crypt_io
*io
, int error
)
437 struct crypt_config
*cc
= (struct crypt_config
*) io
->target
->private;
442 if (!atomic_dec_and_test(&io
->pending
))
446 bio_put(io
->first_clone
);
448 bio_endio(io
->base_bio
, io
->base_bio
->bi_size
, io
->error
);
450 mempool_free(io
, cc
->io_pool
);
456 * Needed because it would be very unwise to do decryption in an
459 static struct workqueue_struct
*_kcryptd_workqueue
;
460 static void kcryptd_do_work(void *data
);
462 static void kcryptd_queue_io(struct crypt_io
*io
)
464 INIT_WORK(&io
->work
, kcryptd_do_work
, io
);
465 queue_work(_kcryptd_workqueue
, &io
->work
);
468 static int crypt_endio(struct bio
*clone
, unsigned int done
, int error
)
470 struct crypt_io
*io
= clone
->bi_private
;
471 struct crypt_config
*cc
= io
->target
->private;
472 unsigned read_io
= bio_data_dir(clone
) == READ
;
475 * free the processed pages, even if
476 * it's only a partially completed write
479 crypt_free_buffer_pages(cc
, clone
, done
);
481 /* keep going - not finished yet */
482 if (unlikely(clone
->bi_size
))
488 if (unlikely(!bio_flagged(clone
, BIO_UPTODATE
))) {
494 io
->post_process
= 1;
495 kcryptd_queue_io(io
);
500 dec_pending(io
, error
);
504 static void clone_init(struct crypt_io
*io
, struct bio
*clone
)
506 struct crypt_config
*cc
= io
->target
->private;
508 clone
->bi_private
= io
;
509 clone
->bi_end_io
= crypt_endio
;
510 clone
->bi_bdev
= cc
->dev
->bdev
;
511 clone
->bi_rw
= io
->base_bio
->bi_rw
;
514 static void process_read(struct crypt_io
*io
)
516 struct crypt_config
*cc
= io
->target
->private;
517 struct bio
*base_bio
= io
->base_bio
;
519 sector_t sector
= base_bio
->bi_sector
- io
->target
->begin
;
521 atomic_inc(&io
->pending
);
524 * The block layer might modify the bvec array, so always
525 * copy the required bvecs because we need the original
526 * one in order to decrypt the whole bio data *afterwards*.
528 clone
= bio_alloc_bioset(GFP_NOIO
, bio_segments(base_bio
), cc
->bs
);
529 if (unlikely(!clone
)) {
530 dec_pending(io
, -ENOMEM
);
534 clone_init(io
, clone
);
535 clone
->bi_destructor
= dm_crypt_bio_destructor
;
537 clone
->bi_vcnt
= bio_segments(base_bio
);
538 clone
->bi_size
= base_bio
->bi_size
;
539 clone
->bi_sector
= cc
->start
+ sector
;
540 memcpy(clone
->bi_io_vec
, bio_iovec(base_bio
),
541 sizeof(struct bio_vec
) * clone
->bi_vcnt
);
543 generic_make_request(clone
);
546 static void process_write(struct crypt_io
*io
)
548 struct crypt_config
*cc
= io
->target
->private;
549 struct bio
*base_bio
= io
->base_bio
;
551 struct convert_context ctx
;
552 unsigned remaining
= base_bio
->bi_size
;
553 sector_t sector
= base_bio
->bi_sector
- io
->target
->begin
;
554 unsigned bvec_idx
= 0;
556 atomic_inc(&io
->pending
);
558 crypt_convert_init(cc
, &ctx
, NULL
, base_bio
, sector
, 1);
561 * The allocated buffers can be smaller than the whole bio,
562 * so repeat the whole process until all the data can be handled.
565 clone
= crypt_alloc_buffer(cc
, base_bio
->bi_size
,
566 io
->first_clone
, &bvec_idx
);
567 if (unlikely(!clone
)) {
568 dec_pending(io
, -ENOMEM
);
574 if (unlikely(crypt_convert(cc
, &ctx
) < 0)) {
575 crypt_free_buffer_pages(cc
, clone
, clone
->bi_size
);
577 dec_pending(io
, -EIO
);
581 clone_init(io
, clone
);
582 clone
->bi_sector
= cc
->start
+ sector
;
584 if (!io
->first_clone
) {
586 * hold a reference to the first clone, because it
587 * holds the bio_vec array and that can't be freed
588 * before all other clones are released
591 io
->first_clone
= clone
;
594 remaining
-= clone
->bi_size
;
595 sector
+= bio_sectors(clone
);
597 /* prevent bio_put of first_clone */
599 atomic_inc(&io
->pending
);
601 generic_make_request(clone
);
603 /* out of memory -> run queues */
605 blk_congestion_wait(bio_data_dir(clone
), HZ
/100);
609 static void process_read_endio(struct crypt_io
*io
)
611 struct crypt_config
*cc
= io
->target
->private;
612 struct convert_context ctx
;
614 crypt_convert_init(cc
, &ctx
, io
->base_bio
, io
->base_bio
,
615 io
->base_bio
->bi_sector
- io
->target
->begin
, 0);
617 dec_pending(io
, crypt_convert(cc
, &ctx
));
620 static void kcryptd_do_work(void *data
)
622 struct crypt_io
*io
= data
;
624 if (io
->post_process
)
625 process_read_endio(io
);
626 else if (bio_data_dir(io
->base_bio
) == READ
)
633 * Decode key from its hex representation
635 static int crypt_decode_key(u8
*key
, char *hex
, unsigned int size
)
643 for (i
= 0; i
< size
; i
++) {
647 key
[i
] = (u8
)simple_strtoul(buffer
, &endp
, 16);
649 if (endp
!= &buffer
[2])
660 * Encode key into its hex representation
662 static void crypt_encode_key(char *hex
, u8
*key
, unsigned int size
)
666 for (i
= 0; i
< size
; i
++) {
667 sprintf(hex
, "%02x", *key
);
673 static int crypt_set_key(struct crypt_config
*cc
, char *key
)
675 unsigned key_size
= strlen(key
) >> 1;
677 if (cc
->key_size
&& cc
->key_size
!= key_size
)
680 cc
->key_size
= key_size
; /* initial settings */
682 if ((!key_size
&& strcmp(key
, "-")) ||
683 (key_size
&& crypt_decode_key(cc
->key
, key
, key_size
) < 0))
686 set_bit(DM_CRYPT_KEY_VALID
, &cc
->flags
);
691 static int crypt_wipe_key(struct crypt_config
*cc
)
693 clear_bit(DM_CRYPT_KEY_VALID
, &cc
->flags
);
694 memset(&cc
->key
, 0, cc
->key_size
* sizeof(u8
));
699 * Construct an encryption mapping:
700 * <cipher> <key> <iv_offset> <dev_path> <start>
702 static int crypt_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
704 struct crypt_config
*cc
;
705 struct crypto_blkcipher
*tfm
;
711 unsigned int key_size
;
712 unsigned long long tmpll
;
715 ti
->error
= "Not enough arguments";
720 cipher
= strsep(&tmp
, "-");
721 chainmode
= strsep(&tmp
, "-");
722 ivopts
= strsep(&tmp
, "-");
723 ivmode
= strsep(&ivopts
, ":");
726 DMWARN("Unexpected additional cipher options");
728 key_size
= strlen(argv
[1]) >> 1;
730 cc
= kzalloc(sizeof(*cc
) + key_size
* sizeof(u8
), GFP_KERNEL
);
733 "Cannot allocate transparent encryption context";
737 if (crypt_set_key(cc
, argv
[1])) {
738 ti
->error
= "Error decoding key";
742 /* Compatiblity mode for old dm-crypt cipher strings */
743 if (!chainmode
|| (strcmp(chainmode
, "plain") == 0 && !ivmode
)) {
748 if (strcmp(chainmode
, "ecb") && !ivmode
) {
749 ti
->error
= "This chaining mode requires an IV mechanism";
753 if (snprintf(cc
->cipher
, CRYPTO_MAX_ALG_NAME
, "%s(%s)", chainmode
,
754 cipher
) >= CRYPTO_MAX_ALG_NAME
) {
755 ti
->error
= "Chain mode + cipher name is too long";
759 tfm
= crypto_alloc_blkcipher(cc
->cipher
, 0, CRYPTO_ALG_ASYNC
);
761 ti
->error
= "Error allocating crypto tfm";
765 strcpy(cc
->cipher
, cipher
);
766 strcpy(cc
->chainmode
, chainmode
);
770 * Choose ivmode. Valid modes: "plain", "essiv:<esshash>".
771 * See comments at iv code
775 cc
->iv_gen_ops
= NULL
;
776 else if (strcmp(ivmode
, "plain") == 0)
777 cc
->iv_gen_ops
= &crypt_iv_plain_ops
;
778 else if (strcmp(ivmode
, "essiv") == 0)
779 cc
->iv_gen_ops
= &crypt_iv_essiv_ops
;
781 ti
->error
= "Invalid IV mode";
785 if (cc
->iv_gen_ops
&& cc
->iv_gen_ops
->ctr
&&
786 cc
->iv_gen_ops
->ctr(cc
, ti
, ivopts
) < 0)
789 cc
->iv_size
= crypto_blkcipher_ivsize(tfm
);
791 /* at least a 64 bit sector number should fit in our buffer */
792 cc
->iv_size
= max(cc
->iv_size
,
793 (unsigned int)(sizeof(u64
) / sizeof(u8
)));
795 if (cc
->iv_gen_ops
) {
796 DMWARN("Selected cipher does not support IVs");
797 if (cc
->iv_gen_ops
->dtr
)
798 cc
->iv_gen_ops
->dtr(cc
);
799 cc
->iv_gen_ops
= NULL
;
803 cc
->io_pool
= mempool_create_slab_pool(MIN_IOS
, _crypt_io_pool
);
805 ti
->error
= "Cannot allocate crypt io mempool";
809 cc
->page_pool
= mempool_create_page_pool(MIN_POOL_PAGES
, 0);
810 if (!cc
->page_pool
) {
811 ti
->error
= "Cannot allocate page mempool";
815 cc
->bs
= bioset_create(MIN_IOS
, MIN_IOS
, 4);
817 ti
->error
= "Cannot allocate crypt bioset";
821 if (crypto_blkcipher_setkey(tfm
, cc
->key
, key_size
) < 0) {
822 ti
->error
= "Error setting key";
826 if (sscanf(argv
[2], "%llu", &tmpll
) != 1) {
827 ti
->error
= "Invalid iv_offset sector";
830 cc
->iv_offset
= tmpll
;
832 if (sscanf(argv
[4], "%llu", &tmpll
) != 1) {
833 ti
->error
= "Invalid device sector";
838 if (dm_get_device(ti
, argv
[3], cc
->start
, ti
->len
,
839 dm_table_get_mode(ti
->table
), &cc
->dev
)) {
840 ti
->error
= "Device lookup failed";
844 if (ivmode
&& cc
->iv_gen_ops
) {
847 cc
->iv_mode
= kmalloc(strlen(ivmode
) + 1, GFP_KERNEL
);
849 ti
->error
= "Error kmallocing iv_mode string";
852 strcpy(cc
->iv_mode
, ivmode
);
862 mempool_destroy(cc
->page_pool
);
864 mempool_destroy(cc
->io_pool
);
866 if (cc
->iv_gen_ops
&& cc
->iv_gen_ops
->dtr
)
867 cc
->iv_gen_ops
->dtr(cc
);
869 crypto_free_blkcipher(tfm
);
871 /* Must zero key material before freeing */
872 memset(cc
, 0, sizeof(*cc
) + cc
->key_size
* sizeof(u8
));
877 static void crypt_dtr(struct dm_target
*ti
)
879 struct crypt_config
*cc
= (struct crypt_config
*) ti
->private;
882 mempool_destroy(cc
->page_pool
);
883 mempool_destroy(cc
->io_pool
);
886 if (cc
->iv_gen_ops
&& cc
->iv_gen_ops
->dtr
)
887 cc
->iv_gen_ops
->dtr(cc
);
888 crypto_free_blkcipher(cc
->tfm
);
889 dm_put_device(ti
, cc
->dev
);
891 /* Must zero key material before freeing */
892 memset(cc
, 0, sizeof(*cc
) + cc
->key_size
* sizeof(u8
));
896 static int crypt_map(struct dm_target
*ti
, struct bio
*bio
,
897 union map_info
*map_context
)
899 struct crypt_config
*cc
= ti
->private;
902 io
= mempool_alloc(cc
->io_pool
, GFP_NOIO
);
905 io
->first_clone
= NULL
;
906 io
->error
= io
->post_process
= 0;
907 atomic_set(&io
->pending
, 0);
908 kcryptd_queue_io(io
);
913 static int crypt_status(struct dm_target
*ti
, status_type_t type
,
914 char *result
, unsigned int maxlen
)
916 struct crypt_config
*cc
= (struct crypt_config
*) ti
->private;
918 const char *chainmode
= NULL
;
922 case STATUSTYPE_INFO
:
926 case STATUSTYPE_TABLE
:
927 cipher
= crypto_blkcipher_name(cc
->tfm
);
929 chainmode
= cc
->chainmode
;
932 DMEMIT("%s-%s-%s ", cipher
, chainmode
, cc
->iv_mode
);
934 DMEMIT("%s-%s ", cipher
, chainmode
);
936 if (cc
->key_size
> 0) {
937 if ((maxlen
- sz
) < ((cc
->key_size
<< 1) + 1))
940 crypt_encode_key(result
+ sz
, cc
->key
, cc
->key_size
);
941 sz
+= cc
->key_size
<< 1;
948 DMEMIT(" %llu %s %llu", (unsigned long long)cc
->iv_offset
,
949 cc
->dev
->name
, (unsigned long long)cc
->start
);
955 static void crypt_postsuspend(struct dm_target
*ti
)
957 struct crypt_config
*cc
= ti
->private;
959 set_bit(DM_CRYPT_SUSPENDED
, &cc
->flags
);
962 static int crypt_preresume(struct dm_target
*ti
)
964 struct crypt_config
*cc
= ti
->private;
966 if (!test_bit(DM_CRYPT_KEY_VALID
, &cc
->flags
)) {
967 DMERR("aborting resume - crypt key is not set.");
974 static void crypt_resume(struct dm_target
*ti
)
976 struct crypt_config
*cc
= ti
->private;
978 clear_bit(DM_CRYPT_SUSPENDED
, &cc
->flags
);
985 static int crypt_message(struct dm_target
*ti
, unsigned argc
, char **argv
)
987 struct crypt_config
*cc
= ti
->private;
992 if (!strnicmp(argv
[0], MESG_STR("key"))) {
993 if (!test_bit(DM_CRYPT_SUSPENDED
, &cc
->flags
)) {
994 DMWARN("not suspended during key manipulation.");
997 if (argc
== 3 && !strnicmp(argv
[1], MESG_STR("set")))
998 return crypt_set_key(cc
, argv
[2]);
999 if (argc
== 2 && !strnicmp(argv
[1], MESG_STR("wipe")))
1000 return crypt_wipe_key(cc
);
1004 DMWARN("unrecognised message received.");
1008 static struct target_type crypt_target
= {
1010 .version
= {1, 3, 0},
1011 .module
= THIS_MODULE
,
1015 .status
= crypt_status
,
1016 .postsuspend
= crypt_postsuspend
,
1017 .preresume
= crypt_preresume
,
1018 .resume
= crypt_resume
,
1019 .message
= crypt_message
,
1022 static int __init
dm_crypt_init(void)
1026 _crypt_io_pool
= kmem_cache_create("dm-crypt_io",
1027 sizeof(struct crypt_io
),
1029 if (!_crypt_io_pool
)
1032 _kcryptd_workqueue
= create_workqueue("kcryptd");
1033 if (!_kcryptd_workqueue
) {
1035 DMERR("couldn't create kcryptd");
1039 r
= dm_register_target(&crypt_target
);
1041 DMERR("register failed %d", r
);
1048 destroy_workqueue(_kcryptd_workqueue
);
1050 kmem_cache_destroy(_crypt_io_pool
);
1054 static void __exit
dm_crypt_exit(void)
1056 int r
= dm_unregister_target(&crypt_target
);
1059 DMERR("unregister failed %d", r
);
1061 destroy_workqueue(_kcryptd_workqueue
);
1062 kmem_cache_destroy(_crypt_io_pool
);
1065 module_init(dm_crypt_init
);
1066 module_exit(dm_crypt_exit
);
1068 MODULE_AUTHOR("Christophe Saout <christophe@saout.de>");
1069 MODULE_DESCRIPTION(DM_NAME
" target for transparent encryption / decryption");
1070 MODULE_LICENSE("GPL");