2ea3eb99c91f013b9b438754d5b6ab2c124a62b0
[linux-2.6.git] / drivers / md / dm-crypt.c
1 /*
2  * Copyright (C) 2003 Christophe Saout <christophe@saout.de>
3  * Copyright (C) 2004 Clemens Fruhwirth <clemens@endorphin.org>
4  * Copyright (C) 2006-2007 Red Hat, Inc. All rights reserved.
5  *
6  * This file is released under the GPL.
7  */
8
9 #include <linux/completion.h>
10 #include <linux/err.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/bio.h>
15 #include <linux/blkdev.h>
16 #include <linux/mempool.h>
17 #include <linux/slab.h>
18 #include <linux/crypto.h>
19 #include <linux/workqueue.h>
20 #include <linux/backing-dev.h>
21 #include <asm/atomic.h>
22 #include <linux/scatterlist.h>
23 #include <asm/page.h>
24 #include <asm/unaligned.h>
25
26 #include "dm.h"
27
28 #define DM_MSG_PREFIX "crypt"
29 #define MESG_STR(x) x, sizeof(x)
30
31 /*
32  * context holding the current state of a multi-part conversion
33  */
34 struct convert_context {
35         struct completion restart;
36         struct bio *bio_in;
37         struct bio *bio_out;
38         unsigned int offset_in;
39         unsigned int offset_out;
40         unsigned int idx_in;
41         unsigned int idx_out;
42         sector_t sector;
43         atomic_t pending;
44 };
45
46 /*
47  * per bio private data
48  */
49 struct dm_crypt_io {
50         struct dm_target *target;
51         struct bio *base_bio;
52         struct work_struct work;
53
54         struct convert_context ctx;
55
56         atomic_t pending;
57         int error;
58         sector_t sector;
59 };
60
61 struct dm_crypt_request {
62         struct scatterlist sg_in;
63         struct scatterlist sg_out;
64 };
65
66 struct crypt_config;
67
68 struct crypt_iv_operations {
69         int (*ctr)(struct crypt_config *cc, struct dm_target *ti,
70                    const char *opts);
71         void (*dtr)(struct crypt_config *cc);
72         const char *(*status)(struct crypt_config *cc);
73         int (*generator)(struct crypt_config *cc, u8 *iv, sector_t sector);
74 };
75
76 /*
77  * Crypt: maps a linear range of a block device
78  * and encrypts / decrypts at the same time.
79  */
80 enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID };
81 struct crypt_config {
82         struct dm_dev *dev;
83         sector_t start;
84
85         /*
86          * pool for per bio private data, crypto requests and
87          * encryption requeusts/buffer pages
88          */
89         mempool_t *io_pool;
90         mempool_t *req_pool;
91         mempool_t *page_pool;
92         struct bio_set *bs;
93
94         struct workqueue_struct *io_queue;
95         struct workqueue_struct *crypt_queue;
96         /*
97          * crypto related data
98          */
99         struct crypt_iv_operations *iv_gen_ops;
100         char *iv_mode;
101         union {
102                 struct crypto_cipher *essiv_tfm;
103                 int benbi_shift;
104         } iv_gen_private;
105         sector_t iv_offset;
106         unsigned int iv_size;
107
108         /*
109          * Layout of each crypto request:
110          *
111          *   struct ablkcipher_request
112          *      context
113          *      padding
114          *   struct dm_crypt_request
115          *      padding
116          *   IV
117          *
118          * The padding is added so that dm_crypt_request and the IV are
119          * correctly aligned.
120          */
121         unsigned int dmreq_start;
122         struct ablkcipher_request *req;
123
124         char cipher[CRYPTO_MAX_ALG_NAME];
125         char chainmode[CRYPTO_MAX_ALG_NAME];
126         struct crypto_blkcipher *tfm;
127         unsigned long flags;
128         unsigned int key_size;
129         u8 key[0];
130 };
131
132 #define MIN_IOS        16
133 #define MIN_POOL_PAGES 32
134 #define MIN_BIO_PAGES  8
135
136 static struct kmem_cache *_crypt_io_pool;
137
138 static void clone_init(struct dm_crypt_io *, struct bio *);
139 static void kcryptd_queue_crypt(struct dm_crypt_io *io);
140
141 /*
142  * Different IV generation algorithms:
143  *
144  * plain: the initial vector is the 32-bit little-endian version of the sector
145  *        number, padded with zeros if necessary.
146  *
147  * essiv: "encrypted sector|salt initial vector", the sector number is
148  *        encrypted with the bulk cipher using a salt as key. The salt
149  *        should be derived from the bulk cipher's key via hashing.
150  *
151  * benbi: the 64-bit "big-endian 'narrow block'-count", starting at 1
152  *        (needed for LRW-32-AES and possible other narrow block modes)
153  *
154  * null: the initial vector is always zero.  Provides compatibility with
155  *       obsolete loop_fish2 devices.  Do not use for new devices.
156  *
157  * plumb: unimplemented, see:
158  * http://article.gmane.org/gmane.linux.kernel.device-mapper.dm-crypt/454
159  */
160
161 static int crypt_iv_plain_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
162 {
163         memset(iv, 0, cc->iv_size);
164         *(u32 *)iv = cpu_to_le32(sector & 0xffffffff);
165
166         return 0;
167 }
168
169 static int crypt_iv_essiv_ctr(struct crypt_config *cc, struct dm_target *ti,
170                               const char *opts)
171 {
172         struct crypto_cipher *essiv_tfm;
173         struct crypto_hash *hash_tfm;
174         struct hash_desc desc;
175         struct scatterlist sg;
176         unsigned int saltsize;
177         u8 *salt;
178         int err;
179
180         if (opts == NULL) {
181                 ti->error = "Digest algorithm missing for ESSIV mode";
182                 return -EINVAL;
183         }
184
185         /* Hash the cipher key with the given hash algorithm */
186         hash_tfm = crypto_alloc_hash(opts, 0, CRYPTO_ALG_ASYNC);
187         if (IS_ERR(hash_tfm)) {
188                 ti->error = "Error initializing ESSIV hash";
189                 return PTR_ERR(hash_tfm);
190         }
191
192         saltsize = crypto_hash_digestsize(hash_tfm);
193         salt = kmalloc(saltsize, GFP_KERNEL);
194         if (salt == NULL) {
195                 ti->error = "Error kmallocing salt storage in ESSIV";
196                 crypto_free_hash(hash_tfm);
197                 return -ENOMEM;
198         }
199
200         sg_init_one(&sg, cc->key, cc->key_size);
201         desc.tfm = hash_tfm;
202         desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
203         err = crypto_hash_digest(&desc, &sg, cc->key_size, salt);
204         crypto_free_hash(hash_tfm);
205
206         if (err) {
207                 ti->error = "Error calculating hash in ESSIV";
208                 kfree(salt);
209                 return err;
210         }
211
212         /* Setup the essiv_tfm with the given salt */
213         essiv_tfm = crypto_alloc_cipher(cc->cipher, 0, CRYPTO_ALG_ASYNC);
214         if (IS_ERR(essiv_tfm)) {
215                 ti->error = "Error allocating crypto tfm for ESSIV";
216                 kfree(salt);
217                 return PTR_ERR(essiv_tfm);
218         }
219         if (crypto_cipher_blocksize(essiv_tfm) !=
220             crypto_blkcipher_ivsize(cc->tfm)) {
221                 ti->error = "Block size of ESSIV cipher does "
222                             "not match IV size of block cipher";
223                 crypto_free_cipher(essiv_tfm);
224                 kfree(salt);
225                 return -EINVAL;
226         }
227         err = crypto_cipher_setkey(essiv_tfm, salt, saltsize);
228         if (err) {
229                 ti->error = "Failed to set key for ESSIV cipher";
230                 crypto_free_cipher(essiv_tfm);
231                 kfree(salt);
232                 return err;
233         }
234         kfree(salt);
235
236         cc->iv_gen_private.essiv_tfm = essiv_tfm;
237         return 0;
238 }
239
240 static void crypt_iv_essiv_dtr(struct crypt_config *cc)
241 {
242         crypto_free_cipher(cc->iv_gen_private.essiv_tfm);
243         cc->iv_gen_private.essiv_tfm = NULL;
244 }
245
246 static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
247 {
248         memset(iv, 0, cc->iv_size);
249         *(u64 *)iv = cpu_to_le64(sector);
250         crypto_cipher_encrypt_one(cc->iv_gen_private.essiv_tfm, iv, iv);
251         return 0;
252 }
253
254 static int crypt_iv_benbi_ctr(struct crypt_config *cc, struct dm_target *ti,
255                               const char *opts)
256 {
257         unsigned int bs = crypto_blkcipher_blocksize(cc->tfm);
258         int log = ilog2(bs);
259
260         /* we need to calculate how far we must shift the sector count
261          * to get the cipher block count, we use this shift in _gen */
262
263         if (1 << log != bs) {
264                 ti->error = "cypher blocksize is not a power of 2";
265                 return -EINVAL;
266         }
267
268         if (log > 9) {
269                 ti->error = "cypher blocksize is > 512";
270                 return -EINVAL;
271         }
272
273         cc->iv_gen_private.benbi_shift = 9 - log;
274
275         return 0;
276 }
277
278 static void crypt_iv_benbi_dtr(struct crypt_config *cc)
279 {
280 }
281
282 static int crypt_iv_benbi_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
283 {
284         __be64 val;
285
286         memset(iv, 0, cc->iv_size - sizeof(u64)); /* rest is cleared below */
287
288         val = cpu_to_be64(((u64)sector << cc->iv_gen_private.benbi_shift) + 1);
289         put_unaligned(val, (__be64 *)(iv + cc->iv_size - sizeof(u64)));
290
291         return 0;
292 }
293
294 static int crypt_iv_null_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
295 {
296         memset(iv, 0, cc->iv_size);
297
298         return 0;
299 }
300
301 static struct crypt_iv_operations crypt_iv_plain_ops = {
302         .generator = crypt_iv_plain_gen
303 };
304
305 static struct crypt_iv_operations crypt_iv_essiv_ops = {
306         .ctr       = crypt_iv_essiv_ctr,
307         .dtr       = crypt_iv_essiv_dtr,
308         .generator = crypt_iv_essiv_gen
309 };
310
311 static struct crypt_iv_operations crypt_iv_benbi_ops = {
312         .ctr       = crypt_iv_benbi_ctr,
313         .dtr       = crypt_iv_benbi_dtr,
314         .generator = crypt_iv_benbi_gen
315 };
316
317 static struct crypt_iv_operations crypt_iv_null_ops = {
318         .generator = crypt_iv_null_gen
319 };
320
321 static int
322 crypt_convert_scatterlist(struct crypt_config *cc, struct scatterlist *out,
323                           struct scatterlist *in, unsigned int length,
324                           int write, sector_t sector)
325 {
326         u8 iv[cc->iv_size] __attribute__ ((aligned(__alignof__(u64))));
327         struct blkcipher_desc desc = {
328                 .tfm = cc->tfm,
329                 .info = iv,
330                 .flags = CRYPTO_TFM_REQ_MAY_SLEEP,
331         };
332         int r;
333
334         if (cc->iv_gen_ops) {
335                 r = cc->iv_gen_ops->generator(cc, iv, sector);
336                 if (r < 0)
337                         return r;
338
339                 if (write)
340                         r = crypto_blkcipher_encrypt_iv(&desc, out, in, length);
341                 else
342                         r = crypto_blkcipher_decrypt_iv(&desc, out, in, length);
343         } else {
344                 if (write)
345                         r = crypto_blkcipher_encrypt(&desc, out, in, length);
346                 else
347                         r = crypto_blkcipher_decrypt(&desc, out, in, length);
348         }
349
350         return r;
351 }
352
353 static void crypt_convert_init(struct crypt_config *cc,
354                                struct convert_context *ctx,
355                                struct bio *bio_out, struct bio *bio_in,
356                                sector_t sector)
357 {
358         ctx->bio_in = bio_in;
359         ctx->bio_out = bio_out;
360         ctx->offset_in = 0;
361         ctx->offset_out = 0;
362         ctx->idx_in = bio_in ? bio_in->bi_idx : 0;
363         ctx->idx_out = bio_out ? bio_out->bi_idx : 0;
364         ctx->sector = sector + cc->iv_offset;
365         init_completion(&ctx->restart);
366         /*
367          * Crypto operation can be asynchronous,
368          * ctx->pending is increased after request submission.
369          * We need to ensure that we don't call the crypt finish
370          * operation before pending got incremented
371          * (dependent on crypt submission return code).
372          */
373         atomic_set(&ctx->pending, 2);
374 }
375
376 static int crypt_convert_block(struct crypt_config *cc,
377                                struct convert_context *ctx)
378 {
379         struct bio_vec *bv_in = bio_iovec_idx(ctx->bio_in, ctx->idx_in);
380         struct bio_vec *bv_out = bio_iovec_idx(ctx->bio_out, ctx->idx_out);
381         struct dm_crypt_request dmreq;
382
383         sg_init_table(&dmreq.sg_in, 1);
384         sg_set_page(&dmreq.sg_in, bv_in->bv_page, 1 << SECTOR_SHIFT,
385                     bv_in->bv_offset + ctx->offset_in);
386
387         sg_init_table(&dmreq.sg_out, 1);
388         sg_set_page(&dmreq.sg_out, bv_out->bv_page, 1 << SECTOR_SHIFT,
389                     bv_out->bv_offset + ctx->offset_out);
390
391         ctx->offset_in += 1 << SECTOR_SHIFT;
392         if (ctx->offset_in >= bv_in->bv_len) {
393                 ctx->offset_in = 0;
394                 ctx->idx_in++;
395         }
396
397         ctx->offset_out += 1 << SECTOR_SHIFT;
398         if (ctx->offset_out >= bv_out->bv_len) {
399                 ctx->offset_out = 0;
400                 ctx->idx_out++;
401         }
402
403         return crypt_convert_scatterlist(cc, &dmreq.sg_out, &dmreq.sg_in,
404                                          dmreq.sg_in.length,
405                                          bio_data_dir(ctx->bio_in) == WRITE,
406                                          ctx->sector);
407 }
408
409 static void crypt_alloc_req(struct crypt_config *cc,
410                             struct convert_context *ctx)
411 {
412         if (!cc->req)
413                 cc->req = mempool_alloc(cc->req_pool, GFP_NOIO);
414 }
415
416 /*
417  * Encrypt / decrypt data from one bio to another one (can be the same one)
418  */
419 static int crypt_convert(struct crypt_config *cc,
420                          struct convert_context *ctx)
421 {
422         int r = 0;
423
424         while(ctx->idx_in < ctx->bio_in->bi_vcnt &&
425               ctx->idx_out < ctx->bio_out->bi_vcnt) {
426                 r = crypt_convert_block(cc, ctx);
427                 if (r < 0)
428                         break;
429
430                 ctx->sector++;
431         }
432
433         /*
434          * If there are pending crypto operation run async
435          * code. Otherwise process return code synchronously.
436          * The step of 2 ensures that async finish doesn't
437          * call crypto finish too early.
438          */
439         if (atomic_sub_return(2, &ctx->pending))
440                 return -EINPROGRESS;
441
442         return r;
443 }
444
445 static void dm_crypt_bio_destructor(struct bio *bio)
446 {
447         struct dm_crypt_io *io = bio->bi_private;
448         struct crypt_config *cc = io->target->private;
449
450         bio_free(bio, cc->bs);
451 }
452
453 /*
454  * Generate a new unfragmented bio with the given size
455  * This should never violate the device limitations
456  * May return a smaller bio when running out of pages
457  */
458 static struct bio *crypt_alloc_buffer(struct dm_crypt_io *io, unsigned size)
459 {
460         struct crypt_config *cc = io->target->private;
461         struct bio *clone;
462         unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
463         gfp_t gfp_mask = GFP_NOIO | __GFP_HIGHMEM;
464         unsigned i, len;
465         struct page *page;
466
467         clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
468         if (!clone)
469                 return NULL;
470
471         clone_init(io, clone);
472
473         for (i = 0; i < nr_iovecs; i++) {
474                 page = mempool_alloc(cc->page_pool, gfp_mask);
475                 if (!page)
476                         break;
477
478                 /*
479                  * if additional pages cannot be allocated without waiting,
480                  * return a partially allocated bio, the caller will then try
481                  * to allocate additional bios while submitting this partial bio
482                  */
483                 if (i == (MIN_BIO_PAGES - 1))
484                         gfp_mask = (gfp_mask | __GFP_NOWARN) & ~__GFP_WAIT;
485
486                 len = (size > PAGE_SIZE) ? PAGE_SIZE : size;
487
488                 if (!bio_add_page(clone, page, len, 0)) {
489                         mempool_free(page, cc->page_pool);
490                         break;
491                 }
492
493                 size -= len;
494         }
495
496         if (!clone->bi_size) {
497                 bio_put(clone);
498                 return NULL;
499         }
500
501         return clone;
502 }
503
504 static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone)
505 {
506         unsigned int i;
507         struct bio_vec *bv;
508
509         for (i = 0; i < clone->bi_vcnt; i++) {
510                 bv = bio_iovec_idx(clone, i);
511                 BUG_ON(!bv->bv_page);
512                 mempool_free(bv->bv_page, cc->page_pool);
513                 bv->bv_page = NULL;
514         }
515 }
516
517 /*
518  * One of the bios was finished. Check for completion of
519  * the whole request and correctly clean up the buffer.
520  */
521 static void crypt_dec_pending(struct dm_crypt_io *io)
522 {
523         struct crypt_config *cc = io->target->private;
524
525         if (!atomic_dec_and_test(&io->pending))
526                 return;
527
528         bio_endio(io->base_bio, io->error);
529         mempool_free(io, cc->io_pool);
530 }
531
532 /*
533  * kcryptd/kcryptd_io:
534  *
535  * Needed because it would be very unwise to do decryption in an
536  * interrupt context.
537  *
538  * kcryptd performs the actual encryption or decryption.
539  *
540  * kcryptd_io performs the IO submission.
541  *
542  * They must be separated as otherwise the final stages could be
543  * starved by new requests which can block in the first stages due
544  * to memory allocation.
545  */
546 static void crypt_endio(struct bio *clone, int error)
547 {
548         struct dm_crypt_io *io = clone->bi_private;
549         struct crypt_config *cc = io->target->private;
550         unsigned rw = bio_data_dir(clone);
551
552         if (unlikely(!bio_flagged(clone, BIO_UPTODATE) && !error))
553                 error = -EIO;
554
555         /*
556          * free the processed pages
557          */
558         if (rw == WRITE)
559                 crypt_free_buffer_pages(cc, clone);
560
561         bio_put(clone);
562
563         if (rw == READ && !error) {
564                 kcryptd_queue_crypt(io);
565                 return;
566         }
567
568         if (unlikely(error))
569                 io->error = error;
570
571         crypt_dec_pending(io);
572 }
573
574 static void clone_init(struct dm_crypt_io *io, struct bio *clone)
575 {
576         struct crypt_config *cc = io->target->private;
577
578         clone->bi_private = io;
579         clone->bi_end_io  = crypt_endio;
580         clone->bi_bdev    = cc->dev->bdev;
581         clone->bi_rw      = io->base_bio->bi_rw;
582         clone->bi_destructor = dm_crypt_bio_destructor;
583 }
584
585 static void kcryptd_io_read(struct dm_crypt_io *io)
586 {
587         struct crypt_config *cc = io->target->private;
588         struct bio *base_bio = io->base_bio;
589         struct bio *clone;
590
591         atomic_inc(&io->pending);
592
593         /*
594          * The block layer might modify the bvec array, so always
595          * copy the required bvecs because we need the original
596          * one in order to decrypt the whole bio data *afterwards*.
597          */
598         clone = bio_alloc_bioset(GFP_NOIO, bio_segments(base_bio), cc->bs);
599         if (unlikely(!clone)) {
600                 io->error = -ENOMEM;
601                 crypt_dec_pending(io);
602                 return;
603         }
604
605         clone_init(io, clone);
606         clone->bi_idx = 0;
607         clone->bi_vcnt = bio_segments(base_bio);
608         clone->bi_size = base_bio->bi_size;
609         clone->bi_sector = cc->start + io->sector;
610         memcpy(clone->bi_io_vec, bio_iovec(base_bio),
611                sizeof(struct bio_vec) * clone->bi_vcnt);
612
613         generic_make_request(clone);
614 }
615
616 static void kcryptd_io_write(struct dm_crypt_io *io)
617 {
618 }
619
620 static void kcryptd_io(struct work_struct *work)
621 {
622         struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
623
624         if (bio_data_dir(io->base_bio) == READ)
625                 kcryptd_io_read(io);
626         else
627                 kcryptd_io_write(io);
628 }
629
630 static void kcryptd_queue_io(struct dm_crypt_io *io)
631 {
632         struct crypt_config *cc = io->target->private;
633
634         INIT_WORK(&io->work, kcryptd_io);
635         queue_work(cc->io_queue, &io->work);
636 }
637
638 static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int error)
639 {
640         struct bio *clone = io->ctx.bio_out;
641         struct crypt_config *cc = io->target->private;
642
643         if (unlikely(error < 0)) {
644                 crypt_free_buffer_pages(cc, clone);
645                 bio_put(clone);
646                 io->error = -EIO;
647                 return;
648         }
649
650         /* crypt_convert should have filled the clone bio */
651         BUG_ON(io->ctx.idx_out < clone->bi_vcnt);
652
653         clone->bi_sector = cc->start + io->sector;
654         io->sector += bio_sectors(clone);
655
656         atomic_inc(&io->pending);
657         generic_make_request(clone);
658 }
659
660 static void kcryptd_crypt_write_convert_loop(struct dm_crypt_io *io)
661 {
662         struct crypt_config *cc = io->target->private;
663         struct bio *clone;
664         unsigned remaining = io->base_bio->bi_size;
665         int r;
666
667         /*
668          * The allocated buffers can be smaller than the whole bio,
669          * so repeat the whole process until all the data can be handled.
670          */
671         while (remaining) {
672                 clone = crypt_alloc_buffer(io, remaining);
673                 if (unlikely(!clone)) {
674                         io->error = -ENOMEM;
675                         return;
676                 }
677
678                 io->ctx.bio_out = clone;
679                 io->ctx.idx_out = 0;
680
681                 remaining -= clone->bi_size;
682
683                 r = crypt_convert(cc, &io->ctx);
684
685                 kcryptd_crypt_write_io_submit(io, r);
686                 if (unlikely(r < 0))
687                         return;
688
689                 /* out of memory -> run queues */
690                 if (unlikely(remaining))
691                         congestion_wait(WRITE, HZ/100);
692         }
693 }
694
695 static void kcryptd_crypt_write_convert(struct dm_crypt_io *io)
696 {
697         struct crypt_config *cc = io->target->private;
698
699         /*
700          * Prevent io from disappearing until this function completes.
701          */
702         atomic_inc(&io->pending);
703
704         crypt_convert_init(cc, &io->ctx, NULL, io->base_bio, io->sector);
705         kcryptd_crypt_write_convert_loop(io);
706
707         crypt_dec_pending(io);
708 }
709
710 static void kcryptd_crypt_read_done(struct dm_crypt_io *io, int error)
711 {
712         if (unlikely(error < 0))
713                 io->error = -EIO;
714
715         crypt_dec_pending(io);
716 }
717
718 static void kcryptd_crypt_read_convert(struct dm_crypt_io *io)
719 {
720         struct crypt_config *cc = io->target->private;
721         int r = 0;
722
723         crypt_convert_init(cc, &io->ctx, io->base_bio, io->base_bio,
724                            io->sector);
725
726         r = crypt_convert(cc, &io->ctx);
727
728         kcryptd_crypt_read_done(io, r);
729 }
730
731 static void kcryptd_crypt(struct work_struct *work)
732 {
733         struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
734
735         if (bio_data_dir(io->base_bio) == READ)
736                 kcryptd_crypt_read_convert(io);
737         else
738                 kcryptd_crypt_write_convert(io);
739 }
740
741 static void kcryptd_queue_crypt(struct dm_crypt_io *io)
742 {
743         struct crypt_config *cc = io->target->private;
744
745         INIT_WORK(&io->work, kcryptd_crypt);
746         queue_work(cc->crypt_queue, &io->work);
747 }
748
749 /*
750  * Decode key from its hex representation
751  */
752 static int crypt_decode_key(u8 *key, char *hex, unsigned int size)
753 {
754         char buffer[3];
755         char *endp;
756         unsigned int i;
757
758         buffer[2] = '\0';
759
760         for (i = 0; i < size; i++) {
761                 buffer[0] = *hex++;
762                 buffer[1] = *hex++;
763
764                 key[i] = (u8)simple_strtoul(buffer, &endp, 16);
765
766                 if (endp != &buffer[2])
767                         return -EINVAL;
768         }
769
770         if (*hex != '\0')
771                 return -EINVAL;
772
773         return 0;
774 }
775
776 /*
777  * Encode key into its hex representation
778  */
779 static void crypt_encode_key(char *hex, u8 *key, unsigned int size)
780 {
781         unsigned int i;
782
783         for (i = 0; i < size; i++) {
784                 sprintf(hex, "%02x", *key);
785                 hex += 2;
786                 key++;
787         }
788 }
789
790 static int crypt_set_key(struct crypt_config *cc, char *key)
791 {
792         unsigned key_size = strlen(key) >> 1;
793
794         if (cc->key_size && cc->key_size != key_size)
795                 return -EINVAL;
796
797         cc->key_size = key_size; /* initial settings */
798
799         if ((!key_size && strcmp(key, "-")) ||
800            (key_size && crypt_decode_key(cc->key, key, key_size) < 0))
801                 return -EINVAL;
802
803         set_bit(DM_CRYPT_KEY_VALID, &cc->flags);
804
805         return 0;
806 }
807
808 static int crypt_wipe_key(struct crypt_config *cc)
809 {
810         clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
811         memset(&cc->key, 0, cc->key_size * sizeof(u8));
812         return 0;
813 }
814
815 /*
816  * Construct an encryption mapping:
817  * <cipher> <key> <iv_offset> <dev_path> <start>
818  */
819 static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
820 {
821         struct crypt_config *cc;
822         struct crypto_blkcipher *tfm;
823         char *tmp;
824         char *cipher;
825         char *chainmode;
826         char *ivmode;
827         char *ivopts;
828         unsigned int key_size;
829         unsigned long long tmpll;
830
831         if (argc != 5) {
832                 ti->error = "Not enough arguments";
833                 return -EINVAL;
834         }
835
836         tmp = argv[0];
837         cipher = strsep(&tmp, "-");
838         chainmode = strsep(&tmp, "-");
839         ivopts = strsep(&tmp, "-");
840         ivmode = strsep(&ivopts, ":");
841
842         if (tmp)
843                 DMWARN("Unexpected additional cipher options");
844
845         key_size = strlen(argv[1]) >> 1;
846
847         cc = kzalloc(sizeof(*cc) + key_size * sizeof(u8), GFP_KERNEL);
848         if (cc == NULL) {
849                 ti->error =
850                         "Cannot allocate transparent encryption context";
851                 return -ENOMEM;
852         }
853
854         if (crypt_set_key(cc, argv[1])) {
855                 ti->error = "Error decoding key";
856                 goto bad_cipher;
857         }
858
859         /* Compatiblity mode for old dm-crypt cipher strings */
860         if (!chainmode || (strcmp(chainmode, "plain") == 0 && !ivmode)) {
861                 chainmode = "cbc";
862                 ivmode = "plain";
863         }
864
865         if (strcmp(chainmode, "ecb") && !ivmode) {
866                 ti->error = "This chaining mode requires an IV mechanism";
867                 goto bad_cipher;
868         }
869
870         if (snprintf(cc->cipher, CRYPTO_MAX_ALG_NAME, "%s(%s)",
871                      chainmode, cipher) >= CRYPTO_MAX_ALG_NAME) {
872                 ti->error = "Chain mode + cipher name is too long";
873                 goto bad_cipher;
874         }
875
876         tfm = crypto_alloc_blkcipher(cc->cipher, 0, CRYPTO_ALG_ASYNC);
877         if (IS_ERR(tfm)) {
878                 ti->error = "Error allocating crypto tfm";
879                 goto bad_cipher;
880         }
881
882         strcpy(cc->cipher, cipher);
883         strcpy(cc->chainmode, chainmode);
884         cc->tfm = tfm;
885
886         /*
887          * Choose ivmode. Valid modes: "plain", "essiv:<esshash>", "benbi".
888          * See comments at iv code
889          */
890
891         if (ivmode == NULL)
892                 cc->iv_gen_ops = NULL;
893         else if (strcmp(ivmode, "plain") == 0)
894                 cc->iv_gen_ops = &crypt_iv_plain_ops;
895         else if (strcmp(ivmode, "essiv") == 0)
896                 cc->iv_gen_ops = &crypt_iv_essiv_ops;
897         else if (strcmp(ivmode, "benbi") == 0)
898                 cc->iv_gen_ops = &crypt_iv_benbi_ops;
899         else if (strcmp(ivmode, "null") == 0)
900                 cc->iv_gen_ops = &crypt_iv_null_ops;
901         else {
902                 ti->error = "Invalid IV mode";
903                 goto bad_ivmode;
904         }
905
906         if (cc->iv_gen_ops && cc->iv_gen_ops->ctr &&
907             cc->iv_gen_ops->ctr(cc, ti, ivopts) < 0)
908                 goto bad_ivmode;
909
910         cc->iv_size = crypto_blkcipher_ivsize(tfm);
911         if (cc->iv_size)
912                 /* at least a 64 bit sector number should fit in our buffer */
913                 cc->iv_size = max(cc->iv_size,
914                                   (unsigned int)(sizeof(u64) / sizeof(u8)));
915         else {
916                 if (cc->iv_gen_ops) {
917                         DMWARN("Selected cipher does not support IVs");
918                         if (cc->iv_gen_ops->dtr)
919                                 cc->iv_gen_ops->dtr(cc);
920                         cc->iv_gen_ops = NULL;
921                 }
922         }
923
924         cc->io_pool = mempool_create_slab_pool(MIN_IOS, _crypt_io_pool);
925         if (!cc->io_pool) {
926                 ti->error = "Cannot allocate crypt io mempool";
927                 goto bad_slab_pool;
928         }
929
930         cc->dmreq_start = sizeof(struct ablkcipher_request);
931         cc->dmreq_start = ALIGN(cc->dmreq_start, crypto_tfm_ctx_alignment());
932
933         cc->req_pool = mempool_create_kmalloc_pool(MIN_IOS, cc->dmreq_start +
934                         sizeof(struct dm_crypt_request) + cc->iv_size);
935         if (!cc->req_pool) {
936                 ti->error = "Cannot allocate crypt request mempool";
937                 goto bad_req_pool;
938         }
939         cc->req = NULL;
940
941         cc->page_pool = mempool_create_page_pool(MIN_POOL_PAGES, 0);
942         if (!cc->page_pool) {
943                 ti->error = "Cannot allocate page mempool";
944                 goto bad_page_pool;
945         }
946
947         cc->bs = bioset_create(MIN_IOS, MIN_IOS);
948         if (!cc->bs) {
949                 ti->error = "Cannot allocate crypt bioset";
950                 goto bad_bs;
951         }
952
953         if (crypto_blkcipher_setkey(tfm, cc->key, key_size) < 0) {
954                 ti->error = "Error setting key";
955                 goto bad_device;
956         }
957
958         if (sscanf(argv[2], "%llu", &tmpll) != 1) {
959                 ti->error = "Invalid iv_offset sector";
960                 goto bad_device;
961         }
962         cc->iv_offset = tmpll;
963
964         if (sscanf(argv[4], "%llu", &tmpll) != 1) {
965                 ti->error = "Invalid device sector";
966                 goto bad_device;
967         }
968         cc->start = tmpll;
969
970         if (dm_get_device(ti, argv[3], cc->start, ti->len,
971                           dm_table_get_mode(ti->table), &cc->dev)) {
972                 ti->error = "Device lookup failed";
973                 goto bad_device;
974         }
975
976         if (ivmode && cc->iv_gen_ops) {
977                 if (ivopts)
978                         *(ivopts - 1) = ':';
979                 cc->iv_mode = kmalloc(strlen(ivmode) + 1, GFP_KERNEL);
980                 if (!cc->iv_mode) {
981                         ti->error = "Error kmallocing iv_mode string";
982                         goto bad_ivmode_string;
983                 }
984                 strcpy(cc->iv_mode, ivmode);
985         } else
986                 cc->iv_mode = NULL;
987
988         cc->io_queue = create_singlethread_workqueue("kcryptd_io");
989         if (!cc->io_queue) {
990                 ti->error = "Couldn't create kcryptd io queue";
991                 goto bad_io_queue;
992         }
993
994         cc->crypt_queue = create_singlethread_workqueue("kcryptd");
995         if (!cc->crypt_queue) {
996                 ti->error = "Couldn't create kcryptd queue";
997                 goto bad_crypt_queue;
998         }
999
1000         ti->private = cc;
1001         return 0;
1002
1003 bad_crypt_queue:
1004         destroy_workqueue(cc->io_queue);
1005 bad_io_queue:
1006         kfree(cc->iv_mode);
1007 bad_ivmode_string:
1008         dm_put_device(ti, cc->dev);
1009 bad_device:
1010         bioset_free(cc->bs);
1011 bad_bs:
1012         mempool_destroy(cc->page_pool);
1013 bad_page_pool:
1014         mempool_destroy(cc->req_pool);
1015 bad_req_pool:
1016         mempool_destroy(cc->io_pool);
1017 bad_slab_pool:
1018         if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
1019                 cc->iv_gen_ops->dtr(cc);
1020 bad_ivmode:
1021         crypto_free_blkcipher(tfm);
1022 bad_cipher:
1023         /* Must zero key material before freeing */
1024         memset(cc, 0, sizeof(*cc) + cc->key_size * sizeof(u8));
1025         kfree(cc);
1026         return -EINVAL;
1027 }
1028
1029 static void crypt_dtr(struct dm_target *ti)
1030 {
1031         struct crypt_config *cc = (struct crypt_config *) ti->private;
1032
1033         destroy_workqueue(cc->io_queue);
1034         destroy_workqueue(cc->crypt_queue);
1035
1036         if (cc->req)
1037                 mempool_free(cc->req, cc->req_pool);
1038
1039         bioset_free(cc->bs);
1040         mempool_destroy(cc->page_pool);
1041         mempool_destroy(cc->req_pool);
1042         mempool_destroy(cc->io_pool);
1043
1044         kfree(cc->iv_mode);
1045         if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
1046                 cc->iv_gen_ops->dtr(cc);
1047         crypto_free_blkcipher(cc->tfm);
1048         dm_put_device(ti, cc->dev);
1049
1050         /* Must zero key material before freeing */
1051         memset(cc, 0, sizeof(*cc) + cc->key_size * sizeof(u8));
1052         kfree(cc);
1053 }
1054
1055 static int crypt_map(struct dm_target *ti, struct bio *bio,
1056                      union map_info *map_context)
1057 {
1058         struct crypt_config *cc = ti->private;
1059         struct dm_crypt_io *io;
1060
1061         io = mempool_alloc(cc->io_pool, GFP_NOIO);
1062         io->target = ti;
1063         io->base_bio = bio;
1064         io->sector = bio->bi_sector - ti->begin;
1065         io->error = 0;
1066         atomic_set(&io->pending, 0);
1067
1068         if (bio_data_dir(io->base_bio) == READ)
1069                 kcryptd_queue_io(io);
1070         else
1071                 kcryptd_queue_crypt(io);
1072
1073         return DM_MAPIO_SUBMITTED;
1074 }
1075
1076 static int crypt_status(struct dm_target *ti, status_type_t type,
1077                         char *result, unsigned int maxlen)
1078 {
1079         struct crypt_config *cc = (struct crypt_config *) ti->private;
1080         unsigned int sz = 0;
1081
1082         switch (type) {
1083         case STATUSTYPE_INFO:
1084                 result[0] = '\0';
1085                 break;
1086
1087         case STATUSTYPE_TABLE:
1088                 if (cc->iv_mode)
1089                         DMEMIT("%s-%s-%s ", cc->cipher, cc->chainmode,
1090                                cc->iv_mode);
1091                 else
1092                         DMEMIT("%s-%s ", cc->cipher, cc->chainmode);
1093
1094                 if (cc->key_size > 0) {
1095                         if ((maxlen - sz) < ((cc->key_size << 1) + 1))
1096                                 return -ENOMEM;
1097
1098                         crypt_encode_key(result + sz, cc->key, cc->key_size);
1099                         sz += cc->key_size << 1;
1100                 } else {
1101                         if (sz >= maxlen)
1102                                 return -ENOMEM;
1103                         result[sz++] = '-';
1104                 }
1105
1106                 DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
1107                                 cc->dev->name, (unsigned long long)cc->start);
1108                 break;
1109         }
1110         return 0;
1111 }
1112
1113 static void crypt_postsuspend(struct dm_target *ti)
1114 {
1115         struct crypt_config *cc = ti->private;
1116
1117         set_bit(DM_CRYPT_SUSPENDED, &cc->flags);
1118 }
1119
1120 static int crypt_preresume(struct dm_target *ti)
1121 {
1122         struct crypt_config *cc = ti->private;
1123
1124         if (!test_bit(DM_CRYPT_KEY_VALID, &cc->flags)) {
1125                 DMERR("aborting resume - crypt key is not set.");
1126                 return -EAGAIN;
1127         }
1128
1129         return 0;
1130 }
1131
1132 static void crypt_resume(struct dm_target *ti)
1133 {
1134         struct crypt_config *cc = ti->private;
1135
1136         clear_bit(DM_CRYPT_SUSPENDED, &cc->flags);
1137 }
1138
1139 /* Message interface
1140  *      key set <key>
1141  *      key wipe
1142  */
1143 static int crypt_message(struct dm_target *ti, unsigned argc, char **argv)
1144 {
1145         struct crypt_config *cc = ti->private;
1146
1147         if (argc < 2)
1148                 goto error;
1149
1150         if (!strnicmp(argv[0], MESG_STR("key"))) {
1151                 if (!test_bit(DM_CRYPT_SUSPENDED, &cc->flags)) {
1152                         DMWARN("not suspended during key manipulation.");
1153                         return -EINVAL;
1154                 }
1155                 if (argc == 3 && !strnicmp(argv[1], MESG_STR("set")))
1156                         return crypt_set_key(cc, argv[2]);
1157                 if (argc == 2 && !strnicmp(argv[1], MESG_STR("wipe")))
1158                         return crypt_wipe_key(cc);
1159         }
1160
1161 error:
1162         DMWARN("unrecognised message received.");
1163         return -EINVAL;
1164 }
1165
1166 static struct target_type crypt_target = {
1167         .name   = "crypt",
1168         .version= {1, 5, 0},
1169         .module = THIS_MODULE,
1170         .ctr    = crypt_ctr,
1171         .dtr    = crypt_dtr,
1172         .map    = crypt_map,
1173         .status = crypt_status,
1174         .postsuspend = crypt_postsuspend,
1175         .preresume = crypt_preresume,
1176         .resume = crypt_resume,
1177         .message = crypt_message,
1178 };
1179
1180 static int __init dm_crypt_init(void)
1181 {
1182         int r;
1183
1184         _crypt_io_pool = KMEM_CACHE(dm_crypt_io, 0);
1185         if (!_crypt_io_pool)
1186                 return -ENOMEM;
1187
1188         r = dm_register_target(&crypt_target);
1189         if (r < 0) {
1190                 DMERR("register failed %d", r);
1191                 kmem_cache_destroy(_crypt_io_pool);
1192         }
1193
1194         return r;
1195 }
1196
1197 static void __exit dm_crypt_exit(void)
1198 {
1199         int r = dm_unregister_target(&crypt_target);
1200
1201         if (r < 0)
1202                 DMERR("unregister failed %d", r);
1203
1204         kmem_cache_destroy(_crypt_io_pool);
1205 }
1206
1207 module_init(dm_crypt_init);
1208 module_exit(dm_crypt_exit);
1209
1210 MODULE_AUTHOR("Christophe Saout <christophe@saout.de>");
1211 MODULE_DESCRIPTION(DM_NAME " target for transparent encryption / decryption");
1212 MODULE_LICENSE("GPL");