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