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