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-2009 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 <linux/atomic.h>
  22 #include <linux/scatterlist.h>
  23 #include <asm/page.h>
  24 #include <asm/unaligned.h>
  25 #include <crypto/hash.h>
  26 #include <crypto/md5.h>
  27 #include <crypto/algapi.h>
  28
  29 #include <linux/device-mapper.h>
  30
  31 #define DM_MSG_PREFIX "crypt"
  32
  33 /*
  34  * context holding the current state of a multi-part conversion
  35  */
  36 struct convert_context {
  37         struct completion restart;
  38         struct bio *bio_in;
  39         struct bio *bio_out;
  40         unsigned int offset_in;
  41         unsigned int offset_out;
  42         unsigned int idx_in;
  43         unsigned int idx_out;
  44         sector_t cc_sector;
  45         atomic_t cc_pending;
  46         struct ablkcipher_request *req;
  47 };
  48
  49 /*
  50  * per bio private data
  51  */
  52 struct dm_crypt_io {
  53         struct crypt_config *cc;
  54         struct bio *base_bio;
  55         struct work_struct work;
  56
  57         struct convert_context ctx;
  58
  59         atomic_t io_pending;
  60         int error;
  61         sector_t sector;
  62         struct dm_crypt_io *base_io;
  63 };
  64
  65 struct dm_crypt_request {
  66         struct convert_context *ctx;
  67         struct scatterlist sg_in;
  68         struct scatterlist sg_out;
  69         sector_t iv_sector;
  70 };
  71
  72 struct crypt_config;
  73
  74 struct crypt_iv_operations {
  75         int (*ctr)(struct crypt_config *cc, struct dm_target *ti,
  76                    const char *opts);
  77         void (*dtr)(struct crypt_config *cc);
  78         int (*init)(struct crypt_config *cc);
  79         int (*wipe)(struct crypt_config *cc);
  80         int (*generator)(struct crypt_config *cc, u8 *iv,
  81                          struct dm_crypt_request *dmreq);
  82         int (*post)(struct crypt_config *cc, u8 *iv,
  83                     struct dm_crypt_request *dmreq);
  84 };
  85
  86 struct iv_essiv_private {
  87         struct crypto_hash *hash_tfm;
  88         u8 *salt;
  89 };
  90
  91 struct iv_benbi_private {
  92         int shift;
  93 };
  94
  95 #define LMK_SEED_SIZE 64 /* hash + 0 */
  96 struct iv_lmk_private {
  97         struct crypto_shash *hash_tfm;
  98         u8 *seed;
  99 };
 100
 101 /*
 102  * Crypt: maps a linear range of a block device
 103  * and encrypts / decrypts at the same time.
 104  */
 105 enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID };
 106
 107 /*
 108  * The fields in here must be read only after initialization.
 109  */
 110 struct crypt_config {
 111         struct dm_dev *dev;
 112         sector_t start;
 113
 114         /*
 115          * pool for per bio private data, crypto requests and
 116          * encryption requeusts/buffer pages
 117          */
 118         mempool_t *io_pool;
 119         mempool_t *req_pool;
 120         mempool_t *page_pool;
 121         struct bio_set *bs;
 122
 123         struct workqueue_struct *io_queue;
 124         struct workqueue_struct *crypt_queue;
 125
 126         char *cipher;
 127         char *cipher_string;
 128
 129         struct crypt_iv_operations *iv_gen_ops;
 130         union {
 131                 struct iv_essiv_private essiv;
 132                 struct iv_benbi_private benbi;
 133                 struct iv_lmk_private lmk;
 134         } iv_gen_private;
 135         sector_t iv_offset;
 136         unsigned int iv_size;
 137
 138         /* ESSIV: struct crypto_cipher *essiv_tfm */
 139         void *iv_private;
 140         struct crypto_ablkcipher **tfms;
 141         unsigned tfms_count;
 142
 143         /*
 144          * Layout of each crypto request:
 145          *
 146          *   struct ablkcipher_request
 147          *      context
 148          *      padding
 149          *   struct dm_crypt_request
 150          *      padding
 151          *   IV
 152          *
 153          * The padding is added so that dm_crypt_request and the IV are
 154          * correctly aligned.
 155          */
 156         unsigned int dmreq_start;
 157
 158         unsigned long flags;
 159         unsigned int key_size;
 160         unsigned int key_parts;
 161         u8 key[0];
 162 };
 163
 164 #define MIN_IOS        16
 165 #define MIN_POOL_PAGES 32
 166
 167 static struct kmem_cache *_crypt_io_pool;
 168
 169 static void clone_init(struct dm_crypt_io *, struct bio *);
 170 static void kcryptd_queue_crypt(struct dm_crypt_io *io);
 171 static u8 *iv_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq);
 172
 173 /*
 174  * Use this to access cipher attributes that are the same for each CPU.
 175  */
 176 static struct crypto_ablkcipher *any_tfm(struct crypt_config *cc)
 177 {
 178         return cc->tfms[0];
 179 }
 180
 181 /*
 182  * Different IV generation algorithms:
 183  *
 184  * plain: the initial vector is the 32-bit little-endian version of the sector
 185  *        number, padded with zeros if necessary.
 186  *
 187  * plain64: the initial vector is the 64-bit little-endian version of the sector
 188  *        number, padded with zeros if necessary.
 189  *
 190  * essiv: "encrypted sector|salt initial vector", the sector number is
 191  *        encrypted with the bulk cipher using a salt as key. The salt
 192  *        should be derived from the bulk cipher's key via hashing.
 193  *
 194  * benbi: the 64-bit "big-endian 'narrow block'-count", starting at 1
 195  *        (needed for LRW-32-AES and possible other narrow block modes)
 196  *
 197  * null: the initial vector is always zero.  Provides compatibility with
 198  *       obsolete loop_fish2 devices.  Do not use for new devices.
 199  *
 200  * lmk:  Compatible implementation of the block chaining mode used
 201  *       by the Loop-AES block device encryption system
 202  *       designed by Jari Ruusu. See http://loop-aes.sourceforge.net/
 203  *       It operates on full 512 byte sectors and uses CBC
 204  *       with an IV derived from the sector number, the data and
 205  *       optionally extra IV seed.
 206  *       This means that after decryption the first block
 207  *       of sector must be tweaked according to decrypted data.
 208  *       Loop-AES can use three encryption schemes:
 209  *         version 1: is plain aes-cbc mode
 210  *         version 2: uses 64 multikey scheme with lmk IV generator
 211  *         version 3: the same as version 2 with additional IV seed
 212  *                   (it uses 65 keys, last key is used as IV seed)
 213  *
 214  * plumb: unimplemented, see:
 215  * http://article.gmane.org/gmane.linux.kernel.device-mapper.dm-crypt/454
 216  */
 217
 218 static int crypt_iv_plain_gen(struct crypt_config *cc, u8 *iv,
 219                               struct dm_crypt_request *dmreq)
 220 {
 221         memset(iv, 0, cc->iv_size);
 222         *(__le32 *)iv = cpu_to_le32(dmreq->iv_sector & 0xffffffff);
 223
 224         return 0;
 225 }
 226
 227 static int crypt_iv_plain64_gen(struct crypt_config *cc, u8 *iv,
 228                                 struct dm_crypt_request *dmreq)
 229 {
 230         memset(iv, 0, cc->iv_size);
 231         *(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
 232
 233         return 0;
 234 }
 235
 236 /* Initialise ESSIV - compute salt but no local memory allocations */
 237 static int crypt_iv_essiv_init(struct crypt_config *cc)
 238 {
 239         struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
 240         struct hash_desc desc;
 241         struct scatterlist sg;
 242         struct crypto_cipher *essiv_tfm;
 243         int err;
 244
 245         sg_init_one(&sg, cc->key, cc->key_size);
 246         desc.tfm = essiv->hash_tfm;
 247         desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 248
 249         err = crypto_hash_digest(&desc, &sg, cc->key_size, essiv->salt);
 250         if (err)
 251                 return err;
 252
 253         essiv_tfm = cc->iv_private;
 254
 255         err = crypto_cipher_setkey(essiv_tfm, essiv->salt,
 256                             crypto_hash_digestsize(essiv->hash_tfm));
 257         if (err)
 258                 return err;
 259
 260         return 0;
 261 }
 262
 263 /* Wipe salt and reset key derived from volume key */
 264 static int crypt_iv_essiv_wipe(struct crypt_config *cc)
 265 {
 266         struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
 267         unsigned salt_size = crypto_hash_digestsize(essiv->hash_tfm);
 268         struct crypto_cipher *essiv_tfm;
 269         int r, err = 0;
 270
 271         memset(essiv->salt, 0, salt_size);
 272
 273         essiv_tfm = cc->iv_private;
 274         r = crypto_cipher_setkey(essiv_tfm, essiv->salt, salt_size);
 275         if (r)
 276                 err = r;
 277
 278         return err;
 279 }
 280
 281 /* Set up per cpu cipher state */
 282 static struct crypto_cipher *setup_essiv_cpu(struct crypt_config *cc,
 283                                              struct dm_target *ti,
 284                                              u8 *salt, unsigned saltsize)
 285 {
 286         struct crypto_cipher *essiv_tfm;
 287         int err;
 288
 289         /* Setup the essiv_tfm with the given salt */
 290         essiv_tfm = crypto_alloc_cipher(cc->cipher, 0, CRYPTO_ALG_ASYNC);
 291         if (IS_ERR(essiv_tfm)) {
 292                 ti->error = "Error allocating crypto tfm for ESSIV";
 293                 return essiv_tfm;
 294         }
 295
 296         if (crypto_cipher_blocksize(essiv_tfm) !=
 297             crypto_ablkcipher_ivsize(any_tfm(cc))) {
 298                 ti->error = "Block size of ESSIV cipher does "
 299                             "not match IV size of block cipher";
 300                 crypto_free_cipher(essiv_tfm);
 301                 return ERR_PTR(-EINVAL);
 302         }
 303
 304         err = crypto_cipher_setkey(essiv_tfm, salt, saltsize);
 305         if (err) {
 306                 ti->error = "Failed to set key for ESSIV cipher";
 307                 crypto_free_cipher(essiv_tfm);
 308                 return ERR_PTR(err);
 309         }
 310
 311         return essiv_tfm;
 312 }
 313
 314 static void crypt_iv_essiv_dtr(struct crypt_config *cc)
 315 {
 316         struct crypto_cipher *essiv_tfm;
 317         struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
 318
 319         crypto_free_hash(essiv->hash_tfm);
 320         essiv->hash_tfm = NULL;
 321
 322         kzfree(essiv->salt);
 323         essiv->salt = NULL;
 324
 325         essiv_tfm = cc->iv_private;
 326
 327         if (essiv_tfm)
 328                 crypto_free_cipher(essiv_tfm);
 329
 330         cc->iv_private = NULL;
 331 }
 332
 333 static int crypt_iv_essiv_ctr(struct crypt_config *cc, struct dm_target *ti,
 334                               const char *opts)
 335 {
 336         struct crypto_cipher *essiv_tfm = NULL;
 337         struct crypto_hash *hash_tfm = NULL;
 338         u8 *salt = NULL;
 339         int err;
 340
 341         if (!opts) {
 342                 ti->error = "Digest algorithm missing for ESSIV mode";
 343                 return -EINVAL;
 344         }
 345
 346         /* Allocate hash algorithm */
 347         hash_tfm = crypto_alloc_hash(opts, 0, CRYPTO_ALG_ASYNC);
 348         if (IS_ERR(hash_tfm)) {
 349                 ti->error = "Error initializing ESSIV hash";
 350                 err = PTR_ERR(hash_tfm);
 351                 goto bad;
 352         }
 353
 354         salt = kzalloc(crypto_hash_digestsize(hash_tfm), GFP_KERNEL);
 355         if (!salt) {
 356                 ti->error = "Error kmallocing salt storage in ESSIV";
 357                 err = -ENOMEM;
 358                 goto bad;
 359         }
 360
 361         cc->iv_gen_private.essiv.salt = salt;
 362         cc->iv_gen_private.essiv.hash_tfm = hash_tfm;
 363
 364         essiv_tfm = setup_essiv_cpu(cc, ti, salt,
 365                                 crypto_hash_digestsize(hash_tfm));
 366         if (IS_ERR(essiv_tfm)) {
 367                 crypt_iv_essiv_dtr(cc);
 368                 return PTR_ERR(essiv_tfm);
 369         }
 370         cc->iv_private = essiv_tfm;
 371
 372         return 0;
 373
 374 bad:
 375         if (hash_tfm && !IS_ERR(hash_tfm))
 376                 crypto_free_hash(hash_tfm);
 377         kfree(salt);
 378         return err;
 379 }
 380
 381 static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv,
 382                               struct dm_crypt_request *dmreq)
 383 {
 384         struct crypto_cipher *essiv_tfm = cc->iv_private;
 385
 386         memset(iv, 0, cc->iv_size);
 387         *(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
 388         crypto_cipher_encrypt_one(essiv_tfm, iv, iv);
 389
 390         return 0;
 391 }
 392
 393 static int crypt_iv_benbi_ctr(struct crypt_config *cc, struct dm_target *ti,
 394                               const char *opts)
 395 {
 396         unsigned bs = crypto_ablkcipher_blocksize(any_tfm(cc));
 397         int log = ilog2(bs);
 398
 399         /* we need to calculate how far we must shift the sector count
 400          * to get the cipher block count, we use this shift in _gen */
 401
 402         if (1 << log != bs) {
 403                 ti->error = "cypher blocksize is not a power of 2";
 404                 return -EINVAL;
 405         }
 406
 407         if (log > 9) {
 408                 ti->error = "cypher blocksize is > 512";
 409                 return -EINVAL;
 410         }
 411
 412         cc->iv_gen_private.benbi.shift = 9 - log;
 413
 414         return 0;
 415 }
 416
 417 static void crypt_iv_benbi_dtr(struct crypt_config *cc)
 418 {
 419 }
 420
 421 static int crypt_iv_benbi_gen(struct crypt_config *cc, u8 *iv,
 422                               struct dm_crypt_request *dmreq)
 423 {
 424         __be64 val;
 425
 426         memset(iv, 0, cc->iv_size - sizeof(u64)); /* rest is cleared below */
 427
 428         val = cpu_to_be64(((u64)dmreq->iv_sector << cc->iv_gen_private.benbi.shift) + 1);
 429         put_unaligned(val, (__be64 *)(iv + cc->iv_size - sizeof(u64)));
 430
 431         return 0;
 432 }
 433
 434 static int crypt_iv_null_gen(struct crypt_config *cc, u8 *iv,
 435                              struct dm_crypt_request *dmreq)
 436 {
 437         memset(iv, 0, cc->iv_size);
 438
 439         return 0;
 440 }
 441
 442 static void crypt_iv_lmk_dtr(struct crypt_config *cc)
 443 {
 444         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 445
 446         if (lmk->hash_tfm && !IS_ERR(lmk->hash_tfm))
 447                 crypto_free_shash(lmk->hash_tfm);
 448         lmk->hash_tfm = NULL;
 449
 450         kzfree(lmk->seed);
 451         lmk->seed = NULL;
 452 }
 453
 454 static int crypt_iv_lmk_ctr(struct crypt_config *cc, struct dm_target *ti,
 455                             const char *opts)
 456 {
 457         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 458
 459         lmk->hash_tfm = crypto_alloc_shash("md5", 0, 0);
 460         if (IS_ERR(lmk->hash_tfm)) {
 461                 ti->error = "Error initializing LMK hash";
 462                 return PTR_ERR(lmk->hash_tfm);
 463         }
 464
 465         /* No seed in LMK version 2 */
 466         if (cc->key_parts == cc->tfms_count) {
 467                 lmk->seed = NULL;
 468                 return 0;
 469         }
 470
 471         lmk->seed = kzalloc(LMK_SEED_SIZE, GFP_KERNEL);
 472         if (!lmk->seed) {
 473                 crypt_iv_lmk_dtr(cc);
 474                 ti->error = "Error kmallocing seed storage in LMK";
 475                 return -ENOMEM;
 476         }
 477
 478         return 0;
 479 }
 480
 481 static int crypt_iv_lmk_init(struct crypt_config *cc)
 482 {
 483         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 484         int subkey_size = cc->key_size / cc->key_parts;
 485
 486         /* LMK seed is on the position of LMK_KEYS + 1 key */
 487         if (lmk->seed)
 488                 memcpy(lmk->seed, cc->key + (cc->tfms_count * subkey_size),
 489                        crypto_shash_digestsize(lmk->hash_tfm));
 490
 491         return 0;
 492 }
 493
 494 static int crypt_iv_lmk_wipe(struct crypt_config *cc)
 495 {
 496         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 497
 498         if (lmk->seed)
 499                 memset(lmk->seed, 0, LMK_SEED_SIZE);
 500
 501         return 0;
 502 }
 503
 504 static int crypt_iv_lmk_one(struct crypt_config *cc, u8 *iv,
 505                             struct dm_crypt_request *dmreq,
 506                             u8 *data)
 507 {
 508         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 509         struct {
 510                 struct shash_desc desc;
 511                 char ctx[crypto_shash_descsize(lmk->hash_tfm)];
 512         } sdesc;
 513         struct md5_state md5state;
 514         u32 buf[4];
 515         int i, r;
 516
 517         sdesc.desc.tfm = lmk->hash_tfm;
 518         sdesc.desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 519
 520         r = crypto_shash_init(&sdesc.desc);
 521         if (r)
 522                 return r;
 523
 524         if (lmk->seed) {
 525                 r = crypto_shash_update(&sdesc.desc, lmk->seed, LMK_SEED_SIZE);
 526                 if (r)
 527                         return r;
 528         }
 529
 530         /* Sector is always 512B, block size 16, add data of blocks 1-31 */
 531         r = crypto_shash_update(&sdesc.desc, data + 16, 16 * 31);
 532         if (r)
 533                 return r;
 534
 535         /* Sector is cropped to 56 bits here */
 536         buf[0] = cpu_to_le32(dmreq->iv_sector & 0xFFFFFFFF);
 537         buf[1] = cpu_to_le32((((u64)dmreq->iv_sector >> 32) & 0x00FFFFFF) | 0x80000000);
 538         buf[2] = cpu_to_le32(4024);
 539         buf[3] = 0;
 540         r = crypto_shash_update(&sdesc.desc, (u8 *)buf, sizeof(buf));
 541         if (r)
 542                 return r;
 543
 544         /* No MD5 padding here */
 545         r = crypto_shash_export(&sdesc.desc, &md5state);
 546         if (r)
 547                 return r;
 548
 549         for (i = 0; i < MD5_HASH_WORDS; i++)
 550                 __cpu_to_le32s(&md5state.hash[i]);
 551         memcpy(iv, &md5state.hash, cc->iv_size);
 552
 553         return 0;
 554 }
 555
 556 static int crypt_iv_lmk_gen(struct crypt_config *cc, u8 *iv,
 557                             struct dm_crypt_request *dmreq)
 558 {
 559         u8 *src;
 560         int r = 0;
 561
 562         if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) {
 563                 src = kmap_atomic(sg_page(&dmreq->sg_in));
 564                 r = crypt_iv_lmk_one(cc, iv, dmreq, src + dmreq->sg_in.offset);
 565                 kunmap_atomic(src);
 566         } else
 567                 memset(iv, 0, cc->iv_size);
 568
 569         return r;
 570 }
 571
 572 static int crypt_iv_lmk_post(struct crypt_config *cc, u8 *iv,
 573                              struct dm_crypt_request *dmreq)
 574 {
 575         u8 *dst;
 576         int r;
 577
 578         if (bio_data_dir(dmreq->ctx->bio_in) == WRITE)
 579                 return 0;
 580
 581         dst = kmap_atomic(sg_page(&dmreq->sg_out));
 582         r = crypt_iv_lmk_one(cc, iv, dmreq, dst + dmreq->sg_out.offset);
 583
 584         /* Tweak the first block of plaintext sector */
 585         if (!r)
 586                 crypto_xor(dst + dmreq->sg_out.offset, iv, cc->iv_size);
 587
 588         kunmap_atomic(dst);
 589         return r;
 590 }
 591
 592 static struct crypt_iv_operations crypt_iv_plain_ops = {
 593         .generator = crypt_iv_plain_gen
 594 };
 595
 596 static struct crypt_iv_operations crypt_iv_plain64_ops = {
 597         .generator = crypt_iv_plain64_gen
 598 };
 599
 600 static struct crypt_iv_operations crypt_iv_essiv_ops = {
 601         .ctr       = crypt_iv_essiv_ctr,
 602         .dtr       = crypt_iv_essiv_dtr,
 603         .init      = crypt_iv_essiv_init,
 604         .wipe      = crypt_iv_essiv_wipe,
 605         .generator = crypt_iv_essiv_gen
 606 };
 607
 608 static struct crypt_iv_operations crypt_iv_benbi_ops = {
 609         .ctr       = crypt_iv_benbi_ctr,
 610         .dtr       = crypt_iv_benbi_dtr,
 611         .generator = crypt_iv_benbi_gen
 612 };
 613
 614 static struct crypt_iv_operations crypt_iv_null_ops = {
 615         .generator = crypt_iv_null_gen
 616 };
 617
 618 static struct crypt_iv_operations crypt_iv_lmk_ops = {
 619         .ctr       = crypt_iv_lmk_ctr,
 620         .dtr       = crypt_iv_lmk_dtr,
 621         .init      = crypt_iv_lmk_init,
 622         .wipe      = crypt_iv_lmk_wipe,
 623         .generator = crypt_iv_lmk_gen,
 624         .post      = crypt_iv_lmk_post
 625 };
 626
 627 static void crypt_convert_init(struct crypt_config *cc,
 628                                struct convert_context *ctx,
 629                                struct bio *bio_out, struct bio *bio_in,
 630                                sector_t sector)
 631 {
 632         ctx->bio_in = bio_in;
 633         ctx->bio_out = bio_out;
 634         ctx->offset_in = 0;
 635         ctx->offset_out = 0;
 636         ctx->idx_in = bio_in ? bio_in->bi_idx : 0;
 637         ctx->idx_out = bio_out ? bio_out->bi_idx : 0;
 638         ctx->cc_sector = sector + cc->iv_offset;
 639         init_completion(&ctx->restart);
 640 }
 641
 642 static struct dm_crypt_request *dmreq_of_req(struct crypt_config *cc,
 643                                              struct ablkcipher_request *req)
 644 {
 645         return (struct dm_crypt_request *)((char *)req + cc->dmreq_start);
 646 }
 647
 648 static struct ablkcipher_request *req_of_dmreq(struct crypt_config *cc,
 649                                                struct dm_crypt_request *dmreq)
 650 {
 651         return (struct ablkcipher_request *)((char *)dmreq - cc->dmreq_start);
 652 }
 653
 654 static u8 *iv_of_dmreq(struct crypt_config *cc,
 655                        struct dm_crypt_request *dmreq)
 656 {
 657         return (u8 *)ALIGN((unsigned long)(dmreq + 1),
 658                 crypto_ablkcipher_alignmask(any_tfm(cc)) + 1);
 659 }
 660
 661 static int crypt_convert_block(struct crypt_config *cc,
 662                                struct convert_context *ctx,
 663                                struct ablkcipher_request *req)
 664 {
 665         struct bio_vec *bv_in = bio_iovec_idx(ctx->bio_in, ctx->idx_in);
 666         struct bio_vec *bv_out = bio_iovec_idx(ctx->bio_out, ctx->idx_out);
 667         struct dm_crypt_request *dmreq;
 668         u8 *iv;
 669         int r;
 670
 671         dmreq = dmreq_of_req(cc, req);
 672         iv = iv_of_dmreq(cc, dmreq);
 673
 674         dmreq->iv_sector = ctx->cc_sector;
 675         dmreq->ctx = ctx;
 676         sg_init_table(&dmreq->sg_in, 1);
 677         sg_set_page(&dmreq->sg_in, bv_in->bv_page, 1 << SECTOR_SHIFT,
 678                     bv_in->bv_offset + ctx->offset_in);
 679
 680         sg_init_table(&dmreq->sg_out, 1);
 681         sg_set_page(&dmreq->sg_out, bv_out->bv_page, 1 << SECTOR_SHIFT,
 682                     bv_out->bv_offset + ctx->offset_out);
 683
 684         ctx->offset_in += 1 << SECTOR_SHIFT;
 685         if (ctx->offset_in >= bv_in->bv_len) {
 686                 ctx->offset_in = 0;
 687                 ctx->idx_in++;
 688         }
 689
 690         ctx->offset_out += 1 << SECTOR_SHIFT;
 691         if (ctx->offset_out >= bv_out->bv_len) {
 692                 ctx->offset_out = 0;
 693                 ctx->idx_out++;
 694         }
 695
 696         if (cc->iv_gen_ops) {
 697                 r = cc->iv_gen_ops->generator(cc, iv, dmreq);
 698                 if (r < 0)
 699                         return r;
 700         }
 701
 702         ablkcipher_request_set_crypt(req, &dmreq->sg_in, &dmreq->sg_out,
 703                                      1 << SECTOR_SHIFT, iv);
 704
 705         if (bio_data_dir(ctx->bio_in) == WRITE)
 706                 r = crypto_ablkcipher_encrypt(req);
 707         else
 708                 r = crypto_ablkcipher_decrypt(req);
 709
 710         if (!r && cc->iv_gen_ops && cc->iv_gen_ops->post)
 711                 r = cc->iv_gen_ops->post(cc, iv, dmreq);
 712
 713         return r;
 714 }
 715
 716 static void kcryptd_async_done(struct crypto_async_request *async_req,
 717                                int error);
 718
 719 static void crypt_alloc_req(struct crypt_config *cc,
 720                             struct convert_context *ctx)
 721 {
 722         unsigned key_index = ctx->cc_sector & (cc->tfms_count - 1);
 723
 724         if (!ctx->req)
 725                 ctx->req = mempool_alloc(cc->req_pool, GFP_NOIO);
 726
 727         ablkcipher_request_set_tfm(ctx->req, cc->tfms[key_index]);
 728         ablkcipher_request_set_callback(ctx->req,
 729             CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
 730             kcryptd_async_done, dmreq_of_req(cc, ctx->req));
 731 }
 732
 733 /*
 734  * Encrypt / decrypt data from one bio to another one (can be the same one)
 735  */
 736 static int crypt_convert(struct crypt_config *cc,
 737                          struct convert_context *ctx)
 738 {
 739         int r;
 740
 741         atomic_set(&ctx->cc_pending, 1);
 742
 743         while(ctx->idx_in < ctx->bio_in->bi_vcnt &&
 744               ctx->idx_out < ctx->bio_out->bi_vcnt) {
 745
 746                 crypt_alloc_req(cc, ctx);
 747
 748                 atomic_inc(&ctx->cc_pending);
 749
 750                 r = crypt_convert_block(cc, ctx, ctx->req);
 751
 752                 switch (r) {
 753                 /* async */
 754                 case -EBUSY:
 755                         wait_for_completion(&ctx->restart);
 756                         INIT_COMPLETION(ctx->restart);
 757                         /* fall through*/
 758                 case -EINPROGRESS:
 759                         ctx->req = NULL;
 760                         ctx->cc_sector++;
 761                         continue;
 762
 763                 /* sync */
 764                 case 0:
 765                         atomic_dec(&ctx->cc_pending);
 766                         ctx->cc_sector++;
 767                         cond_resched();
 768                         continue;
 769
 770                 /* error */
 771                 default:
 772                         atomic_dec(&ctx->cc_pending);
 773                         return r;
 774                 }
 775         }
 776
 777         return 0;
 778 }
 779
 780 /*
 781  * Generate a new unfragmented bio with the given size
 782  * This should never violate the device limitations
 783  * May return a smaller bio when running out of pages, indicated by
 784  * *out_of_pages set to 1.
 785  */
 786 static struct bio *crypt_alloc_buffer(struct dm_crypt_io *io, unsigned size,
 787                                       unsigned *out_of_pages)
 788 {
 789         struct crypt_config *cc = io->cc;
 790         struct bio *clone;
 791         unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
 792         gfp_t gfp_mask = GFP_NOIO | __GFP_HIGHMEM;
 793         unsigned i, len;
 794         struct page *page;
 795
 796         clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
 797         if (!clone)
 798                 return NULL;
 799
 800         clone_init(io, clone);
 801         *out_of_pages = 0;
 802
 803         for (i = 0; i < nr_iovecs; i++) {
 804                 page = mempool_alloc(cc->page_pool, gfp_mask);
 805                 if (!page) {
 806                         *out_of_pages = 1;
 807                         break;
 808                 }
 809
 810                 /*
 811                  * If additional pages cannot be allocated without waiting,
 812                  * return a partially-allocated bio.  The caller will then try
 813                  * to allocate more bios while submitting this partial bio.
 814                  */
 815                 gfp_mask = (gfp_mask | __GFP_NOWARN) & ~__GFP_WAIT;
 816
 817                 len = (size > PAGE_SIZE) ? PAGE_SIZE : size;
 818
 819                 if (!bio_add_page(clone, page, len, 0)) {
 820                         mempool_free(page, cc->page_pool);
 821                         break;
 822                 }
 823
 824                 size -= len;
 825         }
 826
 827         if (!clone->bi_size) {
 828                 bio_put(clone);
 829                 return NULL;
 830         }
 831
 832         return clone;
 833 }
 834
 835 static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone)
 836 {
 837         unsigned int i;
 838         struct bio_vec *bv;
 839
 840         bio_for_each_segment_all(bv, clone, i) {
 841                 BUG_ON(!bv->bv_page);
 842                 mempool_free(bv->bv_page, cc->page_pool);
 843                 bv->bv_page = NULL;
 844         }
 845 }
 846
 847 static struct dm_crypt_io *crypt_io_alloc(struct crypt_config *cc,
 848                                           struct bio *bio, sector_t sector)
 849 {
 850         struct dm_crypt_io *io;
 851
 852         io = mempool_alloc(cc->io_pool, GFP_NOIO);
 853         io->cc = cc;
 854         io->base_bio = bio;
 855         io->sector = sector;
 856         io->error = 0;
 857         io->base_io = NULL;
 858         io->ctx.req = NULL;
 859         atomic_set(&io->io_pending, 0);
 860
 861         return io;
 862 }
 863
 864 static void crypt_inc_pending(struct dm_crypt_io *io)
 865 {
 866         atomic_inc(&io->io_pending);
 867 }
 868
 869 /*
 870  * One of the bios was finished. Check for completion of
 871  * the whole request and correctly clean up the buffer.
 872  * If base_io is set, wait for the last fragment to complete.
 873  */
 874 static void crypt_dec_pending(struct dm_crypt_io *io)
 875 {
 876         struct crypt_config *cc = io->cc;
 877         struct bio *base_bio = io->base_bio;
 878         struct dm_crypt_io *base_io = io->base_io;
 879         int error = io->error;
 880
 881         if (!atomic_dec_and_test(&io->io_pending))
 882                 return;
 883
 884         if (io->ctx.req)
 885                 mempool_free(io->ctx.req, cc->req_pool);
 886         mempool_free(io, cc->io_pool);
 887
 888         if (likely(!base_io))
 889                 bio_endio(base_bio, error);
 890         else {
 891                 if (error && !base_io->error)
 892                         base_io->error = error;
 893                 crypt_dec_pending(base_io);
 894         }
 895 }
 896
 897 /*
 898  * kcryptd/kcryptd_io:
 899  *
 900  * Needed because it would be very unwise to do decryption in an
 901  * interrupt context.
 902  *
 903  * kcryptd performs the actual encryption or decryption.
 904  *
 905  * kcryptd_io performs the IO submission.
 906  *
 907  * They must be separated as otherwise the final stages could be
 908  * starved by new requests which can block in the first stages due
 909  * to memory allocation.
 910  *
 911  * The work is done per CPU global for all dm-crypt instances.
 912  * They should not depend on each other and do not block.
 913  */
 914 static void crypt_endio(struct bio *clone, int error)
 915 {
 916         struct dm_crypt_io *io = clone->bi_private;
 917         struct crypt_config *cc = io->cc;
 918         unsigned rw = bio_data_dir(clone);
 919
 920         if (unlikely(!bio_flagged(clone, BIO_UPTODATE) && !error))
 921                 error = -EIO;
 922
 923         /*
 924          * free the processed pages
 925          */
 926         if (rw == WRITE)
 927                 crypt_free_buffer_pages(cc, clone);
 928
 929         bio_put(clone);
 930
 931         if (rw == READ && !error) {
 932                 kcryptd_queue_crypt(io);
 933                 return;
 934         }
 935
 936         if (unlikely(error))
 937                 io->error = error;
 938
 939         crypt_dec_pending(io);
 940 }
 941
 942 static void clone_init(struct dm_crypt_io *io, struct bio *clone)
 943 {
 944         struct crypt_config *cc = io->cc;
 945
 946         clone->bi_private = io;
 947         clone->bi_end_io  = crypt_endio;
 948         clone->bi_bdev    = cc->dev->bdev;
 949         clone->bi_rw      = io->base_bio->bi_rw;
 950 }
 951
 952 static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
 953 {
 954         struct crypt_config *cc = io->cc;
 955         struct bio *base_bio = io->base_bio;
 956         struct bio *clone;
 957
 958         /*
 959          * The block layer might modify the bvec array, so always
 960          * copy the required bvecs because we need the original
 961          * one in order to decrypt the whole bio data *afterwards*.
 962          */
 963         clone = bio_clone_bioset(base_bio, gfp, cc->bs);
 964         if (!clone)
 965                 return 1;
 966
 967         crypt_inc_pending(io);
 968
 969         clone_init(io, clone);
 970         clone->bi_sector = cc->start + io->sector;
 971
 972         generic_make_request(clone);
 973         return 0;
 974 }
 975
 976 static void kcryptd_io_write(struct dm_crypt_io *io)
 977 {
 978         struct bio *clone = io->ctx.bio_out;
 979         generic_make_request(clone);
 980 }
 981
 982 static void kcryptd_io(struct work_struct *work)
 983 {
 984         struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
 985
 986         if (bio_data_dir(io->base_bio) == READ) {
 987                 crypt_inc_pending(io);
 988                 if (kcryptd_io_read(io, GFP_NOIO))
 989                         io->error = -ENOMEM;
 990                 crypt_dec_pending(io);
 991         } else
 992                 kcryptd_io_write(io);
 993 }
 994
 995 static void kcryptd_queue_io(struct dm_crypt_io *io)
 996 {
 997         struct crypt_config *cc = io->cc;
 998
 999         INIT_WORK(&io->work, kcryptd_io);
1000         queue_work(cc->io_queue, &io->work);
1001 }
1002
1003 static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int async)
1004 {
1005         struct bio *clone = io->ctx.bio_out;
1006         struct crypt_config *cc = io->cc;
1007
1008         if (unlikely(io->error < 0)) {
1009                 crypt_free_buffer_pages(cc, clone);
1010                 bio_put(clone);
1011                 crypt_dec_pending(io);
1012                 return;
1013         }
1014
1015         /* crypt_convert should have filled the clone bio */
1016         BUG_ON(io->ctx.idx_out < clone->bi_vcnt);
1017
1018         clone->bi_sector = cc->start + io->sector;
1019
1020         if (async)
1021                 kcryptd_queue_io(io);
1022         else
1023                 generic_make_request(clone);
1024 }
1025
1026 static void kcryptd_crypt_write_convert(struct dm_crypt_io *io)
1027 {
1028         struct crypt_config *cc = io->cc;
1029         struct bio *clone;
1030         struct dm_crypt_io *new_io;
1031         int crypt_finished;
1032         unsigned out_of_pages = 0;
1033         unsigned remaining = io->base_bio->bi_size;
1034         sector_t sector = io->sector;
1035         int r;
1036
1037         /*
1038          * Prevent io from disappearing until this function completes.
1039          */
1040         crypt_inc_pending(io);
1041         crypt_convert_init(cc, &io->ctx, NULL, io->base_bio, sector);
1042
1043         /*
1044          * The allocated buffers can be smaller than the whole bio,
1045          * so repeat the whole process until all the data can be handled.
1046          */
1047         while (remaining) {
1048                 clone = crypt_alloc_buffer(io, remaining, &out_of_pages);
1049                 if (unlikely(!clone)) {
1050                         io->error = -ENOMEM;
1051                         break;
1052                 }
1053
1054                 io->ctx.bio_out = clone;
1055                 io->ctx.idx_out = 0;
1056
1057                 remaining -= clone->bi_size;
1058                 sector += bio_sectors(clone);
1059
1060                 crypt_inc_pending(io);
1061
1062                 r = crypt_convert(cc, &io->ctx);
1063                 if (r < 0)
1064                         io->error = -EIO;
1065
1066                 crypt_finished = atomic_dec_and_test(&io->ctx.cc_pending);
1067
1068                 /* Encryption was already finished, submit io now */
1069                 if (crypt_finished) {
1070                         kcryptd_crypt_write_io_submit(io, 0);
1071
1072                         /*
1073                          * If there was an error, do not try next fragments.
1074                          * For async, error is processed in async handler.
1075                          */
1076                         if (unlikely(r < 0))
1077                                 break;
1078
1079                         io->sector = sector;
1080                 }
1081
1082                 /*
1083                  * Out of memory -> run queues
1084                  * But don't wait if split was due to the io size restriction
1085                  */
1086                 if (unlikely(out_of_pages))
1087                         congestion_wait(BLK_RW_ASYNC, HZ/100);
1088
1089                 /*
1090                  * With async crypto it is unsafe to share the crypto context
1091                  * between fragments, so switch to a new dm_crypt_io structure.
1092                  */
1093                 if (unlikely(!crypt_finished && remaining)) {
1094                         new_io = crypt_io_alloc(io->cc, io->base_bio,
1095                                                 sector);
1096                         crypt_inc_pending(new_io);
1097                         crypt_convert_init(cc, &new_io->ctx, NULL,
1098                                            io->base_bio, sector);
1099                         new_io->ctx.idx_in = io->ctx.idx_in;
1100                         new_io->ctx.offset_in = io->ctx.offset_in;
1101
1102                         /*
1103                          * Fragments after the first use the base_io
1104                          * pending count.
1105                          */
1106                         if (!io->base_io)
1107                                 new_io->base_io = io;
1108                         else {
1109                                 new_io->base_io = io->base_io;
1110                                 crypt_inc_pending(io->base_io);
1111                                 crypt_dec_pending(io);
1112                         }
1113
1114                         io = new_io;
1115                 }
1116         }
1117
1118         crypt_dec_pending(io);
1119 }
1120
1121 static void kcryptd_crypt_read_done(struct dm_crypt_io *io)
1122 {
1123         crypt_dec_pending(io);
1124 }
1125
1126 static void kcryptd_crypt_read_convert(struct dm_crypt_io *io)
1127 {
1128         struct crypt_config *cc = io->cc;
1129         int r = 0;
1130
1131         crypt_inc_pending(io);
1132
1133         crypt_convert_init(cc, &io->ctx, io->base_bio, io->base_bio,
1134                            io->sector);
1135
1136         r = crypt_convert(cc, &io->ctx);
1137         if (r < 0)
1138                 io->error = -EIO;
1139
1140         if (atomic_dec_and_test(&io->ctx.cc_pending))
1141                 kcryptd_crypt_read_done(io);
1142
1143         crypt_dec_pending(io);
1144 }
1145
1146 static void kcryptd_async_done(struct crypto_async_request *async_req,
1147                                int error)
1148 {
1149         struct dm_crypt_request *dmreq = async_req->data;
1150         struct convert_context *ctx = dmreq->ctx;
1151         struct dm_crypt_io *io = container_of(ctx, struct dm_crypt_io, ctx);
1152         struct crypt_config *cc = io->cc;
1153
1154         if (error == -EINPROGRESS) {
1155                 complete(&ctx->restart);
1156                 return;
1157         }
1158
1159         if (!error && cc->iv_gen_ops && cc->iv_gen_ops->post)
1160                 error = cc->iv_gen_ops->post(cc, iv_of_dmreq(cc, dmreq), dmreq);
1161
1162         if (error < 0)
1163                 io->error = -EIO;
1164
1165         mempool_free(req_of_dmreq(cc, dmreq), cc->req_pool);
1166
1167         if (!atomic_dec_and_test(&ctx->cc_pending))
1168                 return;
1169
1170         if (bio_data_dir(io->base_bio) == READ)
1171                 kcryptd_crypt_read_done(io);
1172         else
1173                 kcryptd_crypt_write_io_submit(io, 1);
1174 }
1175
1176 static void kcryptd_crypt(struct work_struct *work)
1177 {
1178         struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
1179
1180         if (bio_data_dir(io->base_bio) == READ)
1181                 kcryptd_crypt_read_convert(io);
1182         else
1183                 kcryptd_crypt_write_convert(io);
1184 }
1185
1186 static void kcryptd_queue_crypt(struct dm_crypt_io *io)
1187 {
1188         struct crypt_config *cc = io->cc;
1189
1190         INIT_WORK(&io->work, kcryptd_crypt);
1191         queue_work(cc->crypt_queue, &io->work);
1192 }
1193
1194 /*
1195  * Decode key from its hex representation
1196  */
1197 static int crypt_decode_key(u8 *key, char *hex, unsigned int size)
1198 {
1199         char buffer[3];
1200         unsigned int i;
1201
1202         buffer[2] = '\0';
1203
1204         for (i = 0; i < size; i++) {
1205                 buffer[0] = *hex++;
1206                 buffer[1] = *hex++;
1207
1208                 if (kstrtou8(buffer, 16, &key[i]))
1209                         return -EINVAL;
1210         }
1211
1212         if (*hex != '\0')
1213                 return -EINVAL;
1214
1215         return 0;
1216 }
1217
1218 static void crypt_free_tfms(struct crypt_config *cc)
1219 {
1220         unsigned i;
1221
1222         if (!cc->tfms)
1223                 return;
1224
1225         for (i = 0; i < cc->tfms_count; i++)
1226                 if (cc->tfms[i] && !IS_ERR(cc->tfms[i])) {
1227                         crypto_free_ablkcipher(cc->tfms[i]);
1228                         cc->tfms[i] = NULL;
1229                 }
1230
1231         kfree(cc->tfms);
1232         cc->tfms = NULL;
1233 }
1234
1235 static int crypt_alloc_tfms(struct crypt_config *cc, char *ciphermode)
1236 {
1237         unsigned i;
1238         int err;
1239
1240         cc->tfms = kmalloc(cc->tfms_count * sizeof(struct crypto_ablkcipher *),
1241                            GFP_KERNEL);
1242         if (!cc->tfms)
1243                 return -ENOMEM;
1244
1245         for (i = 0; i < cc->tfms_count; i++) {
1246                 cc->tfms[i] = crypto_alloc_ablkcipher(ciphermode, 0, 0);
1247                 if (IS_ERR(cc->tfms[i])) {
1248                         err = PTR_ERR(cc->tfms[i]);
1249                         crypt_free_tfms(cc);
1250                         return err;
1251                 }
1252         }
1253
1254         return 0;
1255 }
1256
1257 static int crypt_setkey_allcpus(struct crypt_config *cc)
1258 {
1259         unsigned subkey_size = cc->key_size >> ilog2(cc->tfms_count);
1260         int err = 0, i, r;
1261
1262         for (i = 0; i < cc->tfms_count; i++) {
1263                 r = crypto_ablkcipher_setkey(cc->tfms[i],
1264                                              cc->key + (i * subkey_size),
1265                                              subkey_size);
1266                 if (r)
1267                         err = r;
1268         }
1269
1270         return err;
1271 }
1272
1273 static int crypt_set_key(struct crypt_config *cc, char *key)
1274 {
1275         int r = -EINVAL;
1276         int key_string_len = strlen(key);
1277
1278         /* The key size may not be changed. */
1279         if (cc->key_size != (key_string_len >> 1))
1280                 goto out;
1281
1282         /* Hyphen (which gives a key_size of zero) means there is no key. */
1283         if (!cc->key_size && strcmp(key, "-"))
1284                 goto out;
1285
1286         if (cc->key_size && crypt_decode_key(cc->key, key, cc->key_size) < 0)
1287                 goto out;
1288
1289         set_bit(DM_CRYPT_KEY_VALID, &cc->flags);
1290
1291         r = crypt_setkey_allcpus(cc);
1292
1293 out:
1294         /* Hex key string not needed after here, so wipe it. */
1295         memset(key, '0', key_string_len);
1296
1297         return r;
1298 }
1299
1300 static int crypt_wipe_key(struct crypt_config *cc)
1301 {
1302         clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
1303         memset(&cc->key, 0, cc->key_size * sizeof(u8));
1304
1305         return crypt_setkey_allcpus(cc);
1306 }
1307
1308 static void crypt_dtr(struct dm_target *ti)
1309 {
1310         struct crypt_config *cc = ti->private;
1311
1312         ti->private = NULL;
1313
1314         if (!cc)
1315                 return;
1316
1317         if (cc->io_queue)
1318                 destroy_workqueue(cc->io_queue);
1319         if (cc->crypt_queue)
1320                 destroy_workqueue(cc->crypt_queue);
1321
1322         crypt_free_tfms(cc);
1323
1324         if (cc->bs)
1325                 bioset_free(cc->bs);
1326
1327         if (cc->page_pool)
1328                 mempool_destroy(cc->page_pool);
1329         if (cc->req_pool)
1330                 mempool_destroy(cc->req_pool);
1331         if (cc->io_pool)
1332                 mempool_destroy(cc->io_pool);
1333
1334         if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
1335                 cc->iv_gen_ops->dtr(cc);
1336
1337         if (cc->dev)
1338                 dm_put_device(ti, cc->dev);
1339
1340         kzfree(cc->cipher);
1341         kzfree(cc->cipher_string);
1342
1343         /* Must zero key material before freeing */
1344         kzfree(cc);
1345 }
1346
1347 static int crypt_ctr_cipher(struct dm_target *ti,
1348                             char *cipher_in, char *key)
1349 {
1350         struct crypt_config *cc = ti->private;
1351         char *tmp, *cipher, *chainmode, *ivmode, *ivopts, *keycount;
1352         char *cipher_api = NULL;
1353         int ret = -EINVAL;
1354         char dummy;
1355
1356         /* Convert to crypto api definition? */
1357         if (strchr(cipher_in, '(')) {
1358                 ti->error = "Bad cipher specification";
1359                 return -EINVAL;
1360         }
1361
1362         cc->cipher_string = kstrdup(cipher_in, GFP_KERNEL);
1363         if (!cc->cipher_string)
1364                 goto bad_mem;
1365
1366         /*
1367          * Legacy dm-crypt cipher specification
1368          * cipher[:keycount]-mode-iv:ivopts
1369          */
1370         tmp = cipher_in;
1371         keycount = strsep(&tmp, "-");
1372         cipher = strsep(&keycount, ":");
1373
1374         if (!keycount)
1375                 cc->tfms_count = 1;
1376         else if (sscanf(keycount, "%u%c", &cc->tfms_count, &dummy) != 1 ||
1377                  !is_power_of_2(cc->tfms_count)) {
1378                 ti->error = "Bad cipher key count specification";
1379                 return -EINVAL;
1380         }
1381         cc->key_parts = cc->tfms_count;
1382
1383         cc->cipher = kstrdup(cipher, GFP_KERNEL);
1384         if (!cc->cipher)
1385                 goto bad_mem;
1386
1387         chainmode = strsep(&tmp, "-");
1388         ivopts = strsep(&tmp, "-");
1389         ivmode = strsep(&ivopts, ":");
1390
1391         if (tmp)
1392                 DMWARN("Ignoring unexpected additional cipher options");
1393
1394         /*
1395          * For compatibility with the original dm-crypt mapping format, if
1396          * only the cipher name is supplied, use cbc-plain.
1397          */
1398         if (!chainmode || (!strcmp(chainmode, "plain") && !ivmode)) {
1399                 chainmode = "cbc";
1400                 ivmode = "plain";
1401         }
1402
1403         if (strcmp(chainmode, "ecb") && !ivmode) {
1404                 ti->error = "IV mechanism required";
1405                 return -EINVAL;
1406         }
1407
1408         cipher_api = kmalloc(CRYPTO_MAX_ALG_NAME, GFP_KERNEL);
1409         if (!cipher_api)
1410                 goto bad_mem;
1411
1412         ret = snprintf(cipher_api, CRYPTO_MAX_ALG_NAME,
1413                        "%s(%s)", chainmode, cipher);
1414         if (ret < 0) {
1415                 kfree(cipher_api);
1416                 goto bad_mem;
1417         }
1418
1419         /* Allocate cipher */
1420         ret = crypt_alloc_tfms(cc, cipher_api);
1421         if (ret < 0) {
1422                 ti->error = "Error allocating crypto tfm";
1423                 goto bad;
1424         }
1425
1426         /* Initialize and set key */
1427         ret = crypt_set_key(cc, key);
1428         if (ret < 0) {
1429                 ti->error = "Error decoding and setting key";
1430                 goto bad;
1431         }
1432
1433         /* Initialize IV */
1434         cc->iv_size = crypto_ablkcipher_ivsize(any_tfm(cc));
1435         if (cc->iv_size)
1436                 /* at least a 64 bit sector number should fit in our buffer */
1437                 cc->iv_size = max(cc->iv_size,
1438                                   (unsigned int)(sizeof(u64) / sizeof(u8)));
1439         else if (ivmode) {
1440                 DMWARN("Selected cipher does not support IVs");
1441                 ivmode = NULL;
1442         }
1443
1444         /* Choose ivmode, see comments at iv code. */
1445         if (ivmode == NULL)
1446                 cc->iv_gen_ops = NULL;
1447         else if (strcmp(ivmode, "plain") == 0)
1448                 cc->iv_gen_ops = &crypt_iv_plain_ops;
1449         else if (strcmp(ivmode, "plain64") == 0)
1450                 cc->iv_gen_ops = &crypt_iv_plain64_ops;
1451         else if (strcmp(ivmode, "essiv") == 0)
1452                 cc->iv_gen_ops = &crypt_iv_essiv_ops;
1453         else if (strcmp(ivmode, "benbi") == 0)
1454                 cc->iv_gen_ops = &crypt_iv_benbi_ops;
1455         else if (strcmp(ivmode, "null") == 0)
1456                 cc->iv_gen_ops = &crypt_iv_null_ops;
1457         else if (strcmp(ivmode, "lmk") == 0) {
1458                 cc->iv_gen_ops = &crypt_iv_lmk_ops;
1459                 /* Version 2 and 3 is recognised according
1460                  * to length of provided multi-key string.
1461                  * If present (version 3), last key is used as IV seed.
1462                  */
1463                 if (cc->key_size % cc->key_parts)
1464                         cc->key_parts++;
1465         } else {
1466                 ret = -EINVAL;
1467                 ti->error = "Invalid IV mode";
1468                 goto bad;
1469         }
1470
1471         /* Allocate IV */
1472         if (cc->iv_gen_ops && cc->iv_gen_ops->ctr) {
1473                 ret = cc->iv_gen_ops->ctr(cc, ti, ivopts);
1474                 if (ret < 0) {
1475                         ti->error = "Error creating IV";
1476                         goto bad;
1477                 }
1478         }
1479
1480         /* Initialize IV (set keys for ESSIV etc) */
1481         if (cc->iv_gen_ops && cc->iv_gen_ops->init) {
1482                 ret = cc->iv_gen_ops->init(cc);
1483                 if (ret < 0) {
1484                         ti->error = "Error initialising IV";
1485                         goto bad;
1486                 }
1487         }
1488
1489         ret = 0;
1490 bad:
1491         kfree(cipher_api);
1492         return ret;
1493
1494 bad_mem:
1495         ti->error = "Cannot allocate cipher strings";
1496         return -ENOMEM;
1497 }
1498
1499 /*
1500  * Construct an encryption mapping:
1501  * <cipher> <key> <iv_offset> <dev_path> <start>
1502  */
1503 static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
1504 {
1505         struct crypt_config *cc;
1506         unsigned int key_size, opt_params;
1507         unsigned long long tmpll;
1508         int ret;
1509         struct dm_arg_set as;
1510         const char *opt_string;
1511         char dummy;
1512
1513         static struct dm_arg _args[] = {
1514                 {0, 1, "Invalid number of feature args"},
1515         };
1516
1517         if (argc < 5) {
1518                 ti->error = "Not enough arguments";
1519                 return -EINVAL;
1520         }
1521
1522         key_size = strlen(argv[1]) >> 1;
1523
1524         cc = kzalloc(sizeof(*cc) + key_size * sizeof(u8), GFP_KERNEL);
1525         if (!cc) {
1526                 ti->error = "Cannot allocate encryption context";
1527                 return -ENOMEM;
1528         }
1529         cc->key_size = key_size;
1530
1531         ti->private = cc;
1532         ret = crypt_ctr_cipher(ti, argv[0], argv[1]);
1533         if (ret < 0)
1534                 goto bad;
1535
1536         ret = -ENOMEM;
1537         cc->io_pool = mempool_create_slab_pool(MIN_IOS, _crypt_io_pool);
1538         if (!cc->io_pool) {
1539                 ti->error = "Cannot allocate crypt io mempool";
1540                 goto bad;
1541         }
1542
1543         cc->dmreq_start = sizeof(struct ablkcipher_request);
1544         cc->dmreq_start += crypto_ablkcipher_reqsize(any_tfm(cc));
1545         cc->dmreq_start = ALIGN(cc->dmreq_start, crypto_tfm_ctx_alignment());
1546         cc->dmreq_start += crypto_ablkcipher_alignmask(any_tfm(cc)) &
1547                            ~(crypto_tfm_ctx_alignment() - 1);
1548
1549         cc->req_pool = mempool_create_kmalloc_pool(MIN_IOS, cc->dmreq_start +
1550                         sizeof(struct dm_crypt_request) + cc->iv_size);
1551         if (!cc->req_pool) {
1552                 ti->error = "Cannot allocate crypt request mempool";
1553                 goto bad;
1554         }
1555
1556         cc->page_pool = mempool_create_page_pool(MIN_POOL_PAGES, 0);
1557         if (!cc->page_pool) {
1558                 ti->error = "Cannot allocate page mempool";
1559                 goto bad;
1560         }
1561
1562         cc->bs = bioset_create(MIN_IOS, 0);
1563         if (!cc->bs) {
1564                 ti->error = "Cannot allocate crypt bioset";
1565                 goto bad;
1566         }
1567
1568         ret = -EINVAL;
1569         if (sscanf(argv[2], "%llu%c", &tmpll, &dummy) != 1) {
1570                 ti->error = "Invalid iv_offset sector";
1571                 goto bad;
1572         }
1573         cc->iv_offset = tmpll;
1574
1575         if (dm_get_device(ti, argv[3], dm_table_get_mode(ti->table), &cc->dev)) {
1576                 ti->error = "Device lookup failed";
1577                 goto bad;
1578         }
1579
1580         if (sscanf(argv[4], "%llu%c", &tmpll, &dummy) != 1) {
1581                 ti->error = "Invalid device sector";
1582                 goto bad;
1583         }
1584         cc->start = tmpll;
1585
1586         argv += 5;
1587         argc -= 5;
1588
1589         /* Optional parameters */
1590         if (argc) {
1591                 as.argc = argc;
1592                 as.argv = argv;
1593
1594                 ret = dm_read_arg_group(_args, &as, &opt_params, &ti->error);
1595                 if (ret)
1596                         goto bad;
1597
1598                 opt_string = dm_shift_arg(&as);
1599
1600                 if (opt_params == 1 && opt_string &&
1601                     !strcasecmp(opt_string, "allow_discards"))
1602                         ti->num_discard_bios = 1;
1603                 else if (opt_params) {
1604                         ret = -EINVAL;
1605                         ti->error = "Invalid feature arguments";
1606                         goto bad;
1607                 }
1608         }
1609
1610         ret = -ENOMEM;
1611         cc->io_queue = alloc_workqueue("kcryptd_io",
1612                                        WQ_NON_REENTRANT|
1613                                        WQ_MEM_RECLAIM,
1614                                        1);
1615         if (!cc->io_queue) {
1616                 ti->error = "Couldn't create kcryptd io queue";
1617                 goto bad;
1618         }
1619
1620         cc->crypt_queue = alloc_workqueue("kcryptd",
1621                                           WQ_NON_REENTRANT|
1622                                           WQ_CPU_INTENSIVE|
1623                                           WQ_MEM_RECLAIM,
1624                                           1);
1625         if (!cc->crypt_queue) {
1626                 ti->error = "Couldn't create kcryptd queue";
1627                 goto bad;
1628         }
1629
1630         ti->num_flush_bios = 1;
1631         ti->discard_zeroes_data_unsupported = true;
1632
1633         return 0;
1634
1635 bad:
1636         crypt_dtr(ti);
1637         return ret;
1638 }
1639
1640 static int crypt_map(struct dm_target *ti, struct bio *bio)
1641 {
1642         struct dm_crypt_io *io;
1643         struct crypt_config *cc = ti->private;
1644
1645         /*
1646          * If bio is REQ_FLUSH or REQ_DISCARD, just bypass crypt queues.
1647          * - for REQ_FLUSH device-mapper core ensures that no IO is in-flight
1648          * - for REQ_DISCARD caller must use flush if IO ordering matters
1649          */
1650         if (unlikely(bio->bi_rw & (REQ_FLUSH | REQ_DISCARD))) {
1651                 bio->bi_bdev = cc->dev->bdev;
1652                 if (bio_sectors(bio))
1653                         bio->bi_sector = cc->start + dm_target_offset(ti, bio->bi_sector);
1654                 return DM_MAPIO_REMAPPED;
1655         }
1656
1657         io = crypt_io_alloc(cc, bio, dm_target_offset(ti, bio->bi_sector));
1658
1659         if (bio_data_dir(io->base_bio) == READ) {
1660                 if (kcryptd_io_read(io, GFP_NOWAIT))
1661                         kcryptd_queue_io(io);
1662         } else
1663                 kcryptd_queue_crypt(io);
1664
1665         return DM_MAPIO_SUBMITTED;
1666 }
1667
1668 static void crypt_status(struct dm_target *ti, status_type_t type,
1669                          unsigned status_flags, char *result, unsigned maxlen)
1670 {
1671         struct crypt_config *cc = ti->private;
1672         unsigned i, sz = 0;
1673
1674         switch (type) {
1675         case STATUSTYPE_INFO:
1676                 result[0] = '\0';
1677                 break;
1678
1679         case STATUSTYPE_TABLE:
1680                 DMEMIT("%s ", cc->cipher_string);
1681
1682                 if (cc->key_size > 0)
1683                         for (i = 0; i < cc->key_size; i++)
1684                                 DMEMIT("%02x", cc->key[i]);
1685                 else
1686                         DMEMIT("-");
1687
1688                 DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
1689                                 cc->dev->name, (unsigned long long)cc->start);
1690
1691                 if (ti->num_discard_bios)
1692                         DMEMIT(" 1 allow_discards");
1693
1694                 break;
1695         }
1696 }
1697
1698 static void crypt_postsuspend(struct dm_target *ti)
1699 {
1700         struct crypt_config *cc = ti->private;
1701
1702         set_bit(DM_CRYPT_SUSPENDED, &cc->flags);
1703 }
1704
1705 static int crypt_preresume(struct dm_target *ti)
1706 {
1707         struct crypt_config *cc = ti->private;
1708
1709         if (!test_bit(DM_CRYPT_KEY_VALID, &cc->flags)) {
1710                 DMERR("aborting resume - crypt key is not set.");
1711                 return -EAGAIN;
1712         }
1713
1714         return 0;
1715 }
1716
1717 static void crypt_resume(struct dm_target *ti)
1718 {
1719         struct crypt_config *cc = ti->private;
1720
1721         clear_bit(DM_CRYPT_SUSPENDED, &cc->flags);
1722 }
1723
1724 /* Message interface
1725  *      key set <key>
1726  *      key wipe
1727  */
1728 static int crypt_message(struct dm_target *ti, unsigned argc, char **argv)
1729 {
1730         struct crypt_config *cc = ti->private;
1731         int ret = -EINVAL;
1732
1733         if (argc < 2)
1734                 goto error;
1735
1736         if (!strcasecmp(argv[0], "key")) {
1737                 if (!test_bit(DM_CRYPT_SUSPENDED, &cc->flags)) {
1738                         DMWARN("not suspended during key manipulation.");
1739                         return -EINVAL;
1740                 }
1741                 if (argc == 3 && !strcasecmp(argv[1], "set")) {
1742                         ret = crypt_set_key(cc, argv[2]);
1743                         if (ret)
1744                                 return ret;
1745                         if (cc->iv_gen_ops && cc->iv_gen_ops->init)
1746                                 ret = cc->iv_gen_ops->init(cc);
1747                         return ret;
1748                 }
1749                 if (argc == 2 && !strcasecmp(argv[1], "wipe")) {
1750                         if (cc->iv_gen_ops && cc->iv_gen_ops->wipe) {
1751                                 ret = cc->iv_gen_ops->wipe(cc);
1752                                 if (ret)
1753                                         return ret;
1754                         }
1755                         return crypt_wipe_key(cc);
1756                 }
1757         }
1758
1759 error:
1760         DMWARN("unrecognised message received.");
1761         return -EINVAL;
1762 }
1763
1764 static int crypt_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
1765                        struct bio_vec *biovec, int max_size)
1766 {
1767         struct crypt_config *cc = ti->private;
1768         struct request_queue *q = bdev_get_queue(cc->dev->bdev);
1769
1770         if (!q->merge_bvec_fn)
1771                 return max_size;
1772
1773         bvm->bi_bdev = cc->dev->bdev;
1774         bvm->bi_sector = cc->start + dm_target_offset(ti, bvm->bi_sector);
1775
1776         return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
1777 }
1778
1779 static int crypt_iterate_devices(struct dm_target *ti,
1780                                  iterate_devices_callout_fn fn, void *data)
1781 {
1782         struct crypt_config *cc = ti->private;
1783
1784         return fn(ti, cc->dev, cc->start, ti->len, data);
1785 }
1786
1787 static struct target_type crypt_target = {
1788         .name   = "crypt",
1789         .version = {1, 12, 1},
1790         .module = THIS_MODULE,
1791         .ctr    = crypt_ctr,
1792         .dtr    = crypt_dtr,
1793         .map    = crypt_map,
1794         .status = crypt_status,
1795         .postsuspend = crypt_postsuspend,
1796         .preresume = crypt_preresume,
1797         .resume = crypt_resume,
1798         .message = crypt_message,
1799         .merge  = crypt_merge,
1800         .iterate_devices = crypt_iterate_devices,
1801 };
1802
1803 static int __init dm_crypt_init(void)
1804 {
1805         int r;
1806
1807         _crypt_io_pool = KMEM_CACHE(dm_crypt_io, 0);
1808         if (!_crypt_io_pool)
1809                 return -ENOMEM;
1810
1811         r = dm_register_target(&crypt_target);
1812         if (r < 0) {
1813                 DMERR("register failed %d", r);
1814                 kmem_cache_destroy(_crypt_io_pool);
1815         }
1816
1817         return r;
1818 }
1819
1820 static void __exit dm_crypt_exit(void)
1821 {
1822         dm_unregister_target(&crypt_target);
1823         kmem_cache_destroy(_crypt_io_pool);
1824 }
1825
1826 module_init(dm_crypt_init);
1827 module_exit(dm_crypt_exit);
1828
1829 MODULE_AUTHOR("Christophe Saout <christophe@saout.de>");
1830 MODULE_DESCRIPTION(DM_NAME " target for transparent encryption / decryption");
1831 MODULE_LICENSE("GPL");