2 * Copyright (C) 2003 Christophe Saout <christophe@saout.de>
3 * Copyright (C) 2004 Clemens Fruhwirth <clemens@endorphin.org>
5 * This file is released under the GPL.
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/kernel.h>
11 #include <linux/bio.h>
12 #include <linux/blkdev.h>
13 #include <linux/mempool.h>
14 #include <linux/slab.h>
15 #include <linux/crypto.h>
16 #include <linux/workqueue.h>
17 #include <asm/atomic.h>
18 #include <asm/scatterlist.h>
26 * per bio private data
29 struct dm_target
*target
;
31 struct bio
*first_clone
;
32 struct work_struct work
;
38 * context holding the current state of a multi-part conversion
40 struct convert_context
{
43 unsigned int offset_in
;
44 unsigned int offset_out
;
53 struct crypt_iv_operations
{
54 int (*ctr
)(struct crypt_config
*cc
, struct dm_target
*ti
,
56 void (*dtr
)(struct crypt_config
*cc
);
57 const char *(*status
)(struct crypt_config
*cc
);
58 int (*generator
)(struct crypt_config
*cc
, u8
*iv
, sector_t sector
);
62 * Crypt: maps a linear range of a block device
63 * and encrypts / decrypts at the same time.
70 * pool for per bio private data and
71 * for encryption buffer pages
79 struct crypt_iv_operations
*iv_gen_ops
;
85 struct crypto_tfm
*tfm
;
86 unsigned int key_size
;
91 #define MIN_POOL_PAGES 32
92 #define MIN_BIO_PAGES 8
94 static kmem_cache_t
*_crypt_io_pool
;
97 * Mempool alloc and free functions for the page
99 static void *mempool_alloc_page(unsigned int __nocast gfp_mask
, void *data
)
101 return alloc_page(gfp_mask
);
104 static void mempool_free_page(void *page
, void *data
)
111 * Different IV generation algorithms:
113 * plain: the initial vector is the 32-bit low-endian version of the sector
114 * number, padded with zeros if neccessary.
116 * ess_iv: "encrypted sector|salt initial vector", the sector number is
117 * encrypted with the bulk cipher using a salt as key. The salt
118 * should be derived from the bulk cipher's key via hashing.
120 * plumb: unimplemented, see:
121 * http://article.gmane.org/gmane.linux.kernel.device-mapper.dm-crypt/454
124 static int crypt_iv_plain_gen(struct crypt_config
*cc
, u8
*iv
, sector_t sector
)
126 memset(iv
, 0, cc
->iv_size
);
127 *(u32
*)iv
= cpu_to_le32(sector
& 0xffffffff);
132 static int crypt_iv_essiv_ctr(struct crypt_config
*cc
, struct dm_target
*ti
,
135 struct crypto_tfm
*essiv_tfm
;
136 struct crypto_tfm
*hash_tfm
;
137 struct scatterlist sg
;
138 unsigned int saltsize
;
142 ti
->error
= PFX
"Digest algorithm missing for ESSIV mode";
146 /* Hash the cipher key with the given hash algorithm */
147 hash_tfm
= crypto_alloc_tfm(opts
, 0);
148 if (hash_tfm
== NULL
) {
149 ti
->error
= PFX
"Error initializing ESSIV hash";
153 if (crypto_tfm_alg_type(hash_tfm
) != CRYPTO_ALG_TYPE_DIGEST
) {
154 ti
->error
= PFX
"Expected digest algorithm for ESSIV hash";
155 crypto_free_tfm(hash_tfm
);
159 saltsize
= crypto_tfm_alg_digestsize(hash_tfm
);
160 salt
= kmalloc(saltsize
, GFP_KERNEL
);
162 ti
->error
= PFX
"Error kmallocing salt storage in ESSIV";
163 crypto_free_tfm(hash_tfm
);
167 sg
.page
= virt_to_page(cc
->key
);
168 sg
.offset
= offset_in_page(cc
->key
);
169 sg
.length
= cc
->key_size
;
170 crypto_digest_digest(hash_tfm
, &sg
, 1, salt
);
171 crypto_free_tfm(hash_tfm
);
173 /* Setup the essiv_tfm with the given salt */
174 essiv_tfm
= crypto_alloc_tfm(crypto_tfm_alg_name(cc
->tfm
),
175 CRYPTO_TFM_MODE_ECB
);
176 if (essiv_tfm
== NULL
) {
177 ti
->error
= PFX
"Error allocating crypto tfm for ESSIV";
181 if (crypto_tfm_alg_blocksize(essiv_tfm
)
182 != crypto_tfm_alg_ivsize(cc
->tfm
)) {
183 ti
->error
= PFX
"Block size of ESSIV cipher does "
184 "not match IV size of block cipher";
185 crypto_free_tfm(essiv_tfm
);
189 if (crypto_cipher_setkey(essiv_tfm
, salt
, saltsize
) < 0) {
190 ti
->error
= PFX
"Failed to set key for ESSIV cipher";
191 crypto_free_tfm(essiv_tfm
);
197 cc
->iv_gen_private
= (void *)essiv_tfm
;
201 static void crypt_iv_essiv_dtr(struct crypt_config
*cc
)
203 crypto_free_tfm((struct crypto_tfm
*)cc
->iv_gen_private
);
204 cc
->iv_gen_private
= NULL
;
207 static int crypt_iv_essiv_gen(struct crypt_config
*cc
, u8
*iv
, sector_t sector
)
209 struct scatterlist sg
= { NULL
, };
211 memset(iv
, 0, cc
->iv_size
);
212 *(u64
*)iv
= cpu_to_le64(sector
);
214 sg
.page
= virt_to_page(iv
);
215 sg
.offset
= offset_in_page(iv
);
216 sg
.length
= cc
->iv_size
;
217 crypto_cipher_encrypt((struct crypto_tfm
*)cc
->iv_gen_private
,
218 &sg
, &sg
, cc
->iv_size
);
223 static struct crypt_iv_operations crypt_iv_plain_ops
= {
224 .generator
= crypt_iv_plain_gen
227 static struct crypt_iv_operations crypt_iv_essiv_ops
= {
228 .ctr
= crypt_iv_essiv_ctr
,
229 .dtr
= crypt_iv_essiv_dtr
,
230 .generator
= crypt_iv_essiv_gen
235 crypt_convert_scatterlist(struct crypt_config
*cc
, struct scatterlist
*out
,
236 struct scatterlist
*in
, unsigned int length
,
237 int write
, sector_t sector
)
242 if (cc
->iv_gen_ops
) {
243 r
= cc
->iv_gen_ops
->generator(cc
, iv
, sector
);
248 r
= crypto_cipher_encrypt_iv(cc
->tfm
, out
, in
, length
, iv
);
250 r
= crypto_cipher_decrypt_iv(cc
->tfm
, out
, in
, length
, iv
);
253 r
= crypto_cipher_encrypt(cc
->tfm
, out
, in
, length
);
255 r
= crypto_cipher_decrypt(cc
->tfm
, out
, in
, length
);
262 crypt_convert_init(struct crypt_config
*cc
, struct convert_context
*ctx
,
263 struct bio
*bio_out
, struct bio
*bio_in
,
264 sector_t sector
, int write
)
266 ctx
->bio_in
= bio_in
;
267 ctx
->bio_out
= bio_out
;
270 ctx
->idx_in
= bio_in
? bio_in
->bi_idx
: 0;
271 ctx
->idx_out
= bio_out
? bio_out
->bi_idx
: 0;
272 ctx
->sector
= sector
+ cc
->iv_offset
;
277 * Encrypt / decrypt data from one bio to another one (can be the same one)
279 static int crypt_convert(struct crypt_config
*cc
,
280 struct convert_context
*ctx
)
284 while(ctx
->idx_in
< ctx
->bio_in
->bi_vcnt
&&
285 ctx
->idx_out
< ctx
->bio_out
->bi_vcnt
) {
286 struct bio_vec
*bv_in
= bio_iovec_idx(ctx
->bio_in
, ctx
->idx_in
);
287 struct bio_vec
*bv_out
= bio_iovec_idx(ctx
->bio_out
, ctx
->idx_out
);
288 struct scatterlist sg_in
= {
289 .page
= bv_in
->bv_page
,
290 .offset
= bv_in
->bv_offset
+ ctx
->offset_in
,
291 .length
= 1 << SECTOR_SHIFT
293 struct scatterlist sg_out
= {
294 .page
= bv_out
->bv_page
,
295 .offset
= bv_out
->bv_offset
+ ctx
->offset_out
,
296 .length
= 1 << SECTOR_SHIFT
299 ctx
->offset_in
+= sg_in
.length
;
300 if (ctx
->offset_in
>= bv_in
->bv_len
) {
305 ctx
->offset_out
+= sg_out
.length
;
306 if (ctx
->offset_out
>= bv_out
->bv_len
) {
311 r
= crypt_convert_scatterlist(cc
, &sg_out
, &sg_in
, sg_in
.length
,
312 ctx
->write
, ctx
->sector
);
323 * Generate a new unfragmented bio with the given size
324 * This should never violate the device limitations
325 * May return a smaller bio when running out of pages
328 crypt_alloc_buffer(struct crypt_config
*cc
, unsigned int size
,
329 struct bio
*base_bio
, unsigned int *bio_vec_idx
)
332 unsigned int nr_iovecs
= (size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
333 int gfp_mask
= GFP_NOIO
| __GFP_HIGHMEM
;
334 unsigned long flags
= current
->flags
;
338 * Tell VM to act less aggressively and fail earlier.
339 * This is not necessary but increases throughput.
340 * FIXME: Is this really intelligent?
342 current
->flags
&= ~PF_MEMALLOC
;
345 bio
= bio_clone(base_bio
, GFP_NOIO
);
347 bio
= bio_alloc(GFP_NOIO
, nr_iovecs
);
349 if (flags
& PF_MEMALLOC
)
350 current
->flags
|= PF_MEMALLOC
;
354 /* if the last bio was not complete, continue where that one ended */
355 bio
->bi_idx
= *bio_vec_idx
;
356 bio
->bi_vcnt
= *bio_vec_idx
;
358 bio
->bi_flags
&= ~(1 << BIO_SEG_VALID
);
360 /* bio->bi_idx pages have already been allocated */
361 size
-= bio
->bi_idx
* PAGE_SIZE
;
363 for(i
= bio
->bi_idx
; i
< nr_iovecs
; i
++) {
364 struct bio_vec
*bv
= bio_iovec_idx(bio
, i
);
366 bv
->bv_page
= mempool_alloc(cc
->page_pool
, gfp_mask
);
371 * if additional pages cannot be allocated without waiting,
372 * return a partially allocated bio, the caller will then try
373 * to allocate additional bios while submitting this partial bio
375 if ((i
- bio
->bi_idx
) == (MIN_BIO_PAGES
- 1))
376 gfp_mask
= (gfp_mask
| __GFP_NOWARN
) & ~__GFP_WAIT
;
379 if (size
> PAGE_SIZE
)
380 bv
->bv_len
= PAGE_SIZE
;
384 bio
->bi_size
+= bv
->bv_len
;
389 if (flags
& PF_MEMALLOC
)
390 current
->flags
|= PF_MEMALLOC
;
398 * Remember the last bio_vec allocated to be able
399 * to correctly continue after the splitting.
401 *bio_vec_idx
= bio
->bi_vcnt
;
406 static void crypt_free_buffer_pages(struct crypt_config
*cc
,
407 struct bio
*bio
, unsigned int bytes
)
409 unsigned int i
, start
, end
;
413 * This is ugly, but Jens Axboe thinks that using bi_idx in the
414 * endio function is too dangerous at the moment, so I calculate the
415 * correct position using bi_vcnt and bi_size.
416 * The bv_offset and bv_len fields might already be modified but we
417 * know that we always allocated whole pages.
418 * A fix to the bi_idx issue in the kernel is in the works, so
419 * we will hopefully be able to revert to the cleaner solution soon.
421 i
= bio
->bi_vcnt
- 1;
422 bv
= bio_iovec_idx(bio
, i
);
423 end
= (i
<< PAGE_SHIFT
) + (bv
->bv_offset
+ bv
->bv_len
) - bio
->bi_size
;
426 start
>>= PAGE_SHIFT
;
432 for(i
= start
; i
< end
; i
++) {
433 bv
= bio_iovec_idx(bio
, i
);
434 BUG_ON(!bv
->bv_page
);
435 mempool_free(bv
->bv_page
, cc
->page_pool
);
441 * One of the bios was finished. Check for completion of
442 * the whole request and correctly clean up the buffer.
444 static void dec_pending(struct crypt_io
*io
, int error
)
446 struct crypt_config
*cc
= (struct crypt_config
*) io
->target
->private;
451 if (!atomic_dec_and_test(&io
->pending
))
455 bio_put(io
->first_clone
);
457 bio_endio(io
->bio
, io
->bio
->bi_size
, io
->error
);
459 mempool_free(io
, cc
->io_pool
);
465 * Needed because it would be very unwise to do decryption in an
466 * interrupt context, so bios returning from read requests get
469 static struct workqueue_struct
*_kcryptd_workqueue
;
471 static void kcryptd_do_work(void *data
)
473 struct crypt_io
*io
= (struct crypt_io
*) data
;
474 struct crypt_config
*cc
= (struct crypt_config
*) io
->target
->private;
475 struct convert_context ctx
;
478 crypt_convert_init(cc
, &ctx
, io
->bio
, io
->bio
,
479 io
->bio
->bi_sector
- io
->target
->begin
, 0);
480 r
= crypt_convert(cc
, &ctx
);
485 static void kcryptd_queue_io(struct crypt_io
*io
)
487 INIT_WORK(&io
->work
, kcryptd_do_work
, io
);
488 queue_work(_kcryptd_workqueue
, &io
->work
);
492 * Decode key from its hex representation
494 static int crypt_decode_key(u8
*key
, char *hex
, unsigned int size
)
502 for(i
= 0; i
< size
; i
++) {
506 key
[i
] = (u8
)simple_strtoul(buffer
, &endp
, 16);
508 if (endp
!= &buffer
[2])
519 * Encode key into its hex representation
521 static void crypt_encode_key(char *hex
, u8
*key
, unsigned int size
)
525 for(i
= 0; i
< size
; i
++) {
526 sprintf(hex
, "%02x", *key
);
533 * Construct an encryption mapping:
534 * <cipher> <key> <iv_offset> <dev_path> <start>
536 static int crypt_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
538 struct crypt_config
*cc
;
539 struct crypto_tfm
*tfm
;
545 unsigned int crypto_flags
;
546 unsigned int key_size
;
549 ti
->error
= PFX
"Not enough arguments";
554 cipher
= strsep(&tmp
, "-");
555 chainmode
= strsep(&tmp
, "-");
556 ivopts
= strsep(&tmp
, "-");
557 ivmode
= strsep(&ivopts
, ":");
560 DMWARN(PFX
"Unexpected additional cipher options");
562 key_size
= strlen(argv
[1]) >> 1;
564 cc
= kmalloc(sizeof(*cc
) + key_size
* sizeof(u8
), GFP_KERNEL
);
567 PFX
"Cannot allocate transparent encryption context";
571 cc
->key_size
= key_size
;
572 if ((!key_size
&& strcmp(argv
[1], "-") != 0) ||
573 (key_size
&& crypt_decode_key(cc
->key
, argv
[1], key_size
) < 0)) {
574 ti
->error
= PFX
"Error decoding key";
578 /* Compatiblity mode for old dm-crypt cipher strings */
579 if (!chainmode
|| (strcmp(chainmode
, "plain") == 0 && !ivmode
)) {
584 /* Choose crypto_flags according to chainmode */
585 if (strcmp(chainmode
, "cbc") == 0)
586 crypto_flags
= CRYPTO_TFM_MODE_CBC
;
587 else if (strcmp(chainmode
, "ecb") == 0)
588 crypto_flags
= CRYPTO_TFM_MODE_ECB
;
590 ti
->error
= PFX
"Unknown chaining mode";
594 if (crypto_flags
!= CRYPTO_TFM_MODE_ECB
&& !ivmode
) {
595 ti
->error
= PFX
"This chaining mode requires an IV mechanism";
599 tfm
= crypto_alloc_tfm(cipher
, crypto_flags
);
601 ti
->error
= PFX
"Error allocating crypto tfm";
604 if (crypto_tfm_alg_type(tfm
) != CRYPTO_ALG_TYPE_CIPHER
) {
605 ti
->error
= PFX
"Expected cipher algorithm";
612 * Choose ivmode. Valid modes: "plain", "essiv:<esshash>".
613 * See comments at iv code
617 cc
->iv_gen_ops
= NULL
;
618 else if (strcmp(ivmode
, "plain") == 0)
619 cc
->iv_gen_ops
= &crypt_iv_plain_ops
;
620 else if (strcmp(ivmode
, "essiv") == 0)
621 cc
->iv_gen_ops
= &crypt_iv_essiv_ops
;
623 ti
->error
= PFX
"Invalid IV mode";
627 if (cc
->iv_gen_ops
&& cc
->iv_gen_ops
->ctr
&&
628 cc
->iv_gen_ops
->ctr(cc
, ti
, ivopts
) < 0)
631 if (tfm
->crt_cipher
.cit_decrypt_iv
&& tfm
->crt_cipher
.cit_encrypt_iv
)
632 /* at least a 64 bit sector number should fit in our buffer */
633 cc
->iv_size
= max(crypto_tfm_alg_ivsize(tfm
),
634 (unsigned int)(sizeof(u64
) / sizeof(u8
)));
637 if (cc
->iv_gen_ops
) {
638 DMWARN(PFX
"Selected cipher does not support IVs");
639 if (cc
->iv_gen_ops
->dtr
)
640 cc
->iv_gen_ops
->dtr(cc
);
641 cc
->iv_gen_ops
= NULL
;
645 cc
->io_pool
= mempool_create(MIN_IOS
, mempool_alloc_slab
,
646 mempool_free_slab
, _crypt_io_pool
);
648 ti
->error
= PFX
"Cannot allocate crypt io mempool";
652 cc
->page_pool
= mempool_create(MIN_POOL_PAGES
, mempool_alloc_page
,
653 mempool_free_page
, NULL
);
654 if (!cc
->page_pool
) {
655 ti
->error
= PFX
"Cannot allocate page mempool";
659 if (tfm
->crt_cipher
.cit_setkey(tfm
, cc
->key
, key_size
) < 0) {
660 ti
->error
= PFX
"Error setting key";
664 if (sscanf(argv
[2], SECTOR_FORMAT
, &cc
->iv_offset
) != 1) {
665 ti
->error
= PFX
"Invalid iv_offset sector";
669 if (sscanf(argv
[4], SECTOR_FORMAT
, &cc
->start
) != 1) {
670 ti
->error
= PFX
"Invalid device sector";
674 if (dm_get_device(ti
, argv
[3], cc
->start
, ti
->len
,
675 dm_table_get_mode(ti
->table
), &cc
->dev
)) {
676 ti
->error
= PFX
"Device lookup failed";
680 if (ivmode
&& cc
->iv_gen_ops
) {
683 cc
->iv_mode
= kmalloc(strlen(ivmode
) + 1, GFP_KERNEL
);
685 ti
->error
= PFX
"Error kmallocing iv_mode string";
688 strcpy(cc
->iv_mode
, ivmode
);
696 mempool_destroy(cc
->page_pool
);
698 mempool_destroy(cc
->io_pool
);
700 if (cc
->iv_gen_ops
&& cc
->iv_gen_ops
->dtr
)
701 cc
->iv_gen_ops
->dtr(cc
);
703 crypto_free_tfm(tfm
);
709 static void crypt_dtr(struct dm_target
*ti
)
711 struct crypt_config
*cc
= (struct crypt_config
*) ti
->private;
713 mempool_destroy(cc
->page_pool
);
714 mempool_destroy(cc
->io_pool
);
718 if (cc
->iv_gen_ops
&& cc
->iv_gen_ops
->dtr
)
719 cc
->iv_gen_ops
->dtr(cc
);
720 crypto_free_tfm(cc
->tfm
);
721 dm_put_device(ti
, cc
->dev
);
725 static int crypt_endio(struct bio
*bio
, unsigned int done
, int error
)
727 struct crypt_io
*io
= (struct crypt_io
*) bio
->bi_private
;
728 struct crypt_config
*cc
= (struct crypt_config
*) io
->target
->private;
730 if (bio_data_dir(bio
) == WRITE
) {
732 * free the processed pages, even if
733 * it's only a partially completed write
735 crypt_free_buffer_pages(cc
, bio
, done
);
744 * successful reads are decrypted by the worker thread
746 if ((bio_data_dir(bio
) == READ
)
747 && bio_flagged(bio
, BIO_UPTODATE
)) {
748 kcryptd_queue_io(io
);
752 dec_pending(io
, error
);
756 static inline struct bio
*
757 crypt_clone(struct crypt_config
*cc
, struct crypt_io
*io
, struct bio
*bio
,
758 sector_t sector
, unsigned int *bvec_idx
,
759 struct convert_context
*ctx
)
763 if (bio_data_dir(bio
) == WRITE
) {
764 clone
= crypt_alloc_buffer(cc
, bio
->bi_size
,
765 io
->first_clone
, bvec_idx
);
767 ctx
->bio_out
= clone
;
768 if (crypt_convert(cc
, ctx
) < 0) {
769 crypt_free_buffer_pages(cc
, clone
,
777 * The block layer might modify the bvec array, so always
778 * copy the required bvecs because we need the original
779 * one in order to decrypt the whole bio data *afterwards*.
781 clone
= bio_alloc(GFP_NOIO
, bio_segments(bio
));
784 clone
->bi_vcnt
= bio_segments(bio
);
785 clone
->bi_size
= bio
->bi_size
;
786 memcpy(clone
->bi_io_vec
, bio_iovec(bio
),
787 sizeof(struct bio_vec
) * clone
->bi_vcnt
);
794 clone
->bi_private
= io
;
795 clone
->bi_end_io
= crypt_endio
;
796 clone
->bi_bdev
= cc
->dev
->bdev
;
797 clone
->bi_sector
= cc
->start
+ sector
;
798 clone
->bi_rw
= bio
->bi_rw
;
803 static int crypt_map(struct dm_target
*ti
, struct bio
*bio
,
804 union map_info
*map_context
)
806 struct crypt_config
*cc
= (struct crypt_config
*) ti
->private;
807 struct crypt_io
*io
= mempool_alloc(cc
->io_pool
, GFP_NOIO
);
808 struct convert_context ctx
;
810 unsigned int remaining
= bio
->bi_size
;
811 sector_t sector
= bio
->bi_sector
- ti
->begin
;
812 unsigned int bvec_idx
= 0;
816 io
->first_clone
= NULL
;
818 atomic_set(&io
->pending
, 1); /* hold a reference */
820 if (bio_data_dir(bio
) == WRITE
)
821 crypt_convert_init(cc
, &ctx
, NULL
, bio
, sector
, 1);
824 * The allocated buffers can be smaller than the whole bio,
825 * so repeat the whole process until all the data can be handled.
828 clone
= crypt_clone(cc
, io
, bio
, sector
, &bvec_idx
, &ctx
);
832 if (!io
->first_clone
) {
834 * hold a reference to the first clone, because it
835 * holds the bio_vec array and that can't be freed
836 * before all other clones are released
839 io
->first_clone
= clone
;
841 atomic_inc(&io
->pending
);
843 remaining
-= clone
->bi_size
;
844 sector
+= bio_sectors(clone
);
846 generic_make_request(clone
);
848 /* out of memory -> run queues */
850 blk_congestion_wait(bio_data_dir(clone
), HZ
/100);
853 /* drop reference, clones could have returned before we reach this */
858 if (io
->first_clone
) {
859 dec_pending(io
, -ENOMEM
);
863 /* if no bio has been dispatched yet, we can directly return the error */
864 mempool_free(io
, cc
->io_pool
);
868 static int crypt_status(struct dm_target
*ti
, status_type_t type
,
869 char *result
, unsigned int maxlen
)
871 struct crypt_config
*cc
= (struct crypt_config
*) ti
->private;
873 const char *chainmode
= NULL
;
877 case STATUSTYPE_INFO
:
881 case STATUSTYPE_TABLE
:
882 cipher
= crypto_tfm_alg_name(cc
->tfm
);
884 switch(cc
->tfm
->crt_cipher
.cit_mode
) {
885 case CRYPTO_TFM_MODE_CBC
:
888 case CRYPTO_TFM_MODE_ECB
:
896 DMEMIT("%s-%s-%s ", cipher
, chainmode
, cc
->iv_mode
);
898 DMEMIT("%s-%s ", cipher
, chainmode
);
900 if (cc
->key_size
> 0) {
901 if ((maxlen
- sz
) < ((cc
->key_size
<< 1) + 1))
904 crypt_encode_key(result
+ sz
, cc
->key
, cc
->key_size
);
905 sz
+= cc
->key_size
<< 1;
912 DMEMIT(" " SECTOR_FORMAT
" %s " SECTOR_FORMAT
,
913 cc
->iv_offset
, cc
->dev
->name
, cc
->start
);
919 static struct target_type crypt_target
= {
922 .module
= THIS_MODULE
,
926 .status
= crypt_status
,
929 static int __init
dm_crypt_init(void)
933 _crypt_io_pool
= kmem_cache_create("dm-crypt_io",
934 sizeof(struct crypt_io
),
939 _kcryptd_workqueue
= create_workqueue("kcryptd");
940 if (!_kcryptd_workqueue
) {
942 DMERR(PFX
"couldn't create kcryptd");
946 r
= dm_register_target(&crypt_target
);
948 DMERR(PFX
"register failed %d", r
);
955 destroy_workqueue(_kcryptd_workqueue
);
957 kmem_cache_destroy(_crypt_io_pool
);
961 static void __exit
dm_crypt_exit(void)
963 int r
= dm_unregister_target(&crypt_target
);
966 DMERR(PFX
"unregister failed %d", r
);
968 destroy_workqueue(_kcryptd_workqueue
);
969 kmem_cache_destroy(_crypt_io_pool
);
972 module_init(dm_crypt_init
);
973 module_exit(dm_crypt_exit
);
975 MODULE_AUTHOR("Christophe Saout <christophe@saout.de>");
976 MODULE_DESCRIPTION(DM_NAME
" target for transparent encryption / decryption");
977 MODULE_LICENSE("GPL");