drivers/md/dm-crypt.c

   1 /*
   2  * Copyright (C) 2003 Jana Saout <jana@saout.de>
   3  * Copyright (C) 2004 Clemens Fruhwirth <clemens@endorphin.org>
   4  * Copyright (C) 2006-2017 Red Hat, Inc. All rights reserved.
   5  * Copyright (C) 2013-2017 Milan Broz <gmazyland@gmail.com>
   6  *
   7  * This file is released under the GPL.
   8  */
   9
  10 #include <linux/completion.h>
  11 #include <linux/err.h>
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15 #include <linux/key.h>
  16 #include <linux/bio.h>
  17 #include <linux/blkdev.h>
  18 #include <linux/mempool.h>
  19 #include <linux/slab.h>
  20 #include <linux/crypto.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/kthread.h>
  23 #include <linux/backing-dev.h>
  24 #include <linux/atomic.h>
  25 #include <linux/scatterlist.h>
  26 #include <linux/rbtree.h>
  27 #include <linux/ctype.h>
  28 #include <asm/page.h>
  29 #include <asm/unaligned.h>
  30 #include <crypto/hash.h>
  31 #include <crypto/md5.h>
  32 #include <crypto/algapi.h>
  33 #include <crypto/skcipher.h>
  34 #include <crypto/aead.h>
  35 #include <crypto/authenc.h>
  36 #include <linux/rtnetlink.h> /* for struct rtattr and RTA macros only */
  37 #include <keys/user-type.h>
  38
  39 #include <linux/device-mapper.h>
  40
  41 #define DM_MSG_PREFIX "crypt"
  42
  43 /*
  44  * context holding the current state of a multi-part conversion
  45  */
  46 struct convert_context {
  47         struct completion restart;
  48         struct bio *bio_in;
  49         struct bio *bio_out;
  50         struct bvec_iter iter_in;
  51         struct bvec_iter iter_out;
  52         u64 cc_sector;
  53         atomic_t cc_pending;
  54         union {
  55                 struct skcipher_request *req;
  56                 struct aead_request *req_aead;
  57         } r;
  58
  59 };
  60
  61 /*
  62  * per bio private data
  63  */
  64 struct dm_crypt_io {
  65         struct crypt_config *cc;
  66         struct bio *base_bio;
  67         u8 *integrity_metadata;
  68         bool integrity_metadata_from_pool;
  69         struct work_struct work;
  70
  71         struct convert_context ctx;
  72
  73         atomic_t io_pending;
  74         blk_status_t error;
  75         sector_t sector;
  76
  77         struct rb_node rb_node;
  78 } CRYPTO_MINALIGN_ATTR;
  79
  80 struct dm_crypt_request {
  81         struct convert_context *ctx;
  82         struct scatterlist sg_in[4];
  83         struct scatterlist sg_out[4];
  84         u64 iv_sector;
  85 };
  86
  87 struct crypt_config;
  88
  89 struct crypt_iv_operations {
  90         int (*ctr)(struct crypt_config *cc, struct dm_target *ti,
  91                    const char *opts);
  92         void (*dtr)(struct crypt_config *cc);
  93         int (*init)(struct crypt_config *cc);
  94         int (*wipe)(struct crypt_config *cc);
  95         int (*generator)(struct crypt_config *cc, u8 *iv,
  96                          struct dm_crypt_request *dmreq);
  97         int (*post)(struct crypt_config *cc, u8 *iv,
  98                     struct dm_crypt_request *dmreq);
  99 };
 100
 101 struct iv_essiv_private {
 102         struct crypto_ahash *hash_tfm;
 103         u8 *salt;
 104 };
 105
 106 struct iv_benbi_private {
 107         int shift;
 108 };
 109
 110 #define LMK_SEED_SIZE 64 /* hash + 0 */
 111 struct iv_lmk_private {
 112         struct crypto_shash *hash_tfm;
 113         u8 *seed;
 114 };
 115
 116 #define TCW_WHITENING_SIZE 16
 117 struct iv_tcw_private {
 118         struct crypto_shash *crc32_tfm;
 119         u8 *iv_seed;
 120         u8 *whitening;
 121 };
 122
 123 /*
 124  * Crypt: maps a linear range of a block device
 125  * and encrypts / decrypts at the same time.
 126  */
 127 enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID,
 128              DM_CRYPT_SAME_CPU, DM_CRYPT_NO_OFFLOAD };
 129
 130 enum cipher_flags {
 131         CRYPT_MODE_INTEGRITY_AEAD,      /* Use authenticated mode for cihper */
 132         CRYPT_IV_LARGE_SECTORS,         /* Calculate IV from sector_size, not 512B sectors */
 133 };
 134
 135 /*
 136  * The fields in here must be read only after initialization.
 137  */
 138 struct crypt_config {
 139         struct dm_dev *dev;
 140         sector_t start;
 141
 142         /*
 143          * pool for per bio private data, crypto requests,
 144          * encryption requeusts/buffer pages and integrity tags
 145          */
 146         mempool_t *req_pool;
 147         mempool_t *page_pool;
 148         mempool_t *tag_pool;
 149         unsigned tag_pool_max_sectors;
 150
 151         struct percpu_counter n_allocated_pages;
 152
 153         struct bio_set *bs;
 154         struct mutex bio_alloc_lock;
 155
 156         struct workqueue_struct *io_queue;
 157         struct workqueue_struct *crypt_queue;
 158
 159         struct task_struct *write_thread;
 160         wait_queue_head_t write_thread_wait;
 161         struct rb_root write_tree;
 162
 163         char *cipher;
 164         char *cipher_string;
 165         char *cipher_auth;
 166         char *key_string;
 167
 168         const struct crypt_iv_operations *iv_gen_ops;
 169         union {
 170                 struct iv_essiv_private essiv;
 171                 struct iv_benbi_private benbi;
 172                 struct iv_lmk_private lmk;
 173                 struct iv_tcw_private tcw;
 174         } iv_gen_private;
 175         u64 iv_offset;
 176         unsigned int iv_size;
 177         unsigned short int sector_size;
 178         unsigned char sector_shift;
 179
 180         /* ESSIV: struct crypto_cipher *essiv_tfm */
 181         void *iv_private;
 182         union {
 183                 struct crypto_skcipher **tfms;
 184                 struct crypto_aead **tfms_aead;
 185         } cipher_tfm;
 186         unsigned tfms_count;
 187         unsigned long cipher_flags;
 188
 189         /*
 190          * Layout of each crypto request:
 191          *
 192          *   struct skcipher_request
 193          *      context
 194          *      padding
 195          *   struct dm_crypt_request
 196          *      padding
 197          *   IV
 198          *
 199          * The padding is added so that dm_crypt_request and the IV are
 200          * correctly aligned.
 201          */
 202         unsigned int dmreq_start;
 203
 204         unsigned int per_bio_data_size;
 205
 206         unsigned long flags;
 207         unsigned int key_size;
 208         unsigned int key_parts;      /* independent parts in key buffer */
 209         unsigned int key_extra_size; /* additional keys length */
 210         unsigned int key_mac_size;   /* MAC key size for authenc(...) */
 211
 212         unsigned int integrity_tag_size;
 213         unsigned int integrity_iv_size;
 214         unsigned int on_disk_tag_size;
 215
 216         u8 *authenc_key; /* space for keys in authenc() format (if used) */
 217         u8 key[0];
 218 };
 219
 220 #define MIN_IOS         64
 221 #define MAX_TAG_SIZE    480
 222 #define POOL_ENTRY_SIZE 512
 223
 224 static DEFINE_SPINLOCK(dm_crypt_clients_lock);
 225 static unsigned dm_crypt_clients_n = 0;
 226 static volatile unsigned long dm_crypt_pages_per_client;
 227 #define DM_CRYPT_MEMORY_PERCENT                 2
 228 #define DM_CRYPT_MIN_PAGES_PER_CLIENT           (BIO_MAX_PAGES * 16)
 229
 230 static void clone_init(struct dm_crypt_io *, struct bio *);
 231 static void kcryptd_queue_crypt(struct dm_crypt_io *io);
 232 static struct scatterlist *crypt_get_sg_data(struct crypt_config *cc,
 233                                              struct scatterlist *sg);
 234
 235 /*
 236  * Use this to access cipher attributes that are independent of the key.
 237  */
 238 static struct crypto_skcipher *any_tfm(struct crypt_config *cc)
 239 {
 240         return cc->cipher_tfm.tfms[0];
 241 }
 242
 243 static struct crypto_aead *any_tfm_aead(struct crypt_config *cc)
 244 {
 245         return cc->cipher_tfm.tfms_aead[0];
 246 }
 247
 248 /*
 249  * Different IV generation algorithms:
 250  *
 251  * plain: the initial vector is the 32-bit little-endian version of the sector
 252  *        number, padded with zeros if necessary.
 253  *
 254  * plain64: the initial vector is the 64-bit little-endian version of the sector
 255  *        number, padded with zeros if necessary.
 256  *
 257  * plain64be: the initial vector is the 64-bit big-endian version of the sector
 258  *        number, padded with zeros if necessary.
 259  *
 260  * essiv: "encrypted sector|salt initial vector", the sector number is
 261  *        encrypted with the bulk cipher using a salt as key. The salt
 262  *        should be derived from the bulk cipher's key via hashing.
 263  *
 264  * benbi: the 64-bit "big-endian 'narrow block'-count", starting at 1
 265  *        (needed for LRW-32-AES and possible other narrow block modes)
 266  *
 267  * null: the initial vector is always zero.  Provides compatibility with
 268  *       obsolete loop_fish2 devices.  Do not use for new devices.
 269  *
 270  * lmk:  Compatible implementation of the block chaining mode used
 271  *       by the Loop-AES block device encryption system
 272  *       designed by Jari Ruusu. See http://loop-aes.sourceforge.net/
 273  *       It operates on full 512 byte sectors and uses CBC
 274  *       with an IV derived from the sector number, the data and
 275  *       optionally extra IV seed.
 276  *       This means that after decryption the first block
 277  *       of sector must be tweaked according to decrypted data.
 278  *       Loop-AES can use three encryption schemes:
 279  *         version 1: is plain aes-cbc mode
 280  *         version 2: uses 64 multikey scheme with lmk IV generator
 281  *         version 3: the same as version 2 with additional IV seed
 282  *                   (it uses 65 keys, last key is used as IV seed)
 283  *
 284  * tcw:  Compatible implementation of the block chaining mode used
 285  *       by the TrueCrypt device encryption system (prior to version 4.1).
 286  *       For more info see: https://gitlab.com/cryptsetup/cryptsetup/wikis/TrueCryptOnDiskFormat
 287  *       It operates on full 512 byte sectors and uses CBC
 288  *       with an IV derived from initial key and the sector number.
 289  *       In addition, whitening value is applied on every sector, whitening
 290  *       is calculated from initial key, sector number and mixed using CRC32.
 291  *       Note that this encryption scheme is vulnerable to watermarking attacks
 292  *       and should be used for old compatible containers access only.
 293  *
 294  * plumb: unimplemented, see:
 295  * http://article.gmane.org/gmane.linux.kernel.device-mapper.dm-crypt/454
 296  */
 297
 298 static int crypt_iv_plain_gen(struct crypt_config *cc, u8 *iv,
 299                               struct dm_crypt_request *dmreq)
 300 {
 301         memset(iv, 0, cc->iv_size);
 302         *(__le32 *)iv = cpu_to_le32(dmreq->iv_sector & 0xffffffff);
 303
 304         return 0;
 305 }
 306
 307 static int crypt_iv_plain64_gen(struct crypt_config *cc, u8 *iv,
 308                                 struct dm_crypt_request *dmreq)
 309 {
 310         memset(iv, 0, cc->iv_size);
 311         *(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
 312
 313         return 0;
 314 }
 315
 316 static int crypt_iv_plain64be_gen(struct crypt_config *cc, u8 *iv,
 317                                   struct dm_crypt_request *dmreq)
 318 {
 319         memset(iv, 0, cc->iv_size);
 320         /* iv_size is at least of size u64; usually it is 16 bytes */
 321         *(__be64 *)&iv[cc->iv_size - sizeof(u64)] = cpu_to_be64(dmreq->iv_sector);
 322
 323         return 0;
 324 }
 325
 326 /* Initialise ESSIV - compute salt but no local memory allocations */
 327 static int crypt_iv_essiv_init(struct crypt_config *cc)
 328 {
 329         struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
 330         AHASH_REQUEST_ON_STACK(req, essiv->hash_tfm);
 331         struct scatterlist sg;
 332         struct crypto_cipher *essiv_tfm;
 333         int err;
 334
 335         sg_init_one(&sg, cc->key, cc->key_size);
 336         ahash_request_set_tfm(req, essiv->hash_tfm);
 337         ahash_request_set_callback(req, 0, NULL, NULL);
 338         ahash_request_set_crypt(req, &sg, essiv->salt, cc->key_size);
 339
 340         err = crypto_ahash_digest(req);
 341         ahash_request_zero(req);
 342         if (err)
 343                 return err;
 344
 345         essiv_tfm = cc->iv_private;
 346
 347         err = crypto_cipher_setkey(essiv_tfm, essiv->salt,
 348                             crypto_ahash_digestsize(essiv->hash_tfm));
 349         if (err)
 350                 return err;
 351
 352         return 0;
 353 }
 354
 355 /* Wipe salt and reset key derived from volume key */
 356 static int crypt_iv_essiv_wipe(struct crypt_config *cc)
 357 {
 358         struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
 359         unsigned salt_size = crypto_ahash_digestsize(essiv->hash_tfm);
 360         struct crypto_cipher *essiv_tfm;
 361         int r, err = 0;
 362
 363         memset(essiv->salt, 0, salt_size);
 364
 365         essiv_tfm = cc->iv_private;
 366         r = crypto_cipher_setkey(essiv_tfm, essiv->salt, salt_size);
 367         if (r)
 368                 err = r;
 369
 370         return err;
 371 }
 372
 373 /* Allocate the cipher for ESSIV */
 374 static struct crypto_cipher *alloc_essiv_cipher(struct crypt_config *cc,
 375                                                 struct dm_target *ti,
 376                                                 const u8 *salt,
 377                                                 unsigned int saltsize)
 378 {
 379         struct crypto_cipher *essiv_tfm;
 380         int err;
 381
 382         /* Setup the essiv_tfm with the given salt */
 383         essiv_tfm = crypto_alloc_cipher(cc->cipher, 0, CRYPTO_ALG_ASYNC);
 384         if (IS_ERR(essiv_tfm)) {
 385                 ti->error = "Error allocating crypto tfm for ESSIV";
 386                 return essiv_tfm;
 387         }
 388
 389         if (crypto_cipher_blocksize(essiv_tfm) != cc->iv_size) {
 390                 ti->error = "Block size of ESSIV cipher does "
 391                             "not match IV size of block cipher";
 392                 crypto_free_cipher(essiv_tfm);
 393                 return ERR_PTR(-EINVAL);
 394         }
 395
 396         err = crypto_cipher_setkey(essiv_tfm, salt, saltsize);
 397         if (err) {
 398                 ti->error = "Failed to set key for ESSIV cipher";
 399                 crypto_free_cipher(essiv_tfm);
 400                 return ERR_PTR(err);
 401         }
 402
 403         return essiv_tfm;
 404 }
 405
 406 static void crypt_iv_essiv_dtr(struct crypt_config *cc)
 407 {
 408         struct crypto_cipher *essiv_tfm;
 409         struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
 410
 411         crypto_free_ahash(essiv->hash_tfm);
 412         essiv->hash_tfm = NULL;
 413
 414         kzfree(essiv->salt);
 415         essiv->salt = NULL;
 416
 417         essiv_tfm = cc->iv_private;
 418
 419         if (essiv_tfm)
 420                 crypto_free_cipher(essiv_tfm);
 421
 422         cc->iv_private = NULL;
 423 }
 424
 425 static int crypt_iv_essiv_ctr(struct crypt_config *cc, struct dm_target *ti,
 426                               const char *opts)
 427 {
 428         struct crypto_cipher *essiv_tfm = NULL;
 429         struct crypto_ahash *hash_tfm = NULL;
 430         u8 *salt = NULL;
 431         int err;
 432
 433         if (!opts) {
 434                 ti->error = "Digest algorithm missing for ESSIV mode";
 435                 return -EINVAL;
 436         }
 437
 438         /* Allocate hash algorithm */
 439         hash_tfm = crypto_alloc_ahash(opts, 0, CRYPTO_ALG_ASYNC);
 440         if (IS_ERR(hash_tfm)) {
 441                 ti->error = "Error initializing ESSIV hash";
 442                 err = PTR_ERR(hash_tfm);
 443                 goto bad;
 444         }
 445
 446         salt = kzalloc(crypto_ahash_digestsize(hash_tfm), GFP_KERNEL);
 447         if (!salt) {
 448                 ti->error = "Error kmallocing salt storage in ESSIV";
 449                 err = -ENOMEM;
 450                 goto bad;
 451         }
 452
 453         cc->iv_gen_private.essiv.salt = salt;
 454         cc->iv_gen_private.essiv.hash_tfm = hash_tfm;
 455
 456         essiv_tfm = alloc_essiv_cipher(cc, ti, salt,
 457                                        crypto_ahash_digestsize(hash_tfm));
 458         if (IS_ERR(essiv_tfm)) {
 459                 crypt_iv_essiv_dtr(cc);
 460                 return PTR_ERR(essiv_tfm);
 461         }
 462         cc->iv_private = essiv_tfm;
 463
 464         return 0;
 465
 466 bad:
 467         if (hash_tfm && !IS_ERR(hash_tfm))
 468                 crypto_free_ahash(hash_tfm);
 469         kfree(salt);
 470         return err;
 471 }
 472
 473 static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv,
 474                               struct dm_crypt_request *dmreq)
 475 {
 476         struct crypto_cipher *essiv_tfm = cc->iv_private;
 477
 478         memset(iv, 0, cc->iv_size);
 479         *(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
 480         crypto_cipher_encrypt_one(essiv_tfm, iv, iv);
 481
 482         return 0;
 483 }
 484
 485 static int crypt_iv_benbi_ctr(struct crypt_config *cc, struct dm_target *ti,
 486                               const char *opts)
 487 {
 488         unsigned bs;
 489         int log;
 490
 491         if (test_bit(CRYPT_MODE_INTEGRITY_AEAD, &cc->cipher_flags))
 492                 bs = crypto_aead_blocksize(any_tfm_aead(cc));
 493         else
 494                 bs = crypto_skcipher_blocksize(any_tfm(cc));
 495         log = ilog2(bs);
 496
 497         /* we need to calculate how far we must shift the sector count
 498          * to get the cipher block count, we use this shift in _gen */
 499
 500         if (1 << log != bs) {
 501                 ti->error = "cypher blocksize is not a power of 2";
 502                 return -EINVAL;
 503         }
 504
 505         if (log > 9) {
 506                 ti->error = "cypher blocksize is > 512";
 507                 return -EINVAL;
 508         }
 509
 510         cc->iv_gen_private.benbi.shift = 9 - log;
 511
 512         return 0;
 513 }
 514
 515 static void crypt_iv_benbi_dtr(struct crypt_config *cc)
 516 {
 517 }
 518
 519 static int crypt_iv_benbi_gen(struct crypt_config *cc, u8 *iv,
 520                               struct dm_crypt_request *dmreq)
 521 {
 522         __be64 val;
 523
 524         memset(iv, 0, cc->iv_size - sizeof(u64)); /* rest is cleared below */
 525
 526         val = cpu_to_be64(((u64)dmreq->iv_sector << cc->iv_gen_private.benbi.shift) + 1);
 527         put_unaligned(val, (__be64 *)(iv + cc->iv_size - sizeof(u64)));
 528
 529         return 0;
 530 }
 531
 532 static int crypt_iv_null_gen(struct crypt_config *cc, u8 *iv,
 533                              struct dm_crypt_request *dmreq)
 534 {
 535         memset(iv, 0, cc->iv_size);
 536
 537         return 0;
 538 }
 539
 540 static void crypt_iv_lmk_dtr(struct crypt_config *cc)
 541 {
 542         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 543
 544         if (lmk->hash_tfm && !IS_ERR(lmk->hash_tfm))
 545                 crypto_free_shash(lmk->hash_tfm);
 546         lmk->hash_tfm = NULL;
 547
 548         kzfree(lmk->seed);
 549         lmk->seed = NULL;
 550 }
 551
 552 static int crypt_iv_lmk_ctr(struct crypt_config *cc, struct dm_target *ti,
 553                             const char *opts)
 554 {
 555         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 556
 557         if (cc->sector_size != (1 << SECTOR_SHIFT)) {
 558                 ti->error = "Unsupported sector size for LMK";
 559                 return -EINVAL;
 560         }
 561
 562         lmk->hash_tfm = crypto_alloc_shash("md5", 0, 0);
 563         if (IS_ERR(lmk->hash_tfm)) {
 564                 ti->error = "Error initializing LMK hash";
 565                 return PTR_ERR(lmk->hash_tfm);
 566         }
 567
 568         /* No seed in LMK version 2 */
 569         if (cc->key_parts == cc->tfms_count) {
 570                 lmk->seed = NULL;
 571                 return 0;
 572         }
 573
 574         lmk->seed = kzalloc(LMK_SEED_SIZE, GFP_KERNEL);
 575         if (!lmk->seed) {
 576                 crypt_iv_lmk_dtr(cc);
 577                 ti->error = "Error kmallocing seed storage in LMK";
 578                 return -ENOMEM;
 579         }
 580
 581         return 0;
 582 }
 583
 584 static int crypt_iv_lmk_init(struct crypt_config *cc)
 585 {
 586         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 587         int subkey_size = cc->key_size / cc->key_parts;
 588
 589         /* LMK seed is on the position of LMK_KEYS + 1 key */
 590         if (lmk->seed)
 591                 memcpy(lmk->seed, cc->key + (cc->tfms_count * subkey_size),
 592                        crypto_shash_digestsize(lmk->hash_tfm));
 593
 594         return 0;
 595 }
 596
 597 static int crypt_iv_lmk_wipe(struct crypt_config *cc)
 598 {
 599         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 600
 601         if (lmk->seed)
 602                 memset(lmk->seed, 0, LMK_SEED_SIZE);
 603
 604         return 0;
 605 }
 606
 607 static int crypt_iv_lmk_one(struct crypt_config *cc, u8 *iv,
 608                             struct dm_crypt_request *dmreq,
 609                             u8 *data)
 610 {
 611         struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
 612         SHASH_DESC_ON_STACK(desc, lmk->hash_tfm);
 613         struct md5_state md5state;
 614         __le32 buf[4];
 615         int i, r;
 616
 617         desc->tfm = lmk->hash_tfm;
 618         desc->flags = 0;
 619
 620         r = crypto_shash_init(desc);
 621         if (r)
 622                 return r;
 623
 624         if (lmk->seed) {
 625                 r = crypto_shash_update(desc, lmk->seed, LMK_SEED_SIZE);
 626                 if (r)
 627                         return r;
 628         }
 629
 630         /* Sector is always 512B, block size 16, add data of blocks 1-31 */
 631         r = crypto_shash_update(desc, data + 16, 16 * 31);
 632         if (r)
 633                 return r;
 634
 635         /* Sector is cropped to 56 bits here */
 636         buf[0] = cpu_to_le32(dmreq->iv_sector & 0xFFFFFFFF);
 637         buf[1] = cpu_to_le32((((u64)dmreq->iv_sector >> 32) & 0x00FFFFFF) | 0x80000000);
 638         buf[2] = cpu_to_le32(4024);
 639         buf[3] = 0;
 640         r = crypto_shash_update(desc, (u8 *)buf, sizeof(buf));
 641         if (r)
 642                 return r;
 643
 644         /* No MD5 padding here */
 645         r = crypto_shash_export(desc, &md5state);
 646         if (r)
 647                 return r;
 648
 649         for (i = 0; i < MD5_HASH_WORDS; i++)
 650                 __cpu_to_le32s(&md5state.hash[i]);
 651         memcpy(iv, &md5state.hash, cc->iv_size);
 652
 653         return 0;
 654 }
 655
 656 static int crypt_iv_lmk_gen(struct crypt_config *cc, u8 *iv,
 657                             struct dm_crypt_request *dmreq)
 658 {
 659         struct scatterlist *sg;
 660         u8 *src;
 661         int r = 0;
 662
 663         if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) {
 664                 sg = crypt_get_sg_data(cc, dmreq->sg_in);
 665                 src = kmap_atomic(sg_page(sg));
 666                 r = crypt_iv_lmk_one(cc, iv, dmreq, src + sg->offset);
 667                 kunmap_atomic(src);
 668         } else
 669                 memset(iv, 0, cc->iv_size);
 670
 671         return r;
 672 }
 673
 674 static int crypt_iv_lmk_post(struct crypt_config *cc, u8 *iv,
 675                              struct dm_crypt_request *dmreq)
 676 {
 677         struct scatterlist *sg;
 678         u8 *dst;
 679         int r;
 680
 681         if (bio_data_dir(dmreq->ctx->bio_in) == WRITE)
 682                 return 0;
 683
 684         sg = crypt_get_sg_data(cc, dmreq->sg_out);
 685         dst = kmap_atomic(sg_page(sg));
 686         r = crypt_iv_lmk_one(cc, iv, dmreq, dst + sg->offset);
 687
 688         /* Tweak the first block of plaintext sector */
 689         if (!r)
 690                 crypto_xor(dst + sg->offset, iv, cc->iv_size);
 691
 692         kunmap_atomic(dst);
 693         return r;
 694 }
 695
 696 static void crypt_iv_tcw_dtr(struct crypt_config *cc)
 697 {
 698         struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
 699
 700         kzfree(tcw->iv_seed);
 701         tcw->iv_seed = NULL;
 702         kzfree(tcw->whitening);
 703         tcw->whitening = NULL;
 704
 705         if (tcw->crc32_tfm && !IS_ERR(tcw->crc32_tfm))
 706                 crypto_free_shash(tcw->crc32_tfm);
 707         tcw->crc32_tfm = NULL;
 708 }
 709
 710 static int crypt_iv_tcw_ctr(struct crypt_config *cc, struct dm_target *ti,
 711                             const char *opts)
 712 {
 713         struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
 714
 715         if (cc->sector_size != (1 << SECTOR_SHIFT)) {
 716                 ti->error = "Unsupported sector size for TCW";
 717                 return -EINVAL;
 718         }
 719
 720         if (cc->key_size <= (cc->iv_size + TCW_WHITENING_SIZE)) {
 721                 ti->error = "Wrong key size for TCW";
 722                 return -EINVAL;
 723         }
 724
 725         tcw->crc32_tfm = crypto_alloc_shash("crc32", 0, 0);
 726         if (IS_ERR(tcw->crc32_tfm)) {
 727                 ti->error = "Error initializing CRC32 in TCW";
 728                 return PTR_ERR(tcw->crc32_tfm);
 729         }
 730
 731         tcw->iv_seed = kzalloc(cc->iv_size, GFP_KERNEL);
 732         tcw->whitening = kzalloc(TCW_WHITENING_SIZE, GFP_KERNEL);
 733         if (!tcw->iv_seed || !tcw->whitening) {
 734                 crypt_iv_tcw_dtr(cc);
 735                 ti->error = "Error allocating seed storage in TCW";
 736                 return -ENOMEM;
 737         }
 738
 739         return 0;
 740 }
 741
 742 static int crypt_iv_tcw_init(struct crypt_config *cc)
 743 {
 744         struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
 745         int key_offset = cc->key_size - cc->iv_size - TCW_WHITENING_SIZE;
 746
 747         memcpy(tcw->iv_seed, &cc->key[key_offset], cc->iv_size);
 748         memcpy(tcw->whitening, &cc->key[key_offset + cc->iv_size],
 749                TCW_WHITENING_SIZE);
 750
 751         return 0;
 752 }
 753
 754 static int crypt_iv_tcw_wipe(struct crypt_config *cc)
 755 {
 756         struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
 757
 758         memset(tcw->iv_seed, 0, cc->iv_size);
 759         memset(tcw->whitening, 0, TCW_WHITENING_SIZE);
 760
 761         return 0;
 762 }
 763
 764 static int crypt_iv_tcw_whitening(struct crypt_config *cc,
 765                                   struct dm_crypt_request *dmreq,
 766                                   u8 *data)
 767 {
 768         struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
 769         __le64 sector = cpu_to_le64(dmreq->iv_sector);
 770         u8 buf[TCW_WHITENING_SIZE];
 771         SHASH_DESC_ON_STACK(desc, tcw->crc32_tfm);
 772         int i, r;
 773
 774         /* xor whitening with sector number */
 775         crypto_xor_cpy(buf, tcw->whitening, (u8 *)&sector, 8);
 776         crypto_xor_cpy(&buf[8], tcw->whitening + 8, (u8 *)&sector, 8);
 777
 778         /* calculate crc32 for every 32bit part and xor it */
 779         desc->tfm = tcw->crc32_tfm;
 780         desc->flags = 0;
 781         for (i = 0; i < 4; i++) {
 782                 r = crypto_shash_init(desc);
 783                 if (r)
 784                         goto out;
 785                 r = crypto_shash_update(desc, &buf[i * 4], 4);
 786                 if (r)
 787                         goto out;
 788                 r = crypto_shash_final(desc, &buf[i * 4]);
 789                 if (r)
 790                         goto out;
 791         }
 792         crypto_xor(&buf[0], &buf[12], 4);
 793         crypto_xor(&buf[4], &buf[8], 4);
 794
 795         /* apply whitening (8 bytes) to whole sector */
 796         for (i = 0; i < ((1 << SECTOR_SHIFT) / 8); i++)
 797                 crypto_xor(data + i * 8, buf, 8);
 798 out:
 799         memzero_explicit(buf, sizeof(buf));
 800         return r;
 801 }
 802
 803 static int crypt_iv_tcw_gen(struct crypt_config *cc, u8 *iv,
 804                             struct dm_crypt_request *dmreq)
 805 {
 806         struct scatterlist *sg;
 807         struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
 808         __le64 sector = cpu_to_le64(dmreq->iv_sector);
 809         u8 *src;
 810         int r = 0;
 811
 812         /* Remove whitening from ciphertext */
 813         if (bio_data_dir(dmreq->ctx->bio_in) != WRITE) {
 814                 sg = crypt_get_sg_data(cc, dmreq->sg_in);
 815                 src = kmap_atomic(sg_page(sg));
 816                 r = crypt_iv_tcw_whitening(cc, dmreq, src + sg->offset);
 817                 kunmap_atomic(src);
 818         }
 819
 820         /* Calculate IV */
 821         crypto_xor_cpy(iv, tcw->iv_seed, (u8 *)&sector, 8);
 822         if (cc->iv_size > 8)
 823                 crypto_xor_cpy(&iv[8], tcw->iv_seed + 8, (u8 *)&sector,
 824                                cc->iv_size - 8);
 825
 826         return r;
 827 }
 828
 829 static int crypt_iv_tcw_post(struct crypt_config *cc, u8 *iv,
 830                              struct dm_crypt_request *dmreq)
 831 {
 832         struct scatterlist *sg;
 833         u8 *dst;
 834         int r;
 835
 836         if (bio_data_dir(dmreq->ctx->bio_in) != WRITE)
 837                 return 0;
 838
 839         /* Apply whitening on ciphertext */
 840         sg = crypt_get_sg_data(cc, dmreq->sg_out);
 841         dst = kmap_atomic(sg_page(sg));
 842         r = crypt_iv_tcw_whitening(cc, dmreq, dst + sg->offset);
 843         kunmap_atomic(dst);
 844
 845         return r;
 846 }
 847
 848 static int crypt_iv_random_gen(struct crypt_config *cc, u8 *iv,
 849                                 struct dm_crypt_request *dmreq)
 850 {
 851         /* Used only for writes, there must be an additional space to store IV */
 852         get_random_bytes(iv, cc->iv_size);
 853         return 0;
 854 }
 855
 856 static const struct crypt_iv_operations crypt_iv_plain_ops = {
 857         .generator = crypt_iv_plain_gen
 858 };
 859
 860 static const struct crypt_iv_operations crypt_iv_plain64_ops = {
 861         .generator = crypt_iv_plain64_gen
 862 };
 863
 864 static const struct crypt_iv_operations crypt_iv_plain64be_ops = {
 865         .generator = crypt_iv_plain64be_gen
 866 };
 867
 868 static const struct crypt_iv_operations crypt_iv_essiv_ops = {
 869         .ctr       = crypt_iv_essiv_ctr,
 870         .dtr       = crypt_iv_essiv_dtr,
 871         .init      = crypt_iv_essiv_init,
 872         .wipe      = crypt_iv_essiv_wipe,
 873         .generator = crypt_iv_essiv_gen
 874 };
 875
 876 static const struct crypt_iv_operations crypt_iv_benbi_ops = {
 877         .ctr       = crypt_iv_benbi_ctr,
 878         .dtr       = crypt_iv_benbi_dtr,
 879         .generator = crypt_iv_benbi_gen
 880 };
 881
 882 static const struct crypt_iv_operations crypt_iv_null_ops = {
 883         .generator = crypt_iv_null_gen
 884 };
 885
 886 static const struct crypt_iv_operations crypt_iv_lmk_ops = {
 887         .ctr       = crypt_iv_lmk_ctr,
 888         .dtr       = crypt_iv_lmk_dtr,
 889         .init      = crypt_iv_lmk_init,
 890         .wipe      = crypt_iv_lmk_wipe,
 891         .generator = crypt_iv_lmk_gen,
 892         .post      = crypt_iv_lmk_post
 893 };
 894
 895 static const struct crypt_iv_operations crypt_iv_tcw_ops = {
 896         .ctr       = crypt_iv_tcw_ctr,
 897         .dtr       = crypt_iv_tcw_dtr,
 898         .init      = crypt_iv_tcw_init,
 899         .wipe      = crypt_iv_tcw_wipe,
 900         .generator = crypt_iv_tcw_gen,
 901         .post      = crypt_iv_tcw_post
 902 };
 903
 904 static struct crypt_iv_operations crypt_iv_random_ops = {
 905         .generator = crypt_iv_random_gen
 906 };
 907
 908 /*
 909  * Integrity extensions
 910  */
 911 static bool crypt_integrity_aead(struct crypt_config *cc)
 912 {
 913         return test_bit(CRYPT_MODE_INTEGRITY_AEAD, &cc->cipher_flags);
 914 }
 915
 916 static bool crypt_integrity_hmac(struct crypt_config *cc)
 917 {
 918         return crypt_integrity_aead(cc) && cc->key_mac_size;
 919 }
 920
 921 /* Get sg containing data */
 922 static struct scatterlist *crypt_get_sg_data(struct crypt_config *cc,
 923                                              struct scatterlist *sg)
 924 {
 925         if (unlikely(crypt_integrity_aead(cc)))
 926                 return &sg[2];
 927
 928         return sg;
 929 }
 930
 931 static int dm_crypt_integrity_io_alloc(struct dm_crypt_io *io, struct bio *bio)
 932 {
 933         struct bio_integrity_payload *bip;
 934         unsigned int tag_len;
 935         int ret;
 936
 937         if (!bio_sectors(bio) || !io->cc->on_disk_tag_size)
 938                 return 0;
 939
 940         bip = bio_integrity_alloc(bio, GFP_NOIO, 1);
 941         if (IS_ERR(bip))
 942                 return PTR_ERR(bip);
 943
 944         tag_len = io->cc->on_disk_tag_size * (bio_sectors(bio) >> io->cc->sector_shift);
 945
 946         bip->bip_iter.bi_size = tag_len;
 947         bip->bip_iter.bi_sector = io->cc->start + io->sector;
 948
 949         ret = bio_integrity_add_page(bio, virt_to_page(io->integrity_metadata),
 950                                      tag_len, offset_in_page(io->integrity_metadata));
 951         if (unlikely(ret != tag_len))
 952                 return -ENOMEM;
 953
 954         return 0;
 955 }
 956
 957 static int crypt_integrity_ctr(struct crypt_config *cc, struct dm_target *ti)
 958 {
 959 #ifdef CONFIG_BLK_DEV_INTEGRITY
 960         struct blk_integrity *bi = blk_get_integrity(cc->dev->bdev->bd_disk);
 961
 962         /* From now we require underlying device with our integrity profile */
 963         if (!bi || strcasecmp(bi->profile->name, "DM-DIF-EXT-TAG")) {
 964                 ti->error = "Integrity profile not supported.";
 965                 return -EINVAL;
 966         }
 967
 968         if (bi->tag_size != cc->on_disk_tag_size ||
 969             bi->tuple_size != cc->on_disk_tag_size) {
 970                 ti->error = "Integrity profile tag size mismatch.";
 971                 return -EINVAL;
 972         }
 973         if (1 << bi->interval_exp != cc->sector_size) {
 974                 ti->error = "Integrity profile sector size mismatch.";
 975                 return -EINVAL;
 976         }
 977
 978         if (crypt_integrity_aead(cc)) {
 979                 cc->integrity_tag_size = cc->on_disk_tag_size - cc->integrity_iv_size;
 980                 DMINFO("Integrity AEAD, tag size %u, IV size %u.",
 981                        cc->integrity_tag_size, cc->integrity_iv_size);
 982
 983                 if (crypto_aead_setauthsize(any_tfm_aead(cc), cc->integrity_tag_size)) {
 984                         ti->error = "Integrity AEAD auth tag size is not supported.";
 985                         return -EINVAL;
 986                 }
 987         } else if (cc->integrity_iv_size)
 988                 DMINFO("Additional per-sector space %u bytes for IV.",
 989                        cc->integrity_iv_size);
 990
 991         if ((cc->integrity_tag_size + cc->integrity_iv_size) != bi->tag_size) {
 992                 ti->error = "Not enough space for integrity tag in the profile.";
 993                 return -EINVAL;
 994         }
 995
 996         return 0;
 997 #else
 998         ti->error = "Integrity profile not supported.";
 999         return -EINVAL;
1000 #endif
1001 }
1002
1003 static void crypt_convert_init(struct crypt_config *cc,
1004                                struct convert_context *ctx,
1005                                struct bio *bio_out, struct bio *bio_in,
1006                                sector_t sector)
1007 {
1008         ctx->bio_in = bio_in;
1009         ctx->bio_out = bio_out;
1010         if (bio_in)
1011                 ctx->iter_in = bio_in->bi_iter;
1012         if (bio_out)
1013                 ctx->iter_out = bio_out->bi_iter;
1014         ctx->cc_sector = sector + cc->iv_offset;
1015         init_completion(&ctx->restart);
1016 }
1017
1018 static struct dm_crypt_request *dmreq_of_req(struct crypt_config *cc,
1019                                              void *req)
1020 {
1021         return (struct dm_crypt_request *)((char *)req + cc->dmreq_start);
1022 }
1023
1024 static void *req_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq)
1025 {
1026         return (void *)((char *)dmreq - cc->dmreq_start);
1027 }
1028
1029 static u8 *iv_of_dmreq(struct crypt_config *cc,
1030                        struct dm_crypt_request *dmreq)
1031 {
1032         if (crypt_integrity_aead(cc))
1033                 return (u8 *)ALIGN((unsigned long)(dmreq + 1),
1034                         crypto_aead_alignmask(any_tfm_aead(cc)) + 1);
1035         else
1036                 return (u8 *)ALIGN((unsigned long)(dmreq + 1),
1037                         crypto_skcipher_alignmask(any_tfm(cc)) + 1);
1038 }
1039
1040 static u8 *org_iv_of_dmreq(struct crypt_config *cc,
1041                        struct dm_crypt_request *dmreq)
1042 {
1043         return iv_of_dmreq(cc, dmreq) + cc->iv_size;
1044 }
1045
1046 static uint64_t *org_sector_of_dmreq(struct crypt_config *cc,
1047                        struct dm_crypt_request *dmreq)
1048 {
1049         u8 *ptr = iv_of_dmreq(cc, dmreq) + cc->iv_size + cc->iv_size;
1050         return (uint64_t*) ptr;
1051 }
1052
1053 static unsigned int *org_tag_of_dmreq(struct crypt_config *cc,
1054                        struct dm_crypt_request *dmreq)
1055 {
1056         u8 *ptr = iv_of_dmreq(cc, dmreq) + cc->iv_size +
1057                   cc->iv_size + sizeof(uint64_t);
1058         return (unsigned int*)ptr;
1059 }
1060
1061 static void *tag_from_dmreq(struct crypt_config *cc,
1062                                 struct dm_crypt_request *dmreq)
1063 {
1064         struct convert_context *ctx = dmreq->ctx;
1065         struct dm_crypt_io *io = container_of(ctx, struct dm_crypt_io, ctx);
1066
1067         return &io->integrity_metadata[*org_tag_of_dmreq(cc, dmreq) *
1068                 cc->on_disk_tag_size];
1069 }
1070
1071 static void *iv_tag_from_dmreq(struct crypt_config *cc,
1072                                struct dm_crypt_request *dmreq)
1073 {
1074         return tag_from_dmreq(cc, dmreq) + cc->integrity_tag_size;
1075 }
1076
1077 static int crypt_convert_block_aead(struct crypt_config *cc,
1078                                      struct convert_context *ctx,
1079                                      struct aead_request *req,
1080                                      unsigned int tag_offset)
1081 {
1082         struct bio_vec bv_in = bio_iter_iovec(ctx->bio_in, ctx->iter_in);
1083         struct bio_vec bv_out = bio_iter_iovec(ctx->bio_out, ctx->iter_out);
1084         struct dm_crypt_request *dmreq;
1085         u8 *iv, *org_iv, *tag_iv, *tag;
1086         uint64_t *sector;
1087         int r = 0;
1088
1089         BUG_ON(cc->integrity_iv_size && cc->integrity_iv_size != cc->iv_size);
1090
1091         /* Reject unexpected unaligned bio. */
1092         if (unlikely(bv_in.bv_len & (cc->sector_size - 1)))
1093                 return -EIO;
1094
1095         dmreq = dmreq_of_req(cc, req);
1096         dmreq->iv_sector = ctx->cc_sector;
1097         if (test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags))
1098                 dmreq->iv_sector >>= cc->sector_shift;
1099         dmreq->ctx = ctx;
1100
1101         *org_tag_of_dmreq(cc, dmreq) = tag_offset;
1102
1103         sector = org_sector_of_dmreq(cc, dmreq);
1104         *sector = cpu_to_le64(ctx->cc_sector - cc->iv_offset);
1105
1106         iv = iv_of_dmreq(cc, dmreq);
1107         org_iv = org_iv_of_dmreq(cc, dmreq);
1108         tag = tag_from_dmreq(cc, dmreq);
1109         tag_iv = iv_tag_from_dmreq(cc, dmreq);
1110
1111         /* AEAD request:
1112          *  |----- AAD -------|------ DATA -------|-- AUTH TAG --|
1113          *  | (authenticated) | (auth+encryption) |              |
1114          *  | sector_LE |  IV |  sector in/out    |  tag in/out  |
1115          */
1116         sg_init_table(dmreq->sg_in, 4);
1117         sg_set_buf(&dmreq->sg_in[0], sector, sizeof(uint64_t));
1118         sg_set_buf(&dmreq->sg_in[1], org_iv, cc->iv_size);
1119         sg_set_page(&dmreq->sg_in[2], bv_in.bv_page, cc->sector_size, bv_in.bv_offset);
1120         sg_set_buf(&dmreq->sg_in[3], tag, cc->integrity_tag_size);
1121
1122         sg_init_table(dmreq->sg_out, 4);
1123         sg_set_buf(&dmreq->sg_out[0], sector, sizeof(uint64_t));
1124         sg_set_buf(&dmreq->sg_out[1], org_iv, cc->iv_size);
1125         sg_set_page(&dmreq->sg_out[2], bv_out.bv_page, cc->sector_size, bv_out.bv_offset);
1126         sg_set_buf(&dmreq->sg_out[3], tag, cc->integrity_tag_size);
1127
1128         if (cc->iv_gen_ops) {
1129                 /* For READs use IV stored in integrity metadata */
1130                 if (cc->integrity_iv_size && bio_data_dir(ctx->bio_in) != WRITE) {
1131                         memcpy(org_iv, tag_iv, cc->iv_size);
1132                 } else {
1133                         r = cc->iv_gen_ops->generator(cc, org_iv, dmreq);
1134                         if (r < 0)
1135                                 return r;
1136                         /* Store generated IV in integrity metadata */
1137                         if (cc->integrity_iv_size)
1138                                 memcpy(tag_iv, org_iv, cc->iv_size);
1139                 }
1140                 /* Working copy of IV, to be modified in crypto API */
1141                 memcpy(iv, org_iv, cc->iv_size);
1142         }
1143
1144         aead_request_set_ad(req, sizeof(uint64_t) + cc->iv_size);
1145         if (bio_data_dir(ctx->bio_in) == WRITE) {
1146                 aead_request_set_crypt(req, dmreq->sg_in, dmreq->sg_out,
1147                                        cc->sector_size, iv);
1148                 r = crypto_aead_encrypt(req);
1149                 if (cc->integrity_tag_size + cc->integrity_iv_size != cc->on_disk_tag_size)
1150                         memset(tag + cc->integrity_tag_size + cc->integrity_iv_size, 0,
1151                                cc->on_disk_tag_size - (cc->integrity_tag_size + cc->integrity_iv_size));
1152         } else {
1153                 aead_request_set_crypt(req, dmreq->sg_in, dmreq->sg_out,
1154                                        cc->sector_size + cc->integrity_tag_size, iv);
1155                 r = crypto_aead_decrypt(req);
1156         }
1157
1158         if (r == -EBADMSG)
1159                 DMERR_LIMIT("INTEGRITY AEAD ERROR, sector %llu",
1160                             (unsigned long long)le64_to_cpu(*sector));
1161
1162         if (!r && cc->iv_gen_ops && cc->iv_gen_ops->post)
1163                 r = cc->iv_gen_ops->post(cc, org_iv, dmreq);
1164
1165         bio_advance_iter(ctx->bio_in, &ctx->iter_in, cc->sector_size);
1166         bio_advance_iter(ctx->bio_out, &ctx->iter_out, cc->sector_size);
1167
1168         return r;
1169 }
1170
1171 static int crypt_convert_block_skcipher(struct crypt_config *cc,
1172                                         struct convert_context *ctx,
1173                                         struct skcipher_request *req,
1174                                         unsigned int tag_offset)
1175 {
1176         struct bio_vec bv_in = bio_iter_iovec(ctx->bio_in, ctx->iter_in);
1177         struct bio_vec bv_out = bio_iter_iovec(ctx->bio_out, ctx->iter_out);
1178         struct scatterlist *sg_in, *sg_out;
1179         struct dm_crypt_request *dmreq;
1180         u8 *iv, *org_iv, *tag_iv;
1181         uint64_t *sector;
1182         int r = 0;
1183
1184         /* Reject unexpected unaligned bio. */
1185         if (unlikely(bv_in.bv_len & (cc->sector_size - 1)))
1186                 return -EIO;
1187
1188         dmreq = dmreq_of_req(cc, req);
1189         dmreq->iv_sector = ctx->cc_sector;
1190         if (test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags))
1191                 dmreq->iv_sector >>= cc->sector_shift;
1192         dmreq->ctx = ctx;
1193
1194         *org_tag_of_dmreq(cc, dmreq) = tag_offset;
1195
1196         iv = iv_of_dmreq(cc, dmreq);
1197         org_iv = org_iv_of_dmreq(cc, dmreq);
1198         tag_iv = iv_tag_from_dmreq(cc, dmreq);
1199
1200         sector = org_sector_of_dmreq(cc, dmreq);
1201         *sector = cpu_to_le64(ctx->cc_sector - cc->iv_offset);
1202
1203         /* For skcipher we use only the first sg item */
1204         sg_in  = &dmreq->sg_in[0];
1205         sg_out = &dmreq->sg_out[0];
1206
1207         sg_init_table(sg_in, 1);
1208         sg_set_page(sg_in, bv_in.bv_page, cc->sector_size, bv_in.bv_offset);
1209
1210         sg_init_table(sg_out, 1);
1211         sg_set_page(sg_out, bv_out.bv_page, cc->sector_size, bv_out.bv_offset);
1212
1213         if (cc->iv_gen_ops) {
1214                 /* For READs use IV stored in integrity metadata */
1215                 if (cc->integrity_iv_size && bio_data_dir(ctx->bio_in) != WRITE) {
1216                         memcpy(org_iv, tag_iv, cc->integrity_iv_size);
1217                 } else {
1218                         r = cc->iv_gen_ops->generator(cc, org_iv, dmreq);
1219                         if (r < 0)
1220                                 return r;
1221                         /* Store generated IV in integrity metadata */
1222                         if (cc->integrity_iv_size)
1223                                 memcpy(tag_iv, org_iv, cc->integrity_iv_size);
1224                 }
1225                 /* Working copy of IV, to be modified in crypto API */
1226                 memcpy(iv, org_iv, cc->iv_size);
1227         }
1228
1229         skcipher_request_set_crypt(req, sg_in, sg_out, cc->sector_size, iv);
1230
1231         if (bio_data_dir(ctx->bio_in) == WRITE)
1232                 r = crypto_skcipher_encrypt(req);
1233         else
1234                 r = crypto_skcipher_decrypt(req);
1235
1236         if (!r && cc->iv_gen_ops && cc->iv_gen_ops->post)
1237                 r = cc->iv_gen_ops->post(cc, org_iv, dmreq);
1238
1239         bio_advance_iter(ctx->bio_in, &ctx->iter_in, cc->sector_size);
1240         bio_advance_iter(ctx->bio_out, &ctx->iter_out, cc->sector_size);
1241
1242         return r;
1243 }
1244
1245 static void kcryptd_async_done(struct crypto_async_request *async_req,
1246                                int error);
1247
1248 static void crypt_alloc_req_skcipher(struct crypt_config *cc,
1249                                      struct convert_context *ctx)
1250 {
1251         unsigned key_index = ctx->cc_sector & (cc->tfms_count - 1);
1252
1253         if (!ctx->r.req)
1254                 ctx->r.req = mempool_alloc(cc->req_pool, GFP_NOIO);
1255
1256         skcipher_request_set_tfm(ctx->r.req, cc->cipher_tfm.tfms[key_index]);
1257
1258         /*
1259          * Use REQ_MAY_BACKLOG so a cipher driver internally backlogs
1260          * requests if driver request queue is full.
1261          */
1262         skcipher_request_set_callback(ctx->r.req,
1263             CRYPTO_TFM_REQ_MAY_BACKLOG,
1264             kcryptd_async_done, dmreq_of_req(cc, ctx->r.req));
1265 }
1266
1267 static void crypt_alloc_req_aead(struct crypt_config *cc,
1268                                  struct convert_context *ctx)
1269 {
1270         if (!ctx->r.req_aead)
1271                 ctx->r.req_aead = mempool_alloc(cc->req_pool, GFP_NOIO);
1272
1273         aead_request_set_tfm(ctx->r.req_aead, cc->cipher_tfm.tfms_aead[0]);
1274
1275         /*
1276          * Use REQ_MAY_BACKLOG so a cipher driver internally backlogs
1277          * requests if driver request queue is full.
1278          */
1279         aead_request_set_callback(ctx->r.req_aead,
1280             CRYPTO_TFM_REQ_MAY_BACKLOG,
1281             kcryptd_async_done, dmreq_of_req(cc, ctx->r.req_aead));
1282 }
1283
1284 static void crypt_alloc_req(struct crypt_config *cc,
1285                             struct convert_context *ctx)
1286 {
1287         if (crypt_integrity_aead(cc))
1288                 crypt_alloc_req_aead(cc, ctx);
1289         else
1290                 crypt_alloc_req_skcipher(cc, ctx);
1291 }
1292
1293 static void crypt_free_req_skcipher(struct crypt_config *cc,
1294                                     struct skcipher_request *req, struct bio *base_bio)
1295 {
1296         struct dm_crypt_io *io = dm_per_bio_data(base_bio, cc->per_bio_data_size);
1297
1298         if ((struct skcipher_request *)(io + 1) != req)
1299                 mempool_free(req, cc->req_pool);
1300 }
1301
1302 static void crypt_free_req_aead(struct crypt_config *cc,
1303                                 struct aead_request *req, struct bio *base_bio)
1304 {
1305         struct dm_crypt_io *io = dm_per_bio_data(base_bio, cc->per_bio_data_size);
1306
1307         if ((struct aead_request *)(io + 1) != req)
1308                 mempool_free(req, cc->req_pool);
1309 }
1310
1311 static void crypt_free_req(struct crypt_config *cc, void *req, struct bio *base_bio)
1312 {
1313         if (crypt_integrity_aead(cc))
1314                 crypt_free_req_aead(cc, req, base_bio);
1315         else
1316                 crypt_free_req_skcipher(cc, req, base_bio);
1317 }
1318
1319 /*
1320  * Encrypt / decrypt data from one bio to another one (can be the same one)
1321  */
1322 static blk_status_t crypt_convert(struct crypt_config *cc,
1323                          struct convert_context *ctx)
1324 {
1325         unsigned int tag_offset = 0;
1326         unsigned int sector_step = cc->sector_size >> SECTOR_SHIFT;
1327         int r;
1328
1329         atomic_set(&ctx->cc_pending, 1);
1330
1331         while (ctx->iter_in.bi_size && ctx->iter_out.bi_size) {
1332
1333                 crypt_alloc_req(cc, ctx);
1334                 atomic_inc(&ctx->cc_pending);
1335
1336                 if (crypt_integrity_aead(cc))
1337                         r = crypt_convert_block_aead(cc, ctx, ctx->r.req_aead, tag_offset);
1338                 else
1339                         r = crypt_convert_block_skcipher(cc, ctx, ctx->r.req, tag_offset);
1340
1341                 switch (r) {
1342                 /*
1343                  * The request was queued by a crypto driver
1344                  * but the driver request queue is full, let's wait.
1345                  */
1346                 case -EBUSY:
1347                         wait_for_completion(&ctx->restart);
1348                         reinit_completion(&ctx->restart);
1349                         /* fall through */
1350                 /*
1351                  * The request is queued and processed asynchronously,
1352                  * completion function kcryptd_async_done() will be called.
1353                  */
1354                 case -EINPROGRESS:
1355                         ctx->r.req = NULL;
1356                         ctx->cc_sector += sector_step;
1357                         tag_offset++;
1358                         continue;
1359                 /*
1360                  * The request was already processed (synchronously).
1361                  */
1362                 case 0:
1363                         atomic_dec(&ctx->cc_pending);
1364                         ctx->cc_sector += sector_step;
1365                         tag_offset++;
1366                         cond_resched();
1367                         continue;
1368                 /*
1369                  * There was a data integrity error.
1370                  */
1371                 case -EBADMSG:
1372                         atomic_dec(&ctx->cc_pending);
1373                         return BLK_STS_PROTECTION;
1374                 /*
1375                  * There was an error while processing the request.
1376                  */
1377                 default:
1378                         atomic_dec(&ctx->cc_pending);
1379                         return BLK_STS_IOERR;
1380                 }
1381         }
1382
1383         return 0;
1384 }
1385
1386 static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone);
1387
1388 /*
1389  * Generate a new unfragmented bio with the given size
1390  * This should never violate the device limitations (but only because
1391  * max_segment_size is being constrained to PAGE_SIZE).
1392  *
1393  * This function may be called concurrently. If we allocate from the mempool
1394  * concurrently, there is a possibility of deadlock. For example, if we have
1395  * mempool of 256 pages, two processes, each wanting 256, pages allocate from
1396  * the mempool concurrently, it may deadlock in a situation where both processes
1397  * have allocated 128 pages and the mempool is exhausted.
1398  *
1399  * In order to avoid this scenario we allocate the pages under a mutex.
1400  *
1401  * In order to not degrade performance with excessive locking, we try
1402  * non-blocking allocations without a mutex first but on failure we fallback
1403  * to blocking allocations with a mutex.
1404  */
1405 static struct bio *crypt_alloc_buffer(struct dm_crypt_io *io, unsigned size)
1406 {
1407         struct crypt_config *cc = io->cc;
1408         struct bio *clone;
1409         unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
1410         gfp_t gfp_mask = GFP_NOWAIT | __GFP_HIGHMEM;
1411         unsigned i, len, remaining_size;
1412         struct page *page;
1413
1414 retry:
1415         if (unlikely(gfp_mask & __GFP_DIRECT_RECLAIM))
1416                 mutex_lock(&cc->bio_alloc_lock);
1417
1418         clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
1419         if (!clone)
1420                 goto out;
1421
1422         clone_init(io, clone);
1423
1424         remaining_size = size;
1425
1426         for (i = 0; i < nr_iovecs; i++) {
1427                 page = mempool_alloc(cc->page_pool, gfp_mask);
1428                 if (!page) {
1429                         crypt_free_buffer_pages(cc, clone);
1430                         bio_put(clone);
1431                         gfp_mask |= __GFP_DIRECT_RECLAIM;
1432                         goto retry;
1433                 }
1434
1435                 len = (remaining_size > PAGE_SIZE) ? PAGE_SIZE : remaining_size;
1436
1437                 bio_add_page(clone, page, len, 0);
1438
1439                 remaining_size -= len;
1440         }
1441
1442         /* Allocate space for integrity tags */
1443         if (dm_crypt_integrity_io_alloc(io, clone)) {
1444                 crypt_free_buffer_pages(cc, clone);
1445                 bio_put(clone);
1446                 clone = NULL;
1447         }
1448 out:
1449         if (unlikely(gfp_mask & __GFP_DIRECT_RECLAIM))
1450                 mutex_unlock(&cc->bio_alloc_lock);
1451
1452         return clone;
1453 }
1454
1455 static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone)
1456 {
1457         unsigned int i;
1458         struct bio_vec *bv;
1459
1460         bio_for_each_segment_all(bv, clone, i) {
1461                 BUG_ON(!bv->bv_page);
1462                 mempool_free(bv->bv_page, cc->page_pool);
1463                 bv->bv_page = NULL;
1464         }
1465 }
1466
1467 static void crypt_io_init(struct dm_crypt_io *io, struct crypt_config *cc,
1468                           struct bio *bio, sector_t sector)
1469 {
1470         io->cc = cc;
1471         io->base_bio = bio;
1472         io->sector = sector;
1473         io->error = 0;
1474         io->ctx.r.req = NULL;
1475         io->integrity_metadata = NULL;
1476         io->integrity_metadata_from_pool = false;
1477         atomic_set(&io->io_pending, 0);
1478 }
1479
1480 static void crypt_inc_pending(struct dm_crypt_io *io)
1481 {
1482         atomic_inc(&io->io_pending);
1483 }
1484
1485 /*
1486  * One of the bios was finished. Check for completion of
1487  * the whole request and correctly clean up the buffer.
1488  */
1489 static void crypt_dec_pending(struct dm_crypt_io *io)
1490 {
1491         struct crypt_config *cc = io->cc;
1492         struct bio *base_bio = io->base_bio;
1493         blk_status_t error = io->error;
1494
1495         if (!atomic_dec_and_test(&io->io_pending))
1496                 return;
1497
1498         if (io->ctx.r.req)
1499                 crypt_free_req(cc, io->ctx.r.req, base_bio);
1500
1501         if (unlikely(io->integrity_metadata_from_pool))
1502                 mempool_free(io->integrity_metadata, io->cc->tag_pool);
1503         else
1504                 kfree(io->integrity_metadata);
1505
1506         base_bio->bi_status = error;
1507         bio_endio(base_bio);
1508 }
1509
1510 /*
1511  * kcryptd/kcryptd_io:
1512  *
1513  * Needed because it would be very unwise to do decryption in an
1514  * interrupt context.
1515  *
1516  * kcryptd performs the actual encryption or decryption.
1517  *
1518  * kcryptd_io performs the IO submission.
1519  *
1520  * They must be separated as otherwise the final stages could be
1521  * starved by new requests which can block in the first stages due
1522  * to memory allocation.
1523  *
1524  * The work is done per CPU global for all dm-crypt instances.
1525  * They should not depend on each other and do not block.
1526  */
1527 static void crypt_endio(struct bio *clone)
1528 {
1529         struct dm_crypt_io *io = clone->bi_private;
1530         struct crypt_config *cc = io->cc;
1531         unsigned rw = bio_data_dir(clone);
1532         blk_status_t error;
1533
1534         /*
1535          * free the processed pages
1536          */
1537         if (rw == WRITE)
1538                 crypt_free_buffer_pages(cc, clone);
1539
1540         error = clone->bi_status;
1541         bio_put(clone);
1542
1543         if (rw == READ && !error) {
1544                 kcryptd_queue_crypt(io);
1545                 return;
1546         }
1547
1548         if (unlikely(error))
1549                 io->error = error;
1550
1551         crypt_dec_pending(io);
1552 }
1553
1554 static void clone_init(struct dm_crypt_io *io, struct bio *clone)
1555 {
1556         struct crypt_config *cc = io->cc;
1557
1558         clone->bi_private = io;
1559         clone->bi_end_io  = crypt_endio;
1560         bio_set_dev(clone, cc->dev->bdev);
1561         clone->bi_opf     = io->base_bio->bi_opf;
1562 }
1563
1564 static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
1565 {
1566         struct crypt_config *cc = io->cc;
1567         struct bio *clone;
1568
1569         /*
1570          * We need the original biovec array in order to decrypt
1571          * the whole bio data *afterwards* -- thanks to immutable
1572          * biovecs we don't need to worry about the block layer
1573          * modifying the biovec array; so leverage bio_clone_fast().
1574          */
1575         clone = bio_clone_fast(io->base_bio, gfp, cc->bs);
1576         if (!clone)
1577                 return 1;
1578
1579         crypt_inc_pending(io);
1580
1581         clone_init(io, clone);
1582         clone->bi_iter.bi_sector = cc->start + io->sector;
1583
1584         if (dm_crypt_integrity_io_alloc(io, clone)) {
1585                 crypt_dec_pending(io);
1586                 bio_put(clone);
1587                 return 1;
1588         }
1589
1590         generic_make_request(clone);
1591         return 0;
1592 }
1593
1594 static void kcryptd_io_read_work(struct work_struct *work)
1595 {
1596         struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
1597
1598         crypt_inc_pending(io);
1599         if (kcryptd_io_read(io, GFP_NOIO))
1600                 io->error = BLK_STS_RESOURCE;
1601         crypt_dec_pending(io);
1602 }
1603
1604 static void kcryptd_queue_read(struct dm_crypt_io *io)
1605 {
1606         struct crypt_config *cc = io->cc;
1607
1608         INIT_WORK(&io->work, kcryptd_io_read_work);
1609         queue_work(cc->io_queue, &io->work);
1610 }
1611
1612 static void kcryptd_io_write(struct dm_crypt_io *io)
1613 {
1614         struct bio *clone = io->ctx.bio_out;
1615
1616         generic_make_request(clone);
1617 }
1618
1619 #define crypt_io_from_node(node) rb_entry((node), struct dm_crypt_io, rb_node)
1620
1621 static int dmcrypt_write(void *data)
1622 {
1623         struct crypt_config *cc = data;
1624         struct dm_crypt_io *io;
1625
1626         while (1) {
1627                 struct rb_root write_tree;
1628                 struct blk_plug plug;
1629
1630                 DECLARE_WAITQUEUE(wait, current);
1631
1632                 spin_lock_irq(&cc->write_thread_wait.lock);
1633 continue_locked:
1634
1635                 if (!RB_EMPTY_ROOT(&cc->write_tree))
1636                         goto pop_from_list;
1637
1638                 set_current_state(TASK_INTERRUPTIBLE);
1639                 __add_wait_queue(&cc->write_thread_wait, &wait);
1640
1641                 spin_unlock_irq(&cc->write_thread_wait.lock);
1642
1643                 if (unlikely(kthread_should_stop())) {
1644                         set_current_state(TASK_RUNNING);
1645                         remove_wait_queue(&cc->write_thread_wait, &wait);
1646                         break;
1647                 }
1648
1649                 schedule();
1650
1651                 set_current_state(TASK_RUNNING);
1652                 spin_lock_irq(&cc->write_thread_wait.lock);
1653                 __remove_wait_queue(&cc->write_thread_wait, &wait);
1654                 goto continue_locked;
1655
1656 pop_from_list:
1657                 write_tree = cc->write_tree;
1658                 cc->write_tree = RB_ROOT;
1659                 spin_unlock_irq(&cc->write_thread_wait.lock);
1660
1661                 BUG_ON(rb_parent(write_tree.rb_node));
1662
1663                 /*
1664                  * Note: we cannot walk the tree here with rb_next because
1665                  * the structures may be freed when kcryptd_io_write is called.
1666                  */
1667                 blk_start_plug(&plug);
1668                 do {
1669                         io = crypt_io_from_node(rb_first(&write_tree));
1670                         rb_erase(&io->rb_node, &write_tree);
1671                         kcryptd_io_write(io);
1672                 } while (!RB_EMPTY_ROOT(&write_tree));
1673                 blk_finish_plug(&plug);
1674         }
1675         return 0;
1676 }
1677
1678 static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int async)
1679 {
1680         struct bio *clone = io->ctx.bio_out;
1681         struct crypt_config *cc = io->cc;
1682         unsigned long flags;
1683         sector_t sector;
1684         struct rb_node **rbp, *parent;
1685
1686         if (unlikely(io->error)) {
1687                 crypt_free_buffer_pages(cc, clone);
1688                 bio_put(clone);
1689                 crypt_dec_pending(io);
1690                 return;
1691         }
1692
1693         /* crypt_convert should have filled the clone bio */
1694         BUG_ON(io->ctx.iter_out.bi_size);
1695
1696         clone->bi_iter.bi_sector = cc->start + io->sector;
1697
1698         if (likely(!async) && test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags)) {
1699                 generic_make_request(clone);
1700                 return;
1701         }
1702
1703         spin_lock_irqsave(&cc->write_thread_wait.lock, flags);
1704         rbp = &cc->write_tree.rb_node;
1705         parent = NULL;
1706         sector = io->sector;
1707         while (*rbp) {
1708                 parent = *rbp;
1709                 if (sector < crypt_io_from_node(parent)->sector)
1710                         rbp = &(*rbp)->rb_left;
1711                 else
1712                         rbp = &(*rbp)->rb_right;
1713         }
1714         rb_link_node(&io->rb_node, parent, rbp);
1715         rb_insert_color(&io->rb_node, &cc->write_tree);
1716
1717         wake_up_locked(&cc->write_thread_wait);
1718         spin_unlock_irqrestore(&cc->write_thread_wait.lock, flags);
1719 }
1720
1721 static void kcryptd_crypt_write_convert(struct dm_crypt_io *io)
1722 {
1723         struct crypt_config *cc = io->cc;
1724         struct bio *clone;
1725         int crypt_finished;
1726         sector_t sector = io->sector;
1727         blk_status_t r;
1728
1729         /*
1730          * Prevent io from disappearing until this function completes.
1731          */
1732         crypt_inc_pending(io);
1733         crypt_convert_init(cc, &io->ctx, NULL, io->base_bio, sector);
1734
1735         clone = crypt_alloc_buffer(io, io->base_bio->bi_iter.bi_size);
1736         if (unlikely(!clone)) {
1737                 io->error = BLK_STS_IOERR;
1738                 goto dec;
1739         }
1740
1741         io->ctx.bio_out = clone;
1742         io->ctx.iter_out = clone->bi_iter;
1743
1744         sector += bio_sectors(clone);
1745
1746         crypt_inc_pending(io);
1747         r = crypt_convert(cc, &io->ctx);
1748         if (r)
1749                 io->error = r;
1750         crypt_finished = atomic_dec_and_test(&io->ctx.cc_pending);
1751
1752         /* Encryption was already finished, submit io now */
1753         if (crypt_finished) {
1754                 kcryptd_crypt_write_io_submit(io, 0);
1755                 io->sector = sector;
1756         }
1757
1758 dec:
1759         crypt_dec_pending(io);
1760 }
1761
1762 static void kcryptd_crypt_read_done(struct dm_crypt_io *io)
1763 {
1764         crypt_dec_pending(io);
1765 }
1766
1767 static void kcryptd_crypt_read_convert(struct dm_crypt_io *io)
1768 {
1769         struct crypt_config *cc = io->cc;
1770         blk_status_t r;
1771
1772         crypt_inc_pending(io);
1773
1774         crypt_convert_init(cc, &io->ctx, io->base_bio, io->base_bio,
1775                            io->sector);
1776
1777         r = crypt_convert(cc, &io->ctx);
1778         if (r)
1779                 io->error = r;
1780
1781         if (atomic_dec_and_test(&io->ctx.cc_pending))
1782                 kcryptd_crypt_read_done(io);
1783
1784         crypt_dec_pending(io);
1785 }
1786
1787 static void kcryptd_async_done(struct crypto_async_request *async_req,
1788                                int error)
1789 {
1790         struct dm_crypt_request *dmreq = async_req->data;
1791         struct convert_context *ctx = dmreq->ctx;
1792         struct dm_crypt_io *io = container_of(ctx, struct dm_crypt_io, ctx);
1793         struct crypt_config *cc = io->cc;
1794
1795         /*
1796          * A request from crypto driver backlog is going to be processed now,
1797          * finish the completion and continue in crypt_convert().
1798          * (Callback will be called for the second time for this request.)
1799          */
1800         if (error == -EINPROGRESS) {
1801                 complete(&ctx->restart);
1802                 return;
1803         }
1804
1805         if (!error && cc->iv_gen_ops && cc->iv_gen_ops->post)
1806                 error = cc->iv_gen_ops->post(cc, org_iv_of_dmreq(cc, dmreq), dmreq);
1807
1808         if (error == -EBADMSG) {
1809                 DMERR_LIMIT("INTEGRITY AEAD ERROR, sector %llu",
1810                             (unsigned long long)le64_to_cpu(*org_sector_of_dmreq(cc, dmreq)));
1811                 io->error = BLK_STS_PROTECTION;
1812         } else if (error < 0)
1813                 io->error = BLK_STS_IOERR;
1814
1815         crypt_free_req(cc, req_of_dmreq(cc, dmreq), io->base_bio);
1816
1817         if (!atomic_dec_and_test(&ctx->cc_pending))
1818                 return;
1819
1820         if (bio_data_dir(io->base_bio) == READ)
1821                 kcryptd_crypt_read_done(io);
1822         else
1823                 kcryptd_crypt_write_io_submit(io, 1);
1824 }
1825
1826 static void kcryptd_crypt(struct work_struct *work)
1827 {
1828         struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
1829
1830         if (bio_data_dir(io->base_bio) == READ)
1831                 kcryptd_crypt_read_convert(io);
1832         else
1833                 kcryptd_crypt_write_convert(io);
1834 }
1835
1836 static void kcryptd_queue_crypt(struct dm_crypt_io *io)
1837 {
1838         struct crypt_config *cc = io->cc;
1839
1840         INIT_WORK(&io->work, kcryptd_crypt);
1841         queue_work(cc->crypt_queue, &io->work);
1842 }
1843
1844 static void crypt_free_tfms_aead(struct crypt_config *cc)
1845 {
1846         if (!cc->cipher_tfm.tfms_aead)
1847                 return;
1848
1849         if (cc->cipher_tfm.tfms_aead[0] && !IS_ERR(cc->cipher_tfm.tfms_aead[0])) {
1850                 crypto_free_aead(cc->cipher_tfm.tfms_aead[0]);
1851                 cc->cipher_tfm.tfms_aead[0] = NULL;
1852         }
1853
1854         kfree(cc->cipher_tfm.tfms_aead);
1855         cc->cipher_tfm.tfms_aead = NULL;
1856 }
1857
1858 static void crypt_free_tfms_skcipher(struct crypt_config *cc)
1859 {
1860         unsigned i;
1861
1862         if (!cc->cipher_tfm.tfms)
1863                 return;
1864
1865         for (i = 0; i < cc->tfms_count; i++)
1866                 if (cc->cipher_tfm.tfms[i] && !IS_ERR(cc->cipher_tfm.tfms[i])) {
1867                         crypto_free_skcipher(cc->cipher_tfm.tfms[i]);
1868                         cc->cipher_tfm.tfms[i] = NULL;
1869                 }
1870
1871         kfree(cc->cipher_tfm.tfms);
1872         cc->cipher_tfm.tfms = NULL;
1873 }
1874
1875 static void crypt_free_tfms(struct crypt_config *cc)
1876 {
1877         if (crypt_integrity_aead(cc))
1878                 crypt_free_tfms_aead(cc);
1879         else
1880                 crypt_free_tfms_skcipher(cc);
1881 }
1882
1883 static int crypt_alloc_tfms_skcipher(struct crypt_config *cc, char *ciphermode)
1884 {
1885         unsigned i;
1886         int err;
1887
1888         cc->cipher_tfm.tfms = kzalloc(cc->tfms_count *
1889                                       sizeof(struct crypto_skcipher *), GFP_KERNEL);
1890         if (!cc->cipher_tfm.tfms)
1891                 return -ENOMEM;
1892
1893         for (i = 0; i < cc->tfms_count; i++) {
1894                 cc->cipher_tfm.tfms[i] = crypto_alloc_skcipher(ciphermode, 0, 0);
1895                 if (IS_ERR(cc->cipher_tfm.tfms[i])) {
1896                         err = PTR_ERR(cc->cipher_tfm.tfms[i]);
1897                         crypt_free_tfms(cc);
1898                         return err;
1899                 }
1900         }
1901
1902         return 0;
1903 }
1904
1905 static int crypt_alloc_tfms_aead(struct crypt_config *cc, char *ciphermode)
1906 {
1907         int err;
1908
1909         cc->cipher_tfm.tfms = kmalloc(sizeof(struct crypto_aead *), GFP_KERNEL);
1910         if (!cc->cipher_tfm.tfms)
1911                 return -ENOMEM;
1912
1913         cc->cipher_tfm.tfms_aead[0] = crypto_alloc_aead(ciphermode, 0, 0);
1914         if (IS_ERR(cc->cipher_tfm.tfms_aead[0])) {
1915                 err = PTR_ERR(cc->cipher_tfm.tfms_aead[0]);
1916                 crypt_free_tfms(cc);
1917                 return err;
1918         }
1919
1920         return 0;
1921 }
1922
1923 static int crypt_alloc_tfms(struct crypt_config *cc, char *ciphermode)
1924 {
1925         if (crypt_integrity_aead(cc))
1926                 return crypt_alloc_tfms_aead(cc, ciphermode);
1927         else
1928                 return crypt_alloc_tfms_skcipher(cc, ciphermode);
1929 }
1930
1931 static unsigned crypt_subkey_size(struct crypt_config *cc)
1932 {
1933         return (cc->key_size - cc->key_extra_size) >> ilog2(cc->tfms_count);
1934 }
1935
1936 static unsigned crypt_authenckey_size(struct crypt_config *cc)
1937 {
1938         return crypt_subkey_size(cc) + RTA_SPACE(sizeof(struct crypto_authenc_key_param));
1939 }
1940
1941 /*
1942  * If AEAD is composed like authenc(hmac(sha256),xts(aes)),
1943  * the key must be for some reason in special format.
1944  * This funcion converts cc->key to this special format.
1945  */
1946 static void crypt_copy_authenckey(char *p, const void *key,
1947                                   unsigned enckeylen, unsigned authkeylen)
1948 {
1949         struct crypto_authenc_key_param *param;
1950         struct rtattr *rta;
1951
1952         rta = (struct rtattr *)p;
1953         param = RTA_DATA(rta);
1954         param->enckeylen = cpu_to_be32(enckeylen);
1955         rta->rta_len = RTA_LENGTH(sizeof(*param));
1956         rta->rta_type = CRYPTO_AUTHENC_KEYA_PARAM;
1957         p += RTA_SPACE(sizeof(*param));
1958         memcpy(p, key + enckeylen, authkeylen);
1959         p += authkeylen;
1960         memcpy(p, key, enckeylen);
1961 }
1962
1963 static int crypt_setkey(struct crypt_config *cc)
1964 {
1965         unsigned subkey_size;
1966         int err = 0, i, r;
1967
1968         /* Ignore extra keys (which are used for IV etc) */
1969         subkey_size = crypt_subkey_size(cc);
1970
1971         if (crypt_integrity_hmac(cc)) {
1972                 if (subkey_size < cc->key_mac_size)
1973                         return -EINVAL;
1974
1975                 crypt_copy_authenckey(cc->authenc_key, cc->key,
1976                                       subkey_size - cc->key_mac_size,
1977                                       cc->key_mac_size);
1978         }
1979
1980         for (i = 0; i < cc->tfms_count; i++) {
1981                 if (crypt_integrity_hmac(cc))
1982                         r = crypto_aead_setkey(cc->cipher_tfm.tfms_aead[i],
1983                                 cc->authenc_key, crypt_authenckey_size(cc));
1984                 else if (crypt_integrity_aead(cc))
1985                         r = crypto_aead_setkey(cc->cipher_tfm.tfms_aead[i],
1986                                                cc->key + (i * subkey_size),
1987                                                subkey_size);
1988                 else
1989                         r = crypto_skcipher_setkey(cc->cipher_tfm.tfms[i],
1990                                                    cc->key + (i * subkey_size),
1991                                                    subkey_size);
1992                 if (r)
1993                         err = r;
1994         }
1995
1996         if (crypt_integrity_hmac(cc))
1997                 memzero_explicit(cc->authenc_key, crypt_authenckey_size(cc));
1998
1999         return err;
2000 }
2001
2002 #ifdef CONFIG_KEYS
2003
2004 static bool contains_whitespace(const char *str)
2005 {
2006         while (*str)
2007                 if (isspace(*str++))
2008                         return true;
2009         return false;
2010 }
2011
2012 static int crypt_set_keyring_key(struct crypt_config *cc, const char *key_string)
2013 {
2014         char *new_key_string, *key_desc;
2015         int ret;
2016         struct key *key;
2017         const struct user_key_payload *ukp;
2018
2019         /*
2020          * Reject key_string with whitespace. dm core currently lacks code for
2021          * proper whitespace escaping in arguments on DM_TABLE_STATUS path.
2022          */
2023         if (contains_whitespace(key_string)) {
2024                 DMERR("whitespace chars not allowed in key string");
2025                 return -EINVAL;
2026         }
2027
2028         /* look for next ':' separating key_type from key_description */
2029         key_desc = strpbrk(key_string, ":");
2030         if (!key_desc || key_desc == key_string || !strlen(key_desc + 1))
2031                 return -EINVAL;
2032
2033         if (strncmp(key_string, "logon:", key_desc - key_string + 1) &&
2034             strncmp(key_string, "user:", key_desc - key_string + 1))
2035                 return -EINVAL;
2036
2037         new_key_string = kstrdup(key_string, GFP_KERNEL);
2038         if (!new_key_string)
2039                 return -ENOMEM;
2040
2041         key = request_key(key_string[0] == 'l' ? &key_type_logon : &key_type_user,
2042                           key_desc + 1, NULL);
2043         if (IS_ERR(key)) {
2044                 kzfree(new_key_string);
2045                 return PTR_ERR(key);
2046         }
2047
2048         down_read(&key->sem);
2049
2050         ukp = user_key_payload_locked(key);
2051         if (!ukp) {
2052                 up_read(&key->sem);
2053                 key_put(key);
2054                 kzfree(new_key_string);
2055                 return -EKEYREVOKED;
2056         }
2057
2058         if (cc->key_size != ukp->datalen) {
2059                 up_read(&key->sem);
2060                 key_put(key);
2061                 kzfree(new_key_string);
2062                 return -EINVAL;
2063         }
2064
2065         memcpy(cc->key, ukp->data, cc->key_size);
2066
2067         up_read(&key->sem);
2068         key_put(key);
2069
2070         /* clear the flag since following operations may invalidate previously valid key */
2071         clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
2072
2073         ret = crypt_setkey(cc);
2074
2075         if (!ret) {
2076                 set_bit(DM_CRYPT_KEY_VALID, &cc->flags);
2077                 kzfree(cc->key_string);
2078                 cc->key_string = new_key_string;
2079         } else
2080                 kzfree(new_key_string);
2081
2082         return ret;
2083 }
2084
2085 static int get_key_size(char **key_string)
2086 {
2087         char *colon, dummy;
2088         int ret;
2089
2090         if (*key_string[0] != ':')
2091                 return strlen(*key_string) >> 1;
2092
2093         /* look for next ':' in key string */
2094         colon = strpbrk(*key_string + 1, ":");
2095         if (!colon)
2096                 return -EINVAL;
2097
2098         if (sscanf(*key_string + 1, "%u%c", &ret, &dummy) != 2 || dummy != ':')
2099                 return -EINVAL;
2100
2101         *key_string = colon;
2102
2103         /* remaining key string should be :<logon|user>:<key_desc> */
2104
2105         return ret;
2106 }
2107
2108 #else
2109
2110 static int crypt_set_keyring_key(struct crypt_config *cc, const char *key_string)
2111 {
2112         return -EINVAL;
2113 }
2114
2115 static int get_key_size(char **key_string)
2116 {
2117         return (*key_string[0] == ':') ? -EINVAL : strlen(*key_string) >> 1;
2118 }
2119
2120 #endif
2121
2122 static int crypt_set_key(struct crypt_config *cc, char *key)
2123 {
2124         int r = -EINVAL;
2125         int key_string_len = strlen(key);
2126
2127         /* Hyphen (which gives a key_size of zero) means there is no key. */
2128         if (!cc->key_size && strcmp(key, "-"))
2129                 goto out;
2130
2131         /* ':' means the key is in kernel keyring, short-circuit normal key processing */
2132         if (key[0] == ':') {
2133                 r = crypt_set_keyring_key(cc, key + 1);
2134                 goto out;
2135         }
2136
2137         /* clear the flag since following operations may invalidate previously valid key */
2138         clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
2139
2140         /* wipe references to any kernel keyring key */
2141         kzfree(cc->key_string);
2142         cc->key_string = NULL;
2143
2144         /* Decode key from its hex representation. */
2145         if (cc->key_size && hex2bin(cc->key, key, cc->key_size) < 0)
2146                 goto out;
2147
2148         r = crypt_setkey(cc);
2149         if (!r)
2150                 set_bit(DM_CRYPT_KEY_VALID, &cc->flags);
2151
2152 out:
2153         /* Hex key string not needed after here, so wipe it. */
2154         memset(key, '0', key_string_len);
2155
2156         return r;
2157 }
2158
2159 static int crypt_wipe_key(struct crypt_config *cc)
2160 {
2161         int r;
2162
2163         clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
2164         get_random_bytes(&cc->key, cc->key_size);
2165         kzfree(cc->key_string);
2166         cc->key_string = NULL;
2167         r = crypt_setkey(cc);
2168         memset(&cc->key, 0, cc->key_size * sizeof(u8));
2169
2170         return r;
2171 }
2172
2173 static void crypt_calculate_pages_per_client(void)
2174 {
2175         unsigned long pages = (totalram_pages - totalhigh_pages) * DM_CRYPT_MEMORY_PERCENT / 100;
2176
2177         if (!dm_crypt_clients_n)
2178                 return;
2179
2180         pages /= dm_crypt_clients_n;
2181         if (pages < DM_CRYPT_MIN_PAGES_PER_CLIENT)
2182                 pages = DM_CRYPT_MIN_PAGES_PER_CLIENT;
2183         dm_crypt_pages_per_client = pages;
2184 }
2185
2186 static void *crypt_page_alloc(gfp_t gfp_mask, void *pool_data)
2187 {
2188         struct crypt_config *cc = pool_data;
2189         struct page *page;
2190
2191         /*
2192          * Note, percpu_counter_read_positive() may over (and under) estimate
2193          * the current usage by at most (batch - 1) * num_online_cpus() pages,
2194          * but avoids potential spinlock contention of an exact result.
2195          */
2196         if (unlikely(percpu_counter_read_positive(&cc->n_allocated_pages) >= dm_crypt_pages_per_client) &&
2197             likely(gfp_mask & __GFP_NORETRY))
2198                 return NULL;
2199
2200         page = alloc_page(gfp_mask);
2201         if (likely(page != NULL))
2202                 percpu_counter_add(&cc->n_allocated_pages, 1);
2203
2204         return page;
2205 }
2206
2207 static void crypt_page_free(void *page, void *pool_data)
2208 {
2209         struct crypt_config *cc = pool_data;
2210
2211         __free_page(page);
2212         percpu_counter_sub(&cc->n_allocated_pages, 1);
2213 }
2214
2215 static void crypt_dtr(struct dm_target *ti)
2216 {
2217         struct crypt_config *cc = ti->private;
2218
2219         ti->private = NULL;
2220
2221         if (!cc)
2222                 return;
2223
2224         if (cc->write_thread)
2225                 kthread_stop(cc->write_thread);
2226
2227         if (cc->io_queue)
2228                 destroy_workqueue(cc->io_queue);
2229         if (cc->crypt_queue)
2230                 destroy_workqueue(cc->crypt_queue);
2231
2232         crypt_free_tfms(cc);
2233
2234         if (cc->bs)
2235                 bioset_free(cc->bs);
2236
2237         mempool_destroy(cc->page_pool);
2238         mempool_destroy(cc->req_pool);
2239         mempool_destroy(cc->tag_pool);
2240
2241         if (cc->page_pool)
2242                 WARN_ON(percpu_counter_sum(&cc->n_allocated_pages) != 0);
2243         percpu_counter_destroy(&cc->n_allocated_pages);
2244
2245         if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
2246                 cc->iv_gen_ops->dtr(cc);
2247
2248         if (cc->dev)
2249                 dm_put_device(ti, cc->dev);
2250
2251         kzfree(cc->cipher);
2252         kzfree(cc->cipher_string);
2253         kzfree(cc->key_string);
2254         kzfree(cc->cipher_auth);
2255         kzfree(cc->authenc_key);
2256
2257         /* Must zero key material before freeing */
2258         kzfree(cc);
2259
2260         spin_lock(&dm_crypt_clients_lock);
2261         WARN_ON(!dm_crypt_clients_n);
2262         dm_crypt_clients_n--;
2263         crypt_calculate_pages_per_client();
2264         spin_unlock(&dm_crypt_clients_lock);
2265 }
2266
2267 static int crypt_ctr_ivmode(struct dm_target *ti, const char *ivmode)
2268 {
2269         struct crypt_config *cc = ti->private;
2270
2271         if (crypt_integrity_aead(cc))
2272                 cc->iv_size = crypto_aead_ivsize(any_tfm_aead(cc));
2273         else
2274                 cc->iv_size = crypto_skcipher_ivsize(any_tfm(cc));
2275
2276         if (cc->iv_size)
2277                 /* at least a 64 bit sector number should fit in our buffer */
2278                 cc->iv_size = max(cc->iv_size,
2279                                   (unsigned int)(sizeof(u64) / sizeof(u8)));
2280         else if (ivmode) {
2281                 DMWARN("Selected cipher does not support IVs");
2282                 ivmode = NULL;
2283         }
2284
2285         /* Choose ivmode, see comments at iv code. */
2286         if (ivmode == NULL)
2287                 cc->iv_gen_ops = NULL;
2288         else if (strcmp(ivmode, "plain") == 0)
2289                 cc->iv_gen_ops = &crypt_iv_plain_ops;
2290         else if (strcmp(ivmode, "plain64") == 0)
2291                 cc->iv_gen_ops = &crypt_iv_plain64_ops;
2292         else if (strcmp(ivmode, "plain64be") == 0)
2293                 cc->iv_gen_ops = &crypt_iv_plain64be_ops;
2294         else if (strcmp(ivmode, "essiv") == 0)
2295                 cc->iv_gen_ops = &crypt_iv_essiv_ops;
2296         else if (strcmp(ivmode, "benbi") == 0)
2297                 cc->iv_gen_ops = &crypt_iv_benbi_ops;
2298         else if (strcmp(ivmode, "null") == 0)
2299                 cc->iv_gen_ops = &crypt_iv_null_ops;
2300         else if (strcmp(ivmode, "lmk") == 0) {
2301                 cc->iv_gen_ops = &crypt_iv_lmk_ops;
2302                 /*
2303                  * Version 2 and 3 is recognised according
2304                  * to length of provided multi-key string.
2305                  * If present (version 3), last key is used as IV seed.
2306                  * All keys (including IV seed) are always the same size.
2307                  */
2308                 if (cc->key_size % cc->key_parts) {
2309                         cc->key_parts++;
2310                         cc->key_extra_size = cc->key_size / cc->key_parts;
2311                 }
2312         } else if (strcmp(ivmode, "tcw") == 0) {
2313                 cc->iv_gen_ops = &crypt_iv_tcw_ops;
2314                 cc->key_parts += 2; /* IV + whitening */
2315                 cc->key_extra_size = cc->iv_size + TCW_WHITENING_SIZE;
2316         } else if (strcmp(ivmode, "random") == 0) {
2317                 cc->iv_gen_ops = &crypt_iv_random_ops;
2318                 /* Need storage space in integrity fields. */
2319                 cc->integrity_iv_size = cc->iv_size;
2320         } else {
2321                 ti->error = "Invalid IV mode";
2322                 return -EINVAL;
2323         }
2324
2325         return 0;
2326 }
2327
2328 /*
2329  * Workaround to parse cipher algorithm from crypto API spec.
2330  * The cc->cipher is currently used only in ESSIV.
2331  * This should be probably done by crypto-api calls (once available...)
2332  */
2333 static int crypt_ctr_blkdev_cipher(struct crypt_config *cc)
2334 {
2335         const char *alg_name = NULL;
2336         char *start, *end;
2337
2338         if (crypt_integrity_aead(cc)) {
2339                 alg_name = crypto_tfm_alg_name(crypto_aead_tfm(any_tfm_aead(cc)));
2340                 if (!alg_name)
2341                         return -EINVAL;
2342                 if (crypt_integrity_hmac(cc)) {
2343                         alg_name = strchr(alg_name, ',');
2344                         if (!alg_name)
2345                                 return -EINVAL;
2346                 }
2347                 alg_name++;
2348         } else {
2349                 alg_name = crypto_tfm_alg_name(crypto_skcipher_tfm(any_tfm(cc)));
2350                 if (!alg_name)
2351                         return -EINVAL;
2352         }
2353
2354         start = strchr(alg_name, '(');
2355         end = strchr(alg_name, ')');
2356
2357         if (!start && !end) {
2358                 cc->cipher = kstrdup(alg_name, GFP_KERNEL);
2359                 return cc->cipher ? 0 : -ENOMEM;
2360         }
2361
2362         if (!start || !end || ++start >= end)
2363                 return -EINVAL;
2364
2365         cc->cipher = kzalloc(end - start + 1, GFP_KERNEL);
2366         if (!cc->cipher)
2367                 return -ENOMEM;
2368
2369         strncpy(cc->cipher, start, end - start);
2370
2371         return 0;
2372 }
2373
2374 /*
2375  * Workaround to parse HMAC algorithm from AEAD crypto API spec.
2376  * The HMAC is needed to calculate tag size (HMAC digest size).
2377  * This should be probably done by crypto-api calls (once available...)
2378  */
2379 static int crypt_ctr_auth_cipher(struct crypt_config *cc, char *cipher_api)
2380 {
2381         char *start, *end, *mac_alg = NULL;
2382         struct crypto_ahash *mac;
2383
2384         if (!strstarts(cipher_api, "authenc("))
2385                 return 0;
2386
2387         start = strchr(cipher_api, '(');
2388         end = strchr(cipher_api, ',');
2389         if (!start || !end || ++start > end)
2390                 return -EINVAL;
2391
2392         mac_alg = kzalloc(end - start + 1, GFP_KERNEL);
2393         if (!mac_alg)
2394                 return -ENOMEM;
2395         strncpy(mac_alg, start, end - start);
2396
2397         mac = crypto_alloc_ahash(mac_alg, 0, 0);
2398         kfree(mac_alg);
2399
2400         if (IS_ERR(mac))
2401                 return PTR_ERR(mac);
2402
2403         cc->key_mac_size = crypto_ahash_digestsize(mac);
2404         crypto_free_ahash(mac);
2405
2406         cc->authenc_key = kmalloc(crypt_authenckey_size(cc), GFP_KERNEL);
2407         if (!cc->authenc_key)
2408                 return -ENOMEM;
2409
2410         return 0;
2411 }
2412
2413 static int crypt_ctr_cipher_new(struct dm_target *ti, char *cipher_in, char *key,
2414                                 char **ivmode, char **ivopts)
2415 {
2416         struct crypt_config *cc = ti->private;
2417         char *tmp, *cipher_api;
2418         int ret = -EINVAL;
2419
2420         cc->tfms_count = 1;
2421
2422         /*
2423          * New format (capi: prefix)
2424          * capi:cipher_api_spec-iv:ivopts
2425          */
2426         tmp = &cipher_in[strlen("capi:")];
2427
2428         /* Separate IV options if present, it can contain another '-' in hash name */
2429         *ivopts = strrchr(tmp, ':');
2430         if (*ivopts) {
2431                 **ivopts = '\0';
2432                 (*ivopts)++;
2433         }
2434         /* Parse IV mode */
2435         *ivmode = strrchr(tmp, '-');
2436         if (*ivmode) {
2437                 **ivmode = '\0';
2438                 (*ivmode)++;
2439         }
2440         /* The rest is crypto API spec */
2441         cipher_api = tmp;
2442
2443         if (*ivmode && !strcmp(*ivmode, "lmk"))
2444                 cc->tfms_count = 64;
2445
2446         cc->key_parts = cc->tfms_count;
2447
2448         /* Allocate cipher */
2449         ret = crypt_alloc_tfms(cc, cipher_api);
2450         if (ret < 0) {
2451                 ti->error = "Error allocating crypto tfm";
2452                 return ret;
2453         }
2454
2455         /* Alloc AEAD, can be used only in new format. */
2456         if (crypt_integrity_aead(cc)) {
2457                 ret = crypt_ctr_auth_cipher(cc, cipher_api);
2458                 if (ret < 0) {
2459                         ti->error = "Invalid AEAD cipher spec";
2460                         return -ENOMEM;
2461                 }
2462                 cc->iv_size = crypto_aead_ivsize(any_tfm_aead(cc));
2463         } else
2464                 cc->iv_size = crypto_skcipher_ivsize(any_tfm(cc));
2465
2466         ret = crypt_ctr_blkdev_cipher(cc);
2467         if (ret < 0) {
2468                 ti->error = "Cannot allocate cipher string";
2469                 return -ENOMEM;
2470         }
2471
2472         return 0;
2473 }
2474
2475 static int crypt_ctr_cipher_old(struct dm_target *ti, char *cipher_in, char *key,
2476                                 char **ivmode, char **ivopts)
2477 {
2478         struct crypt_config *cc = ti->private;
2479         char *tmp, *cipher, *chainmode, *keycount;
2480         char *cipher_api = NULL;
2481         int ret = -EINVAL;
2482         char dummy;
2483
2484         if (strchr(cipher_in, '(') || crypt_integrity_aead(cc)) {
2485                 ti->error = "Bad cipher specification";
2486                 return -EINVAL;
2487         }
2488
2489         /*
2490          * Legacy dm-crypt cipher specification
2491          * cipher[:keycount]-mode-iv:ivopts
2492          */
2493         tmp = cipher_in;
2494         keycount = strsep(&tmp, "-");
2495         cipher = strsep(&keycount, ":");
2496
2497         if (!keycount)
2498                 cc->tfms_count = 1;
2499         else if (sscanf(keycount, "%u%c", &cc->tfms_count, &dummy) != 1 ||
2500                  !is_power_of_2(cc->tfms_count)) {
2501                 ti->error = "Bad cipher key count specification";
2502                 return -EINVAL;
2503         }
2504         cc->key_parts = cc->tfms_count;
2505
2506         cc->cipher = kstrdup(cipher, GFP_KERNEL);
2507         if (!cc->cipher)
2508                 goto bad_mem;
2509
2510         chainmode = strsep(&tmp, "-");
2511         *ivmode = strsep(&tmp, ":");
2512         *ivopts = tmp;
2513
2514         /*
2515          * For compatibility with the original dm-crypt mapping format, if
2516          * only the cipher name is supplied, use cbc-plain.
2517          */
2518         if (!chainmode || (!strcmp(chainmode, "plain") && !*ivmode)) {
2519                 chainmode = "cbc";
2520                 *ivmode = "plain";
2521         }
2522
2523         if (strcmp(chainmode, "ecb") && !*ivmode) {
2524                 ti->error = "IV mechanism required";
2525                 return -EINVAL;
2526         }
2527
2528         cipher_api = kmalloc(CRYPTO_MAX_ALG_NAME, GFP_KERNEL);
2529         if (!cipher_api)
2530                 goto bad_mem;
2531
2532         ret = snprintf(cipher_api, CRYPTO_MAX_ALG_NAME,
2533                        "%s(%s)", chainmode, cipher);
2534         if (ret < 0) {
2535                 kfree(cipher_api);
2536                 goto bad_mem;
2537         }
2538
2539         /* Allocate cipher */
2540         ret = crypt_alloc_tfms(cc, cipher_api);
2541         if (ret < 0) {
2542                 ti->error = "Error allocating crypto tfm";
2543                 kfree(cipher_api);
2544                 return ret;
2545         }
2546         kfree(cipher_api);
2547
2548         return 0;
2549 bad_mem:
2550         ti->error = "Cannot allocate cipher strings";
2551         return -ENOMEM;
2552 }
2553
2554 static int crypt_ctr_cipher(struct dm_target *ti, char *cipher_in, char *key)
2555 {
2556         struct crypt_config *cc = ti->private;
2557         char *ivmode = NULL, *ivopts = NULL;
2558         int ret;
2559
2560         cc->cipher_string = kstrdup(cipher_in, GFP_KERNEL);
2561         if (!cc->cipher_string) {
2562                 ti->error = "Cannot allocate cipher strings";
2563                 return -ENOMEM;
2564         }
2565
2566         if (strstarts(cipher_in, "capi:"))
2567                 ret = crypt_ctr_cipher_new(ti, cipher_in, key, &ivmode, &ivopts);
2568         else
2569                 ret = crypt_ctr_cipher_old(ti, cipher_in, key, &ivmode, &ivopts);
2570         if (ret)
2571                 return ret;
2572
2573         /* Initialize IV */
2574         ret = crypt_ctr_ivmode(ti, ivmode);
2575         if (ret < 0)
2576                 return ret;
2577
2578         /* Initialize and set key */
2579         ret = crypt_set_key(cc, key);
2580         if (ret < 0) {
2581                 ti->error = "Error decoding and setting key";
2582                 return ret;
2583         }
2584
2585         /* Allocate IV */
2586         if (cc->iv_gen_ops && cc->iv_gen_ops->ctr) {
2587                 ret = cc->iv_gen_ops->ctr(cc, ti, ivopts);
2588                 if (ret < 0) {
2589                         ti->error = "Error creating IV";
2590                         return ret;
2591                 }
2592         }
2593
2594         /* Initialize IV (set keys for ESSIV etc) */
2595         if (cc->iv_gen_ops && cc->iv_gen_ops->init) {
2596                 ret = cc->iv_gen_ops->init(cc);
2597                 if (ret < 0) {
2598                         ti->error = "Error initialising IV";
2599                         return ret;
2600                 }
2601         }
2602
2603         /* wipe the kernel key payload copy */
2604         if (cc->key_string)
2605                 memset(cc->key, 0, cc->key_size * sizeof(u8));
2606
2607         return ret;
2608 }
2609
2610 static int crypt_ctr_optional(struct dm_target *ti, unsigned int argc, char **argv)
2611 {
2612         struct crypt_config *cc = ti->private;
2613         struct dm_arg_set as;
2614         static const struct dm_arg _args[] = {
2615                 {0, 6, "Invalid number of feature args"},
2616         };
2617         unsigned int opt_params, val;
2618         const char *opt_string, *sval;
2619         char dummy;
2620         int ret;
2621
2622         /* Optional parameters */
2623         as.argc = argc;
2624         as.argv = argv;
2625
2626         ret = dm_read_arg_group(_args, &as, &opt_params, &ti->error);
2627         if (ret)
2628                 return ret;
2629
2630         while (opt_params--) {
2631                 opt_string = dm_shift_arg(&as);
2632                 if (!opt_string) {
2633                         ti->error = "Not enough feature arguments";
2634                         return -EINVAL;
2635                 }
2636
2637                 if (!strcasecmp(opt_string, "allow_discards"))
2638                         ti->num_discard_bios = 1;
2639
2640                 else if (!strcasecmp(opt_string, "same_cpu_crypt"))
2641                         set_bit(DM_CRYPT_SAME_CPU, &cc->flags);
2642
2643                 else if (!strcasecmp(opt_string, "submit_from_crypt_cpus"))
2644                         set_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags);
2645                 else if (sscanf(opt_string, "integrity:%u:", &val) == 1) {
2646                         if (val == 0 || val > MAX_TAG_SIZE) {
2647                                 ti->error = "Invalid integrity arguments";
2648                                 return -EINVAL;
2649                         }
2650                         cc->on_disk_tag_size = val;
2651                         sval = strchr(opt_string + strlen("integrity:"), ':') + 1;
2652                         if (!strcasecmp(sval, "aead")) {
2653                                 set_bit(CRYPT_MODE_INTEGRITY_AEAD, &cc->cipher_flags);
2654                         } else  if (strcasecmp(sval, "none")) {
2655                                 ti->error = "Unknown integrity profile";
2656                                 return -EINVAL;
2657                         }
2658
2659                         cc->cipher_auth = kstrdup(sval, GFP_KERNEL);
2660                         if (!cc->cipher_auth)
2661                                 return -ENOMEM;
2662                 } else if (sscanf(opt_string, "sector_size:%hu%c", &cc->sector_size, &dummy) == 1) {
2663                         if (cc->sector_size < (1 << SECTOR_SHIFT) ||
2664                             cc->sector_size > 4096 ||
2665                             (cc->sector_size & (cc->sector_size - 1))) {
2666                                 ti->error = "Invalid feature value for sector_size";
2667                                 return -EINVAL;
2668                         }
2669                         if (ti->len & ((cc->sector_size >> SECTOR_SHIFT) - 1)) {
2670                                 ti->error = "Device size is not multiple of sector_size feature";
2671                                 return -EINVAL;
2672                         }
2673                         cc->sector_shift = __ffs(cc->sector_size) - SECTOR_SHIFT;
2674                 } else if (!strcasecmp(opt_string, "iv_large_sectors"))
2675                         set_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags);
2676                 else {
2677                         ti->error = "Invalid feature arguments";
2678                         return -EINVAL;
2679                 }
2680         }
2681
2682         return 0;
2683 }
2684
2685 /*
2686  * Construct an encryption mapping:
2687  * <cipher> [<key>|:<key_size>:<user|logon>:<key_description>] <iv_offset> <dev_path> <start>
2688  */
2689 static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
2690 {
2691         struct crypt_config *cc;
2692         int key_size;
2693         unsigned int align_mask;
2694         unsigned long long tmpll;
2695         int ret;
2696         size_t iv_size_padding, additional_req_size;
2697         char dummy;
2698
2699         if (argc < 5) {
2700                 ti->error = "Not enough arguments";
2701                 return -EINVAL;
2702         }
2703
2704         key_size = get_key_size(&argv[1]);
2705         if (key_size < 0) {
2706                 ti->error = "Cannot parse key size";
2707                 return -EINVAL;
2708         }
2709
2710         cc = kzalloc(sizeof(*cc) + key_size * sizeof(u8), GFP_KERNEL);
2711         if (!cc) {
2712                 ti->error = "Cannot allocate encryption context";
2713                 return -ENOMEM;
2714         }
2715         cc->key_size = key_size;
2716         cc->sector_size = (1 << SECTOR_SHIFT);
2717         cc->sector_shift = 0;
2718
2719         ti->private = cc;
2720
2721         spin_lock(&dm_crypt_clients_lock);
2722         dm_crypt_clients_n++;
2723         crypt_calculate_pages_per_client();
2724         spin_unlock(&dm_crypt_clients_lock);
2725
2726         ret = percpu_counter_init(&cc->n_allocated_pages, 0, GFP_KERNEL);
2727         if (ret < 0)
2728                 goto bad;
2729
2730         /* Optional parameters need to be read before cipher constructor */
2731         if (argc > 5) {
2732                 ret = crypt_ctr_optional(ti, argc - 5, &argv[5]);
2733                 if (ret)
2734                         goto bad;
2735         }
2736
2737         ret = crypt_ctr_cipher(ti, argv[0], argv[1]);
2738         if (ret < 0)
2739                 goto bad;
2740
2741         if (crypt_integrity_aead(cc)) {
2742                 cc->dmreq_start = sizeof(struct aead_request);
2743                 cc->dmreq_start += crypto_aead_reqsize(any_tfm_aead(cc));
2744                 align_mask = crypto_aead_alignmask(any_tfm_aead(cc));
2745         } else {
2746                 cc->dmreq_start = sizeof(struct skcipher_request);
2747                 cc->dmreq_start += crypto_skcipher_reqsize(any_tfm(cc));
2748                 align_mask = crypto_skcipher_alignmask(any_tfm(cc));
2749         }
2750         cc->dmreq_start = ALIGN(cc->dmreq_start, __alignof__(struct dm_crypt_request));
2751
2752         if (align_mask < CRYPTO_MINALIGN) {
2753                 /* Allocate the padding exactly */
2754                 iv_size_padding = -(cc->dmreq_start + sizeof(struct dm_crypt_request))
2755                                 & align_mask;
2756         } else {
2757                 /*
2758                  * If the cipher requires greater alignment than kmalloc
2759                  * alignment, we don't know the exact position of the
2760                  * initialization vector. We must assume worst case.
2761                  */
2762                 iv_size_padding = align_mask;
2763         }
2764
2765         ret = -ENOMEM;
2766
2767         /*  ...| IV + padding | original IV | original sec. number | bio tag offset | */
2768         additional_req_size = sizeof(struct dm_crypt_request) +
2769                 iv_size_padding + cc->iv_size +
2770                 cc->iv_size +
2771                 sizeof(uint64_t) +
2772                 sizeof(unsigned int);
2773
2774         cc->req_pool = mempool_create_kmalloc_pool(MIN_IOS, cc->dmreq_start + additional_req_size);
2775         if (!cc->req_pool) {
2776                 ti->error = "Cannot allocate crypt request mempool";
2777                 goto bad;
2778         }
2779
2780         cc->per_bio_data_size = ti->per_io_data_size =
2781                 ALIGN(sizeof(struct dm_crypt_io) + cc->dmreq_start + additional_req_size,
2782                       ARCH_KMALLOC_MINALIGN);
2783
2784         cc->page_pool = mempool_create(BIO_MAX_PAGES, crypt_page_alloc, crypt_page_free, cc);
2785         if (!cc->page_pool) {
2786                 ti->error = "Cannot allocate page mempool";
2787                 goto bad;
2788         }
2789
2790         cc->bs = bioset_create(MIN_IOS, 0, (BIOSET_NEED_BVECS |
2791                                             BIOSET_NEED_RESCUER));
2792         if (!cc->bs) {
2793                 ti->error = "Cannot allocate crypt bioset";
2794                 goto bad;
2795         }
2796
2797         mutex_init(&cc->bio_alloc_lock);
2798
2799         ret = -EINVAL;
2800         if ((sscanf(argv[2], "%llu%c", &tmpll, &dummy) != 1) ||
2801             (tmpll & ((cc->sector_size >> SECTOR_SHIFT) - 1))) {
2802                 ti->error = "Invalid iv_offset sector";
2803                 goto bad;
2804         }
2805         cc->iv_offset = tmpll;
2806
2807         ret = dm_get_device(ti, argv[3], dm_table_get_mode(ti->table), &cc->dev);
2808         if (ret) {
2809                 ti->error = "Device lookup failed";
2810                 goto bad;
2811         }
2812
2813         ret = -EINVAL;
2814         if (sscanf(argv[4], "%llu%c", &tmpll, &dummy) != 1) {
2815                 ti->error = "Invalid device sector";
2816                 goto bad;
2817         }
2818         cc->start = tmpll;
2819
2820         if (crypt_integrity_aead(cc) || cc->integrity_iv_size) {
2821                 ret = crypt_integrity_ctr(cc, ti);
2822                 if (ret)
2823                         goto bad;
2824
2825                 cc->tag_pool_max_sectors = POOL_ENTRY_SIZE / cc->on_disk_tag_size;
2826                 if (!cc->tag_pool_max_sectors)
2827                         cc->tag_pool_max_sectors = 1;
2828
2829                 cc->tag_pool = mempool_create_kmalloc_pool(MIN_IOS,
2830                         cc->tag_pool_max_sectors * cc->on_disk_tag_size);
2831                 if (!cc->tag_pool) {
2832                         ti->error = "Cannot allocate integrity tags mempool";
2833                         ret = -ENOMEM;
2834                         goto bad;
2835                 }
2836
2837                 cc->tag_pool_max_sectors <<= cc->sector_shift;
2838         }
2839
2840         ret = -ENOMEM;
2841         cc->io_queue = alloc_workqueue("kcryptd_io", WQ_HIGHPRI | WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM, 1);
2842         if (!cc->io_queue) {
2843                 ti->error = "Couldn't create kcryptd io queue";
2844                 goto bad;
2845         }
2846
2847         if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags))
2848                 cc->crypt_queue = alloc_workqueue("kcryptd", WQ_HIGHPRI | WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM, 1);
2849         else
2850                 cc->crypt_queue = alloc_workqueue("kcryptd",
2851                                                   WQ_HIGHPRI | WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM | WQ_UNBOUND,
2852                                                   num_online_cpus());
2853         if (!cc->crypt_queue) {
2854                 ti->error = "Couldn't create kcryptd queue";
2855                 goto bad;
2856         }
2857
2858         init_waitqueue_head(&cc->write_thread_wait);
2859         cc->write_tree = RB_ROOT;
2860
2861         cc->write_thread = kthread_create(dmcrypt_write, cc, "dmcrypt_write");
2862         if (IS_ERR(cc->write_thread)) {
2863                 ret = PTR_ERR(cc->write_thread);
2864                 cc->write_thread = NULL;
2865                 ti->error = "Couldn't spawn write thread";
2866                 goto bad;
2867         }
2868         wake_up_process(cc->write_thread);
2869
2870         ti->num_flush_bios = 1;
2871
2872         return 0;
2873
2874 bad:
2875         crypt_dtr(ti);
2876         return ret;
2877 }
2878
2879 static int crypt_map(struct dm_target *ti, struct bio *bio)
2880 {
2881         struct dm_crypt_io *io;
2882         struct crypt_config *cc = ti->private;
2883
2884         /*
2885          * If bio is REQ_PREFLUSH or REQ_OP_DISCARD, just bypass crypt queues.
2886          * - for REQ_PREFLUSH device-mapper core ensures that no IO is in-flight
2887          * - for REQ_OP_DISCARD caller must use flush if IO ordering matters
2888          */
2889         if (unlikely(bio->bi_opf & REQ_PREFLUSH ||
2890             bio_op(bio) == REQ_OP_DISCARD)) {
2891                 bio_set_dev(bio, cc->dev->bdev);
2892                 if (bio_sectors(bio))
2893                         bio->bi_iter.bi_sector = cc->start +
2894                                 dm_target_offset(ti, bio->bi_iter.bi_sector);
2895                 return DM_MAPIO_REMAPPED;
2896         }
2897
2898         /*
2899          * Check if bio is too large, split as needed.
2900          */
2901         if (unlikely(bio->bi_iter.bi_size > (BIO_MAX_PAGES << PAGE_SHIFT)) &&
2902             (bio_data_dir(bio) == WRITE || cc->on_disk_tag_size))
2903                 dm_accept_partial_bio(bio, ((BIO_MAX_PAGES << PAGE_SHIFT) >> SECTOR_SHIFT));
2904
2905         /*
2906          * Ensure that bio is a multiple of internal sector encryption size
2907          * and is aligned to this size as defined in IO hints.
2908          */
2909         if (unlikely((bio->bi_iter.bi_sector & ((cc->sector_size >> SECTOR_SHIFT) - 1)) != 0))
2910                 return DM_MAPIO_KILL;
2911
2912         if (unlikely(bio->bi_iter.bi_size & (cc->sector_size - 1)))
2913                 return DM_MAPIO_KILL;
2914
2915         io = dm_per_bio_data(bio, cc->per_bio_data_size);
2916         crypt_io_init(io, cc, bio, dm_target_offset(ti, bio->bi_iter.bi_sector));
2917
2918         if (cc->on_disk_tag_size) {
2919                 unsigned tag_len = cc->on_disk_tag_size * (bio_sectors(bio) >> cc->sector_shift);
2920
2921                 if (unlikely(tag_len > KMALLOC_MAX_SIZE) ||
2922                     unlikely(!(io->integrity_metadata = kmalloc(tag_len,
2923                                 GFP_NOIO | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN)))) {
2924                         if (bio_sectors(bio) > cc->tag_pool_max_sectors)
2925                                 dm_accept_partial_bio(bio, cc->tag_pool_max_sectors);
2926                         io->integrity_metadata = mempool_alloc(cc->tag_pool, GFP_NOIO);
2927                         io->integrity_metadata_from_pool = true;
2928                 }
2929         }
2930
2931         if (crypt_integrity_aead(cc))
2932                 io->ctx.r.req_aead = (struct aead_request *)(io + 1);
2933         else
2934                 io->ctx.r.req = (struct skcipher_request *)(io + 1);
2935
2936         if (bio_data_dir(io->base_bio) == READ) {
2937                 if (kcryptd_io_read(io, GFP_NOWAIT))
2938                         kcryptd_queue_read(io);
2939         } else
2940                 kcryptd_queue_crypt(io);
2941
2942         return DM_MAPIO_SUBMITTED;
2943 }
2944
2945 static void crypt_status(struct dm_target *ti, status_type_t type,
2946                          unsigned status_flags, char *result, unsigned maxlen)
2947 {
2948         struct crypt_config *cc = ti->private;
2949         unsigned i, sz = 0;
2950         int num_feature_args = 0;
2951
2952         switch (type) {
2953         case STATUSTYPE_INFO:
2954                 result[0] = '\0';
2955                 break;
2956
2957         case STATUSTYPE_TABLE:
2958                 DMEMIT("%s ", cc->cipher_string);
2959
2960                 if (cc->key_size > 0) {
2961                         if (cc->key_string)
2962                                 DMEMIT(":%u:%s", cc->key_size, cc->key_string);
2963                         else
2964                                 for (i = 0; i < cc->key_size; i++)
2965                                         DMEMIT("%02x", cc->key[i]);
2966                 } else
2967                         DMEMIT("-");
2968
2969                 DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
2970                                 cc->dev->name, (unsigned long long)cc->start);
2971
2972                 num_feature_args += !!ti->num_discard_bios;
2973                 num_feature_args += test_bit(DM_CRYPT_SAME_CPU, &cc->flags);
2974                 num_feature_args += test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags);
2975                 num_feature_args += cc->sector_size != (1 << SECTOR_SHIFT);
2976                 num_feature_args += test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags);
2977                 if (cc->on_disk_tag_size)
2978                         num_feature_args++;
2979                 if (num_feature_args) {
2980                         DMEMIT(" %d", num_feature_args);
2981                         if (ti->num_discard_bios)
2982                                 DMEMIT(" allow_discards");
2983                         if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags))
2984                                 DMEMIT(" same_cpu_crypt");
2985                         if (test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags))
2986                                 DMEMIT(" submit_from_crypt_cpus");
2987                         if (cc->on_disk_tag_size)
2988                                 DMEMIT(" integrity:%u:%s", cc->on_disk_tag_size, cc->cipher_auth);
2989                         if (cc->sector_size != (1 << SECTOR_SHIFT))
2990                                 DMEMIT(" sector_size:%d", cc->sector_size);
2991                         if (test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags))
2992                                 DMEMIT(" iv_large_sectors");
2993                 }
2994
2995                 break;
2996         }
2997 }
2998
2999 static void crypt_postsuspend(struct dm_target *ti)
3000 {
3001         struct crypt_config *cc = ti->private;
3002
3003         set_bit(DM_CRYPT_SUSPENDED, &cc->flags);
3004 }
3005
3006 static int crypt_preresume(struct dm_target *ti)
3007 {
3008         struct crypt_config *cc = ti->private;
3009
3010         if (!test_bit(DM_CRYPT_KEY_VALID, &cc->flags)) {
3011                 DMERR("aborting resume - crypt key is not set.");
3012                 return -EAGAIN;
3013         }
3014
3015         return 0;
3016 }
3017
3018 static void crypt_resume(struct dm_target *ti)
3019 {
3020         struct crypt_config *cc = ti->private;
3021
3022         clear_bit(DM_CRYPT_SUSPENDED, &cc->flags);
3023 }
3024
3025 /* Message interface
3026  *      key set <key>
3027  *      key wipe
3028  */
3029 static int crypt_message(struct dm_target *ti, unsigned argc, char **argv)
3030 {
3031         struct crypt_config *cc = ti->private;
3032         int key_size, ret = -EINVAL;
3033
3034         if (argc < 2)
3035                 goto error;
3036
3037         if (!strcasecmp(argv[0], "key")) {
3038                 if (!test_bit(DM_CRYPT_SUSPENDED, &cc->flags)) {
3039                         DMWARN("not suspended during key manipulation.");
3040                         return -EINVAL;
3041                 }
3042                 if (argc == 3 && !strcasecmp(argv[1], "set")) {
3043                         /* The key size may not be changed. */
3044                         key_size = get_key_size(&argv[2]);
3045                         if (key_size < 0 || cc->key_size != key_size) {
3046                                 memset(argv[2], '0', strlen(argv[2]));
3047                                 return -EINVAL;
3048                         }
3049
3050                         ret = crypt_set_key(cc, argv[2]);
3051                         if (ret)
3052                                 return ret;
3053                         if (cc->iv_gen_ops && cc->iv_gen_ops->init)
3054                                 ret = cc->iv_gen_ops->init(cc);
3055                         /* wipe the kernel key payload copy */
3056                         if (cc->key_string)
3057                                 memset(cc->key, 0, cc->key_size * sizeof(u8));
3058                         return ret;
3059                 }
3060                 if (argc == 2 && !strcasecmp(argv[1], "wipe")) {
3061                         if (cc->iv_gen_ops && cc->iv_gen_ops->wipe) {
3062                                 ret = cc->iv_gen_ops->wipe(cc);
3063                                 if (ret)
3064                                         return ret;
3065                         }
3066                         return crypt_wipe_key(cc);
3067                 }
3068         }
3069
3070 error:
3071         DMWARN("unrecognised message received.");
3072         return -EINVAL;
3073 }
3074
3075 static int crypt_iterate_devices(struct dm_target *ti,
3076                                  iterate_devices_callout_fn fn, void *data)
3077 {
3078         struct crypt_config *cc = ti->private;
3079
3080         return fn(ti, cc->dev, cc->start, ti->len, data);
3081 }
3082
3083 static void crypt_io_hints(struct dm_target *ti, struct queue_limits *limits)
3084 {
3085         struct crypt_config *cc = ti->private;
3086
3087         /*
3088          * Unfortunate constraint that is required to avoid the potential
3089          * for exceeding underlying device's max_segments limits -- due to
3090          * crypt_alloc_buffer() possibly allocating pages for the encryption
3091          * bio that are not as physically contiguous as the original bio.
3092          */
3093         limits->max_segment_size = PAGE_SIZE;
3094
3095         limits->logical_block_size =
3096                 max_t(unsigned, limits->logical_block_size, cc->sector_size);
3097         limits->physical_block_size =
3098                 max_t(unsigned, limits->physical_block_size, cc->sector_size);
3099         limits->io_min = max_t(unsigned, limits->io_min, cc->sector_size);
3100 }
3101
3102 static struct target_type crypt_target = {
3103         .name   = "crypt",
3104         .version = {1, 18, 1},
3105         .module = THIS_MODULE,
3106         .ctr    = crypt_ctr,
3107         .dtr    = crypt_dtr,
3108         .map    = crypt_map,
3109         .status = crypt_status,
3110         .postsuspend = crypt_postsuspend,
3111         .preresume = crypt_preresume,
3112         .resume = crypt_resume,
3113         .message = crypt_message,
3114         .iterate_devices = crypt_iterate_devices,
3115         .io_hints = crypt_io_hints,
3116 };
3117
3118 static int __init dm_crypt_init(void)
3119 {
3120         int r;
3121
3122         r = dm_register_target(&crypt_target);
3123         if (r < 0)
3124                 DMERR("register failed %d", r);
3125
3126         return r;
3127 }
3128
3129 static void __exit dm_crypt_exit(void)
3130 {
3131         dm_unregister_target(&crypt_target);
3132 }
3133
3134 module_init(dm_crypt_init);
3135 module_exit(dm_crypt_exit);
3136
3137 MODULE_AUTHOR("Jana Saout <jana@saout.de>");
3138 MODULE_DESCRIPTION(DM_NAME " target for transparent encryption / decryption");
3139 MODULE_LICENSE("GPL");