blob: a625576fdeeb3eb5c5ac1c7ebc15f3aea841df39 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2003 Christophe Saout <christophe@saout.de>
3 * Copyright (C) 2004 Clemens Fruhwirth <clemens@endorphin.org>
Milan Broze48d4bb2006-10-03 01:15:37 -07004 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * This file is released under the GPL.
7 */
8
Herbert Xud1806f62006-08-22 20:29:17 +10009#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#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>
Andrew Morton3fcfab12006-10-19 23:28:16 -070019#include <linux/backing-dev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <asm/atomic.h>
David Hardeman378f0582005-09-17 17:55:31 +100021#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <asm/page.h>
23
24#include "dm.h"
25
Alasdair G Kergon72d94862006-06-26 00:27:35 -070026#define DM_MSG_PREFIX "crypt"
Milan Broze48d4bb2006-10-03 01:15:37 -070027#define MESG_STR(x) x, sizeof(x)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29/*
30 * per bio private data
31 */
32struct crypt_io {
33 struct dm_target *target;
Milan Broz8b004452006-10-03 01:15:37 -070034 struct bio *base_bio;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 struct bio *first_clone;
36 struct work_struct work;
37 atomic_t pending;
38 int error;
Milan Broz23541d22006-10-03 01:15:39 -070039 int post_process;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040};
41
42/*
43 * context holding the current state of a multi-part conversion
44 */
45struct convert_context {
46 struct bio *bio_in;
47 struct bio *bio_out;
48 unsigned int offset_in;
49 unsigned int offset_out;
50 unsigned int idx_in;
51 unsigned int idx_out;
52 sector_t sector;
53 int write;
54};
55
56struct crypt_config;
57
58struct crypt_iv_operations {
59 int (*ctr)(struct crypt_config *cc, struct dm_target *ti,
60 const char *opts);
61 void (*dtr)(struct crypt_config *cc);
62 const char *(*status)(struct crypt_config *cc);
63 int (*generator)(struct crypt_config *cc, u8 *iv, sector_t sector);
64};
65
66/*
67 * Crypt: maps a linear range of a block device
68 * and encrypts / decrypts at the same time.
69 */
Milan Broze48d4bb2006-10-03 01:15:37 -070070enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID };
Linus Torvalds1da177e2005-04-16 15:20:36 -070071struct crypt_config {
72 struct dm_dev *dev;
73 sector_t start;
74
75 /*
76 * pool for per bio private data and
77 * for encryption buffer pages
78 */
79 mempool_t *io_pool;
80 mempool_t *page_pool;
Milan Broz6a24c712006-10-03 01:15:40 -070081 struct bio_set *bs;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83 /*
84 * crypto related data
85 */
86 struct crypt_iv_operations *iv_gen_ops;
87 char *iv_mode;
Herbert Xud1806f62006-08-22 20:29:17 +100088 struct crypto_cipher *iv_gen_private;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 sector_t iv_offset;
90 unsigned int iv_size;
91
Herbert Xud1806f62006-08-22 20:29:17 +100092 char cipher[CRYPTO_MAX_ALG_NAME];
93 char chainmode[CRYPTO_MAX_ALG_NAME];
94 struct crypto_blkcipher *tfm;
Milan Broze48d4bb2006-10-03 01:15:37 -070095 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 unsigned int key_size;
97 u8 key[0];
98};
99
Milan Broz6a24c712006-10-03 01:15:40 -0700100#define MIN_IOS 16
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101#define MIN_POOL_PAGES 32
102#define MIN_BIO_PAGES 8
103
104static kmem_cache_t *_crypt_io_pool;
105
106/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 * Different IV generation algorithms:
108 *
Rik Snel3c164bd2006-09-02 18:17:33 +1000109 * plain: the initial vector is the 32-bit little-endian version of the sector
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 * number, padded with zeros if neccessary.
111 *
Rik Snel3c164bd2006-09-02 18:17:33 +1000112 * essiv: "encrypted sector|salt initial vector", the sector number is
113 * encrypted with the bulk cipher using a salt as key. The salt
114 * should be derived from the bulk cipher's key via hashing.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 *
116 * plumb: unimplemented, see:
117 * http://article.gmane.org/gmane.linux.kernel.device-mapper.dm-crypt/454
118 */
119
120static int crypt_iv_plain_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
121{
122 memset(iv, 0, cc->iv_size);
123 *(u32 *)iv = cpu_to_le32(sector & 0xffffffff);
124
125 return 0;
126}
127
128static int crypt_iv_essiv_ctr(struct crypt_config *cc, struct dm_target *ti,
129 const char *opts)
130{
Herbert Xud1806f62006-08-22 20:29:17 +1000131 struct crypto_cipher *essiv_tfm;
Herbert Xu35058682006-08-24 19:10:20 +1000132 struct crypto_hash *hash_tfm;
133 struct hash_desc desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 struct scatterlist sg;
135 unsigned int saltsize;
136 u8 *salt;
Herbert Xud1806f62006-08-22 20:29:17 +1000137 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 if (opts == NULL) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700140 ti->error = "Digest algorithm missing for ESSIV mode";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 return -EINVAL;
142 }
143
144 /* Hash the cipher key with the given hash algorithm */
Herbert Xu35058682006-08-24 19:10:20 +1000145 hash_tfm = crypto_alloc_hash(opts, 0, CRYPTO_ALG_ASYNC);
146 if (IS_ERR(hash_tfm)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700147 ti->error = "Error initializing ESSIV hash";
Herbert Xu35058682006-08-24 19:10:20 +1000148 return PTR_ERR(hash_tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
150
Herbert Xu35058682006-08-24 19:10:20 +1000151 saltsize = crypto_hash_digestsize(hash_tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 salt = kmalloc(saltsize, GFP_KERNEL);
153 if (salt == NULL) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700154 ti->error = "Error kmallocing salt storage in ESSIV";
Herbert Xu35058682006-08-24 19:10:20 +1000155 crypto_free_hash(hash_tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 return -ENOMEM;
157 }
158
David Hardeman378f0582005-09-17 17:55:31 +1000159 sg_set_buf(&sg, cc->key, cc->key_size);
Herbert Xu35058682006-08-24 19:10:20 +1000160 desc.tfm = hash_tfm;
161 desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
162 err = crypto_hash_digest(&desc, &sg, cc->key_size, salt);
163 crypto_free_hash(hash_tfm);
164
165 if (err) {
166 ti->error = "Error calculating hash in ESSIV";
167 return err;
168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 /* Setup the essiv_tfm with the given salt */
Herbert Xud1806f62006-08-22 20:29:17 +1000171 essiv_tfm = crypto_alloc_cipher(cc->cipher, 0, CRYPTO_ALG_ASYNC);
172 if (IS_ERR(essiv_tfm)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700173 ti->error = "Error allocating crypto tfm for ESSIV";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 kfree(salt);
Herbert Xud1806f62006-08-22 20:29:17 +1000175 return PTR_ERR(essiv_tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 }
Herbert Xud1806f62006-08-22 20:29:17 +1000177 if (crypto_cipher_blocksize(essiv_tfm) !=
178 crypto_blkcipher_ivsize(cc->tfm)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700179 ti->error = "Block size of ESSIV cipher does "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 "not match IV size of block cipher";
Herbert Xud1806f62006-08-22 20:29:17 +1000181 crypto_free_cipher(essiv_tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 kfree(salt);
183 return -EINVAL;
184 }
Herbert Xud1806f62006-08-22 20:29:17 +1000185 err = crypto_cipher_setkey(essiv_tfm, salt, saltsize);
186 if (err) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700187 ti->error = "Failed to set key for ESSIV cipher";
Herbert Xud1806f62006-08-22 20:29:17 +1000188 crypto_free_cipher(essiv_tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 kfree(salt);
Herbert Xud1806f62006-08-22 20:29:17 +1000190 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 }
192 kfree(salt);
193
Herbert Xud1806f62006-08-22 20:29:17 +1000194 cc->iv_gen_private = essiv_tfm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 return 0;
196}
197
198static void crypt_iv_essiv_dtr(struct crypt_config *cc)
199{
Herbert Xud1806f62006-08-22 20:29:17 +1000200 crypto_free_cipher(cc->iv_gen_private);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 cc->iv_gen_private = NULL;
202}
203
204static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
205{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 memset(iv, 0, cc->iv_size);
207 *(u64 *)iv = cpu_to_le64(sector);
Herbert Xud1806f62006-08-22 20:29:17 +1000208 crypto_cipher_encrypt_one(cc->iv_gen_private, iv, iv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 return 0;
210}
211
212static struct crypt_iv_operations crypt_iv_plain_ops = {
213 .generator = crypt_iv_plain_gen
214};
215
216static struct crypt_iv_operations crypt_iv_essiv_ops = {
217 .ctr = crypt_iv_essiv_ctr,
218 .dtr = crypt_iv_essiv_dtr,
219 .generator = crypt_iv_essiv_gen
220};
221
222
Arjan van de Ven858119e2006-01-14 13:20:43 -0800223static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224crypt_convert_scatterlist(struct crypt_config *cc, struct scatterlist *out,
225 struct scatterlist *in, unsigned int length,
226 int write, sector_t sector)
227{
228 u8 iv[cc->iv_size];
Herbert Xud1806f62006-08-22 20:29:17 +1000229 struct blkcipher_desc desc = {
230 .tfm = cc->tfm,
231 .info = iv,
232 .flags = CRYPTO_TFM_REQ_MAY_SLEEP,
233 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 int r;
235
236 if (cc->iv_gen_ops) {
237 r = cc->iv_gen_ops->generator(cc, iv, sector);
238 if (r < 0)
239 return r;
240
241 if (write)
Herbert Xud1806f62006-08-22 20:29:17 +1000242 r = crypto_blkcipher_encrypt_iv(&desc, out, in, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 else
Herbert Xud1806f62006-08-22 20:29:17 +1000244 r = crypto_blkcipher_decrypt_iv(&desc, out, in, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 } else {
246 if (write)
Herbert Xud1806f62006-08-22 20:29:17 +1000247 r = crypto_blkcipher_encrypt(&desc, out, in, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 else
Herbert Xud1806f62006-08-22 20:29:17 +1000249 r = crypto_blkcipher_decrypt(&desc, out, in, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 }
251
252 return r;
253}
254
255static void
256crypt_convert_init(struct crypt_config *cc, struct convert_context *ctx,
257 struct bio *bio_out, struct bio *bio_in,
258 sector_t sector, int write)
259{
260 ctx->bio_in = bio_in;
261 ctx->bio_out = bio_out;
262 ctx->offset_in = 0;
263 ctx->offset_out = 0;
264 ctx->idx_in = bio_in ? bio_in->bi_idx : 0;
265 ctx->idx_out = bio_out ? bio_out->bi_idx : 0;
266 ctx->sector = sector + cc->iv_offset;
267 ctx->write = write;
268}
269
270/*
271 * Encrypt / decrypt data from one bio to another one (can be the same one)
272 */
273static int crypt_convert(struct crypt_config *cc,
274 struct convert_context *ctx)
275{
276 int r = 0;
277
278 while(ctx->idx_in < ctx->bio_in->bi_vcnt &&
279 ctx->idx_out < ctx->bio_out->bi_vcnt) {
280 struct bio_vec *bv_in = bio_iovec_idx(ctx->bio_in, ctx->idx_in);
281 struct bio_vec *bv_out = bio_iovec_idx(ctx->bio_out, ctx->idx_out);
282 struct scatterlist sg_in = {
283 .page = bv_in->bv_page,
284 .offset = bv_in->bv_offset + ctx->offset_in,
285 .length = 1 << SECTOR_SHIFT
286 };
287 struct scatterlist sg_out = {
288 .page = bv_out->bv_page,
289 .offset = bv_out->bv_offset + ctx->offset_out,
290 .length = 1 << SECTOR_SHIFT
291 };
292
293 ctx->offset_in += sg_in.length;
294 if (ctx->offset_in >= bv_in->bv_len) {
295 ctx->offset_in = 0;
296 ctx->idx_in++;
297 }
298
299 ctx->offset_out += sg_out.length;
300 if (ctx->offset_out >= bv_out->bv_len) {
301 ctx->offset_out = 0;
302 ctx->idx_out++;
303 }
304
305 r = crypt_convert_scatterlist(cc, &sg_out, &sg_in, sg_in.length,
306 ctx->write, ctx->sector);
307 if (r < 0)
308 break;
309
310 ctx->sector++;
311 }
312
313 return r;
314}
315
Milan Broz6a24c712006-10-03 01:15:40 -0700316 static void dm_crypt_bio_destructor(struct bio *bio)
317 {
318 struct crypt_io *io = bio->bi_private;
319 struct crypt_config *cc = io->target->private;
320
321 bio_free(bio, cc->bs);
322 }
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324/*
325 * Generate a new unfragmented bio with the given size
326 * This should never violate the device limitations
327 * May return a smaller bio when running out of pages
328 */
329static struct bio *
330crypt_alloc_buffer(struct crypt_config *cc, unsigned int size,
331 struct bio *base_bio, unsigned int *bio_vec_idx)
332{
Milan Broz8b004452006-10-03 01:15:37 -0700333 struct bio *clone;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
Al Virob4e3ca12005-10-21 03:22:34 -0400335 gfp_t gfp_mask = GFP_NOIO | __GFP_HIGHMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 unsigned int i;
337
Milan Broz6a24c712006-10-03 01:15:40 -0700338 if (base_bio) {
339 clone = bio_alloc_bioset(GFP_NOIO, base_bio->bi_max_vecs, cc->bs);
340 __bio_clone(clone, base_bio);
341 } else
342 clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
343
Milan Broz8b004452006-10-03 01:15:37 -0700344 if (!clone)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Milan Broz6a24c712006-10-03 01:15:40 -0700347 clone->bi_destructor = dm_crypt_bio_destructor;
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 /* if the last bio was not complete, continue where that one ended */
Milan Broz8b004452006-10-03 01:15:37 -0700350 clone->bi_idx = *bio_vec_idx;
351 clone->bi_vcnt = *bio_vec_idx;
352 clone->bi_size = 0;
353 clone->bi_flags &= ~(1 << BIO_SEG_VALID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
Milan Broz8b004452006-10-03 01:15:37 -0700355 /* clone->bi_idx pages have already been allocated */
356 size -= clone->bi_idx * PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Milan Broz8b004452006-10-03 01:15:37 -0700358 for (i = clone->bi_idx; i < nr_iovecs; i++) {
359 struct bio_vec *bv = bio_iovec_idx(clone, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361 bv->bv_page = mempool_alloc(cc->page_pool, gfp_mask);
362 if (!bv->bv_page)
363 break;
364
365 /*
366 * if additional pages cannot be allocated without waiting,
367 * return a partially allocated bio, the caller will then try
368 * to allocate additional bios while submitting this partial bio
369 */
Milan Broz8b004452006-10-03 01:15:37 -0700370 if ((i - clone->bi_idx) == (MIN_BIO_PAGES - 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 gfp_mask = (gfp_mask | __GFP_NOWARN) & ~__GFP_WAIT;
372
373 bv->bv_offset = 0;
374 if (size > PAGE_SIZE)
375 bv->bv_len = PAGE_SIZE;
376 else
377 bv->bv_len = size;
378
Milan Broz8b004452006-10-03 01:15:37 -0700379 clone->bi_size += bv->bv_len;
380 clone->bi_vcnt++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 size -= bv->bv_len;
382 }
383
Milan Broz8b004452006-10-03 01:15:37 -0700384 if (!clone->bi_size) {
385 bio_put(clone);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 return NULL;
387 }
388
389 /*
390 * Remember the last bio_vec allocated to be able
391 * to correctly continue after the splitting.
392 */
Milan Broz8b004452006-10-03 01:15:37 -0700393 *bio_vec_idx = clone->bi_vcnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
Milan Broz8b004452006-10-03 01:15:37 -0700395 return clone;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396}
397
398static void crypt_free_buffer_pages(struct crypt_config *cc,
Milan Broz8b004452006-10-03 01:15:37 -0700399 struct bio *clone, unsigned int bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
401 unsigned int i, start, end;
402 struct bio_vec *bv;
403
404 /*
405 * This is ugly, but Jens Axboe thinks that using bi_idx in the
406 * endio function is too dangerous at the moment, so I calculate the
407 * correct position using bi_vcnt and bi_size.
408 * The bv_offset and bv_len fields might already be modified but we
409 * know that we always allocated whole pages.
410 * A fix to the bi_idx issue in the kernel is in the works, so
411 * we will hopefully be able to revert to the cleaner solution soon.
412 */
Milan Broz8b004452006-10-03 01:15:37 -0700413 i = clone->bi_vcnt - 1;
414 bv = bio_iovec_idx(clone, i);
415 end = (i << PAGE_SHIFT) + (bv->bv_offset + bv->bv_len) - clone->bi_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 start = end - bytes;
417
418 start >>= PAGE_SHIFT;
Milan Broz8b004452006-10-03 01:15:37 -0700419 if (!clone->bi_size)
420 end = clone->bi_vcnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 else
422 end >>= PAGE_SHIFT;
423
Milan Broz8b004452006-10-03 01:15:37 -0700424 for (i = start; i < end; i++) {
425 bv = bio_iovec_idx(clone, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 BUG_ON(!bv->bv_page);
427 mempool_free(bv->bv_page, cc->page_pool);
428 bv->bv_page = NULL;
429 }
430}
431
432/*
433 * One of the bios was finished. Check for completion of
434 * the whole request and correctly clean up the buffer.
435 */
436static void dec_pending(struct crypt_io *io, int error)
437{
438 struct crypt_config *cc = (struct crypt_config *) io->target->private;
439
440 if (error < 0)
441 io->error = error;
442
443 if (!atomic_dec_and_test(&io->pending))
444 return;
445
446 if (io->first_clone)
447 bio_put(io->first_clone);
448
Milan Broz8b004452006-10-03 01:15:37 -0700449 bio_endio(io->base_bio, io->base_bio->bi_size, io->error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451 mempool_free(io, cc->io_pool);
452}
453
454/*
455 * kcryptd:
456 *
457 * Needed because it would be very unwise to do decryption in an
Milan Broz23541d22006-10-03 01:15:39 -0700458 * interrupt context.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 */
460static struct workqueue_struct *_kcryptd_workqueue;
Milan Broz8b004452006-10-03 01:15:37 -0700461static void kcryptd_do_work(void *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
463static void kcryptd_queue_io(struct crypt_io *io)
464{
465 INIT_WORK(&io->work, kcryptd_do_work, io);
466 queue_work(_kcryptd_workqueue, &io->work);
467}
468
Milan Broz8b004452006-10-03 01:15:37 -0700469static int crypt_endio(struct bio *clone, unsigned int done, int error)
470{
471 struct crypt_io *io = clone->bi_private;
472 struct crypt_config *cc = io->target->private;
473 unsigned read_io = bio_data_dir(clone) == READ;
474
475 /*
476 * free the processed pages, even if
477 * it's only a partially completed write
478 */
479 if (!read_io)
480 crypt_free_buffer_pages(cc, clone, done);
481
Milan Broz23541d22006-10-03 01:15:39 -0700482 /* keep going - not finished yet */
Milan Broz8b004452006-10-03 01:15:37 -0700483 if (unlikely(clone->bi_size))
484 return 1;
485
Milan Broz8b004452006-10-03 01:15:37 -0700486 if (!read_io)
487 goto out;
488
489 if (unlikely(!bio_flagged(clone, BIO_UPTODATE))) {
490 error = -EIO;
491 goto out;
492 }
493
494 bio_put(clone);
Milan Broz23541d22006-10-03 01:15:39 -0700495 io->post_process = 1;
Milan Broz8b004452006-10-03 01:15:37 -0700496 kcryptd_queue_io(io);
497 return 0;
498
499out:
500 bio_put(clone);
501 dec_pending(io, error);
502 return error;
503}
504
505static void clone_init(struct crypt_io *io, struct bio *clone)
506{
507 struct crypt_config *cc = io->target->private;
508
509 clone->bi_private = io;
510 clone->bi_end_io = crypt_endio;
511 clone->bi_bdev = cc->dev->bdev;
512 clone->bi_rw = io->base_bio->bi_rw;
513}
514
Milan Broz23541d22006-10-03 01:15:39 -0700515static void process_read(struct crypt_io *io)
Milan Broz8b004452006-10-03 01:15:37 -0700516{
517 struct crypt_config *cc = io->target->private;
518 struct bio *base_bio = io->base_bio;
519 struct bio *clone;
Milan Broz93e605c2006-10-03 01:15:38 -0700520 sector_t sector = base_bio->bi_sector - io->target->begin;
521
522 atomic_inc(&io->pending);
Milan Broz8b004452006-10-03 01:15:37 -0700523
524 /*
525 * The block layer might modify the bvec array, so always
526 * copy the required bvecs because we need the original
527 * one in order to decrypt the whole bio data *afterwards*.
528 */
Milan Broz6a24c712006-10-03 01:15:40 -0700529 clone = bio_alloc_bioset(GFP_NOIO, bio_segments(base_bio), cc->bs);
Milan Broz93e605c2006-10-03 01:15:38 -0700530 if (unlikely(!clone)) {
531 dec_pending(io, -ENOMEM);
Milan Broz23541d22006-10-03 01:15:39 -0700532 return;
Milan Broz93e605c2006-10-03 01:15:38 -0700533 }
Milan Broz8b004452006-10-03 01:15:37 -0700534
535 clone_init(io, clone);
Milan Broz6a24c712006-10-03 01:15:40 -0700536 clone->bi_destructor = dm_crypt_bio_destructor;
Milan Broz8b004452006-10-03 01:15:37 -0700537 clone->bi_idx = 0;
538 clone->bi_vcnt = bio_segments(base_bio);
539 clone->bi_size = base_bio->bi_size;
Milan Broz93e605c2006-10-03 01:15:38 -0700540 clone->bi_sector = cc->start + sector;
Milan Broz8b004452006-10-03 01:15:37 -0700541 memcpy(clone->bi_io_vec, bio_iovec(base_bio),
542 sizeof(struct bio_vec) * clone->bi_vcnt);
Milan Broz8b004452006-10-03 01:15:37 -0700543
Milan Broz93e605c2006-10-03 01:15:38 -0700544 generic_make_request(clone);
Milan Broz8b004452006-10-03 01:15:37 -0700545}
546
Milan Broz23541d22006-10-03 01:15:39 -0700547static void process_write(struct crypt_io *io)
Milan Broz8b004452006-10-03 01:15:37 -0700548{
549 struct crypt_config *cc = io->target->private;
550 struct bio *base_bio = io->base_bio;
551 struct bio *clone;
Milan Broz93e605c2006-10-03 01:15:38 -0700552 struct convert_context ctx;
553 unsigned remaining = base_bio->bi_size;
554 sector_t sector = base_bio->bi_sector - io->target->begin;
555 unsigned bvec_idx = 0;
Milan Broz8b004452006-10-03 01:15:37 -0700556
Milan Broz93e605c2006-10-03 01:15:38 -0700557 atomic_inc(&io->pending);
Milan Broz8b004452006-10-03 01:15:37 -0700558
Milan Broz93e605c2006-10-03 01:15:38 -0700559 crypt_convert_init(cc, &ctx, NULL, base_bio, sector, 1);
Milan Broz8b004452006-10-03 01:15:37 -0700560
Milan Broz93e605c2006-10-03 01:15:38 -0700561 /*
562 * The allocated buffers can be smaller than the whole bio,
563 * so repeat the whole process until all the data can be handled.
564 */
565 while (remaining) {
566 clone = crypt_alloc_buffer(cc, base_bio->bi_size,
567 io->first_clone, &bvec_idx);
Milan Broz23541d22006-10-03 01:15:39 -0700568 if (unlikely(!clone)) {
569 dec_pending(io, -ENOMEM);
570 return;
571 }
Milan Broz93e605c2006-10-03 01:15:38 -0700572
573 ctx.bio_out = clone;
574
575 if (unlikely(crypt_convert(cc, &ctx) < 0)) {
576 crypt_free_buffer_pages(cc, clone, clone->bi_size);
577 bio_put(clone);
Milan Broz23541d22006-10-03 01:15:39 -0700578 dec_pending(io, -EIO);
579 return;
Milan Broz93e605c2006-10-03 01:15:38 -0700580 }
581
582 clone_init(io, clone);
583 clone->bi_sector = cc->start + sector;
584
585 if (!io->first_clone) {
586 /*
587 * hold a reference to the first clone, because it
588 * holds the bio_vec array and that can't be freed
589 * before all other clones are released
590 */
591 bio_get(clone);
592 io->first_clone = clone;
593 }
594
Milan Broz93e605c2006-10-03 01:15:38 -0700595 remaining -= clone->bi_size;
596 sector += bio_sectors(clone);
597
Milan Broz23541d22006-10-03 01:15:39 -0700598 /* prevent bio_put of first_clone */
599 if (remaining)
600 atomic_inc(&io->pending);
601
Milan Broz93e605c2006-10-03 01:15:38 -0700602 generic_make_request(clone);
603
604 /* out of memory -> run queues */
605 if (remaining)
Andrew Morton3fcfab12006-10-19 23:28:16 -0700606 congestion_wait(bio_data_dir(clone), HZ/100);
Milan Broz8b004452006-10-03 01:15:37 -0700607 }
Milan Broz8b004452006-10-03 01:15:37 -0700608}
609
610static void process_read_endio(struct crypt_io *io)
611{
612 struct crypt_config *cc = io->target->private;
613 struct convert_context ctx;
614
615 crypt_convert_init(cc, &ctx, io->base_bio, io->base_bio,
616 io->base_bio->bi_sector - io->target->begin, 0);
617
618 dec_pending(io, crypt_convert(cc, &ctx));
619}
620
621static void kcryptd_do_work(void *data)
622{
623 struct crypt_io *io = data;
624
Milan Broz23541d22006-10-03 01:15:39 -0700625 if (io->post_process)
626 process_read_endio(io);
627 else if (bio_data_dir(io->base_bio) == READ)
628 process_read(io);
629 else
630 process_write(io);
Milan Broz8b004452006-10-03 01:15:37 -0700631}
632
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633/*
634 * Decode key from its hex representation
635 */
636static int crypt_decode_key(u8 *key, char *hex, unsigned int size)
637{
638 char buffer[3];
639 char *endp;
640 unsigned int i;
641
642 buffer[2] = '\0';
643
Milan Broz8b004452006-10-03 01:15:37 -0700644 for (i = 0; i < size; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 buffer[0] = *hex++;
646 buffer[1] = *hex++;
647
648 key[i] = (u8)simple_strtoul(buffer, &endp, 16);
649
650 if (endp != &buffer[2])
651 return -EINVAL;
652 }
653
654 if (*hex != '\0')
655 return -EINVAL;
656
657 return 0;
658}
659
660/*
661 * Encode key into its hex representation
662 */
663static void crypt_encode_key(char *hex, u8 *key, unsigned int size)
664{
665 unsigned int i;
666
Milan Broz8b004452006-10-03 01:15:37 -0700667 for (i = 0; i < size; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 sprintf(hex, "%02x", *key);
669 hex += 2;
670 key++;
671 }
672}
673
Milan Broze48d4bb2006-10-03 01:15:37 -0700674static int crypt_set_key(struct crypt_config *cc, char *key)
675{
676 unsigned key_size = strlen(key) >> 1;
677
678 if (cc->key_size && cc->key_size != key_size)
679 return -EINVAL;
680
681 cc->key_size = key_size; /* initial settings */
682
683 if ((!key_size && strcmp(key, "-")) ||
684 (key_size && crypt_decode_key(cc->key, key, key_size) < 0))
685 return -EINVAL;
686
687 set_bit(DM_CRYPT_KEY_VALID, &cc->flags);
688
689 return 0;
690}
691
692static int crypt_wipe_key(struct crypt_config *cc)
693{
694 clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
695 memset(&cc->key, 0, cc->key_size * sizeof(u8));
696 return 0;
697}
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699/*
700 * Construct an encryption mapping:
701 * <cipher> <key> <iv_offset> <dev_path> <start>
702 */
703static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
704{
705 struct crypt_config *cc;
Herbert Xud1806f62006-08-22 20:29:17 +1000706 struct crypto_blkcipher *tfm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 char *tmp;
708 char *cipher;
709 char *chainmode;
710 char *ivmode;
711 char *ivopts;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 unsigned int key_size;
Andrew Morton4ee218c2006-03-27 01:17:48 -0800713 unsigned long long tmpll;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
715 if (argc != 5) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700716 ti->error = "Not enough arguments";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 return -EINVAL;
718 }
719
720 tmp = argv[0];
721 cipher = strsep(&tmp, "-");
722 chainmode = strsep(&tmp, "-");
723 ivopts = strsep(&tmp, "-");
724 ivmode = strsep(&ivopts, ":");
725
726 if (tmp)
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700727 DMWARN("Unexpected additional cipher options");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729 key_size = strlen(argv[1]) >> 1;
730
Milan Broze48d4bb2006-10-03 01:15:37 -0700731 cc = kzalloc(sizeof(*cc) + key_size * sizeof(u8), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (cc == NULL) {
733 ti->error =
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700734 "Cannot allocate transparent encryption context";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 return -ENOMEM;
736 }
737
Milan Broze48d4bb2006-10-03 01:15:37 -0700738 if (crypt_set_key(cc, argv[1])) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700739 ti->error = "Error decoding key";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 goto bad1;
741 }
742
743 /* Compatiblity mode for old dm-crypt cipher strings */
744 if (!chainmode || (strcmp(chainmode, "plain") == 0 && !ivmode)) {
745 chainmode = "cbc";
746 ivmode = "plain";
747 }
748
Herbert Xud1806f62006-08-22 20:29:17 +1000749 if (strcmp(chainmode, "ecb") && !ivmode) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700750 ti->error = "This chaining mode requires an IV mechanism";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 goto bad1;
752 }
753
Herbert Xud1806f62006-08-22 20:29:17 +1000754 if (snprintf(cc->cipher, CRYPTO_MAX_ALG_NAME, "%s(%s)", chainmode,
755 cipher) >= CRYPTO_MAX_ALG_NAME) {
756 ti->error = "Chain mode + cipher name is too long";
757 goto bad1;
758 }
759
760 tfm = crypto_alloc_blkcipher(cc->cipher, 0, CRYPTO_ALG_ASYNC);
761 if (IS_ERR(tfm)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700762 ti->error = "Error allocating crypto tfm";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 goto bad1;
764 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Herbert Xud1806f62006-08-22 20:29:17 +1000766 strcpy(cc->cipher, cipher);
767 strcpy(cc->chainmode, chainmode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 cc->tfm = tfm;
769
770 /*
771 * Choose ivmode. Valid modes: "plain", "essiv:<esshash>".
772 * See comments at iv code
773 */
774
775 if (ivmode == NULL)
776 cc->iv_gen_ops = NULL;
777 else if (strcmp(ivmode, "plain") == 0)
778 cc->iv_gen_ops = &crypt_iv_plain_ops;
779 else if (strcmp(ivmode, "essiv") == 0)
780 cc->iv_gen_ops = &crypt_iv_essiv_ops;
781 else {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700782 ti->error = "Invalid IV mode";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 goto bad2;
784 }
785
786 if (cc->iv_gen_ops && cc->iv_gen_ops->ctr &&
787 cc->iv_gen_ops->ctr(cc, ti, ivopts) < 0)
788 goto bad2;
789
Herbert Xud1806f62006-08-22 20:29:17 +1000790 cc->iv_size = crypto_blkcipher_ivsize(tfm);
791 if (cc->iv_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 /* at least a 64 bit sector number should fit in our buffer */
Herbert Xud1806f62006-08-22 20:29:17 +1000793 cc->iv_size = max(cc->iv_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 (unsigned int)(sizeof(u64) / sizeof(u8)));
795 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 if (cc->iv_gen_ops) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700797 DMWARN("Selected cipher does not support IVs");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 if (cc->iv_gen_ops->dtr)
799 cc->iv_gen_ops->dtr(cc);
800 cc->iv_gen_ops = NULL;
801 }
802 }
803
Matthew Dobson93d23412006-03-26 01:37:50 -0800804 cc->io_pool = mempool_create_slab_pool(MIN_IOS, _crypt_io_pool);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 if (!cc->io_pool) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700806 ti->error = "Cannot allocate crypt io mempool";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 goto bad3;
808 }
809
Matthew Dobsona19b27c2006-03-26 01:37:45 -0800810 cc->page_pool = mempool_create_page_pool(MIN_POOL_PAGES, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 if (!cc->page_pool) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700812 ti->error = "Cannot allocate page mempool";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 goto bad4;
814 }
815
Milan Broz6a24c712006-10-03 01:15:40 -0700816 cc->bs = bioset_create(MIN_IOS, MIN_IOS, 4);
817 if (!cc->bs) {
818 ti->error = "Cannot allocate crypt bioset";
819 goto bad_bs;
820 }
821
Herbert Xud1806f62006-08-22 20:29:17 +1000822 if (crypto_blkcipher_setkey(tfm, cc->key, key_size) < 0) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700823 ti->error = "Error setting key";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 goto bad5;
825 }
826
Andrew Morton4ee218c2006-03-27 01:17:48 -0800827 if (sscanf(argv[2], "%llu", &tmpll) != 1) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700828 ti->error = "Invalid iv_offset sector";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 goto bad5;
830 }
Andrew Morton4ee218c2006-03-27 01:17:48 -0800831 cc->iv_offset = tmpll;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
Andrew Morton4ee218c2006-03-27 01:17:48 -0800833 if (sscanf(argv[4], "%llu", &tmpll) != 1) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700834 ti->error = "Invalid device sector";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 goto bad5;
836 }
Andrew Morton4ee218c2006-03-27 01:17:48 -0800837 cc->start = tmpll;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
839 if (dm_get_device(ti, argv[3], cc->start, ti->len,
840 dm_table_get_mode(ti->table), &cc->dev)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700841 ti->error = "Device lookup failed";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 goto bad5;
843 }
844
845 if (ivmode && cc->iv_gen_ops) {
846 if (ivopts)
847 *(ivopts - 1) = ':';
848 cc->iv_mode = kmalloc(strlen(ivmode) + 1, GFP_KERNEL);
849 if (!cc->iv_mode) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700850 ti->error = "Error kmallocing iv_mode string";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 goto bad5;
852 }
853 strcpy(cc->iv_mode, ivmode);
854 } else
855 cc->iv_mode = NULL;
856
857 ti->private = cc;
858 return 0;
859
860bad5:
Milan Broz6a24c712006-10-03 01:15:40 -0700861 bioset_free(cc->bs);
862bad_bs:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 mempool_destroy(cc->page_pool);
864bad4:
865 mempool_destroy(cc->io_pool);
866bad3:
867 if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
868 cc->iv_gen_ops->dtr(cc);
869bad2:
Herbert Xud1806f62006-08-22 20:29:17 +1000870 crypto_free_blkcipher(tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871bad1:
Stefan Rompf9d3520a2006-01-06 00:20:08 -0800872 /* Must zero key material before freeing */
873 memset(cc, 0, sizeof(*cc) + cc->key_size * sizeof(u8));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 kfree(cc);
875 return -EINVAL;
876}
877
878static void crypt_dtr(struct dm_target *ti)
879{
880 struct crypt_config *cc = (struct crypt_config *) ti->private;
881
Milan Broz6a24c712006-10-03 01:15:40 -0700882 bioset_free(cc->bs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 mempool_destroy(cc->page_pool);
884 mempool_destroy(cc->io_pool);
885
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700886 kfree(cc->iv_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
888 cc->iv_gen_ops->dtr(cc);
Herbert Xud1806f62006-08-22 20:29:17 +1000889 crypto_free_blkcipher(cc->tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 dm_put_device(ti, cc->dev);
Stefan Rompf9d3520a2006-01-06 00:20:08 -0800891
892 /* Must zero key material before freeing */
893 memset(cc, 0, sizeof(*cc) + cc->key_size * sizeof(u8));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 kfree(cc);
895}
896
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897static int crypt_map(struct dm_target *ti, struct bio *bio,
898 union map_info *map_context)
899{
Milan Broz8b004452006-10-03 01:15:37 -0700900 struct crypt_config *cc = ti->private;
Milan Broze48d4bb2006-10-03 01:15:37 -0700901 struct crypt_io *io;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
Milan Broze48d4bb2006-10-03 01:15:37 -0700903 io = mempool_alloc(cc->io_pool, GFP_NOIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 io->target = ti;
Milan Broz8b004452006-10-03 01:15:37 -0700905 io->base_bio = bio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 io->first_clone = NULL;
Milan Broz23541d22006-10-03 01:15:39 -0700907 io->error = io->post_process = 0;
Milan Broz93e605c2006-10-03 01:15:38 -0700908 atomic_set(&io->pending, 0);
Milan Broz23541d22006-10-03 01:15:39 -0700909 kcryptd_queue_io(io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
Milan Broz23541d22006-10-03 01:15:39 -0700911 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912}
913
914static int crypt_status(struct dm_target *ti, status_type_t type,
915 char *result, unsigned int maxlen)
916{
917 struct crypt_config *cc = (struct crypt_config *) ti->private;
918 const char *cipher;
919 const char *chainmode = NULL;
920 unsigned int sz = 0;
921
922 switch (type) {
923 case STATUSTYPE_INFO:
924 result[0] = '\0';
925 break;
926
927 case STATUSTYPE_TABLE:
Herbert Xud1806f62006-08-22 20:29:17 +1000928 cipher = crypto_blkcipher_name(cc->tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Herbert Xud1806f62006-08-22 20:29:17 +1000930 chainmode = cc->chainmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
932 if (cc->iv_mode)
933 DMEMIT("%s-%s-%s ", cipher, chainmode, cc->iv_mode);
934 else
935 DMEMIT("%s-%s ", cipher, chainmode);
936
937 if (cc->key_size > 0) {
938 if ((maxlen - sz) < ((cc->key_size << 1) + 1))
939 return -ENOMEM;
940
941 crypt_encode_key(result + sz, cc->key, cc->key_size);
942 sz += cc->key_size << 1;
943 } else {
944 if (sz >= maxlen)
945 return -ENOMEM;
946 result[sz++] = '-';
947 }
948
Andrew Morton4ee218c2006-03-27 01:17:48 -0800949 DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
950 cc->dev->name, (unsigned long long)cc->start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 break;
952 }
953 return 0;
954}
955
Milan Broze48d4bb2006-10-03 01:15:37 -0700956static void crypt_postsuspend(struct dm_target *ti)
957{
958 struct crypt_config *cc = ti->private;
959
960 set_bit(DM_CRYPT_SUSPENDED, &cc->flags);
961}
962
963static int crypt_preresume(struct dm_target *ti)
964{
965 struct crypt_config *cc = ti->private;
966
967 if (!test_bit(DM_CRYPT_KEY_VALID, &cc->flags)) {
968 DMERR("aborting resume - crypt key is not set.");
969 return -EAGAIN;
970 }
971
972 return 0;
973}
974
975static void crypt_resume(struct dm_target *ti)
976{
977 struct crypt_config *cc = ti->private;
978
979 clear_bit(DM_CRYPT_SUSPENDED, &cc->flags);
980}
981
982/* Message interface
983 * key set <key>
984 * key wipe
985 */
986static int crypt_message(struct dm_target *ti, unsigned argc, char **argv)
987{
988 struct crypt_config *cc = ti->private;
989
990 if (argc < 2)
991 goto error;
992
993 if (!strnicmp(argv[0], MESG_STR("key"))) {
994 if (!test_bit(DM_CRYPT_SUSPENDED, &cc->flags)) {
995 DMWARN("not suspended during key manipulation.");
996 return -EINVAL;
997 }
998 if (argc == 3 && !strnicmp(argv[1], MESG_STR("set")))
999 return crypt_set_key(cc, argv[2]);
1000 if (argc == 2 && !strnicmp(argv[1], MESG_STR("wipe")))
1001 return crypt_wipe_key(cc);
1002 }
1003
1004error:
1005 DMWARN("unrecognised message received.");
1006 return -EINVAL;
1007}
1008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009static struct target_type crypt_target = {
1010 .name = "crypt",
Milan Broz23541d22006-10-03 01:15:39 -07001011 .version= {1, 3, 0},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 .module = THIS_MODULE,
1013 .ctr = crypt_ctr,
1014 .dtr = crypt_dtr,
1015 .map = crypt_map,
1016 .status = crypt_status,
Milan Broze48d4bb2006-10-03 01:15:37 -07001017 .postsuspend = crypt_postsuspend,
1018 .preresume = crypt_preresume,
1019 .resume = crypt_resume,
1020 .message = crypt_message,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021};
1022
1023static int __init dm_crypt_init(void)
1024{
1025 int r;
1026
1027 _crypt_io_pool = kmem_cache_create("dm-crypt_io",
1028 sizeof(struct crypt_io),
1029 0, 0, NULL, NULL);
1030 if (!_crypt_io_pool)
1031 return -ENOMEM;
1032
1033 _kcryptd_workqueue = create_workqueue("kcryptd");
1034 if (!_kcryptd_workqueue) {
1035 r = -ENOMEM;
Alasdair G Kergon72d94862006-06-26 00:27:35 -07001036 DMERR("couldn't create kcryptd");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 goto bad1;
1038 }
1039
1040 r = dm_register_target(&crypt_target);
1041 if (r < 0) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -07001042 DMERR("register failed %d", r);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 goto bad2;
1044 }
1045
1046 return 0;
1047
1048bad2:
1049 destroy_workqueue(_kcryptd_workqueue);
1050bad1:
1051 kmem_cache_destroy(_crypt_io_pool);
1052 return r;
1053}
1054
1055static void __exit dm_crypt_exit(void)
1056{
1057 int r = dm_unregister_target(&crypt_target);
1058
1059 if (r < 0)
Alasdair G Kergon72d94862006-06-26 00:27:35 -07001060 DMERR("unregister failed %d", r);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
1062 destroy_workqueue(_kcryptd_workqueue);
1063 kmem_cache_destroy(_crypt_io_pool);
1064}
1065
1066module_init(dm_crypt_init);
1067module_exit(dm_crypt_exit);
1068
1069MODULE_AUTHOR("Christophe Saout <christophe@saout.de>");
1070MODULE_DESCRIPTION(DM_NAME " target for transparent encryption / decryption");
1071MODULE_LICENSE("GPL");