SAFE public projects git trees. - safe/jmp/linux-2.6/blob - include/linux/crypto.h

   1 /*
   2  * Scatterlist Cryptographic API.
   3  *
   4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   5  * Copyright (c) 2002 David S. Miller (davem@redhat.com)
   6  * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
   7  *
   8  * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
   9  * and Nettle, by Niels Möller.
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU General Public License as published by the Free
  13  * Software Foundation; either version 2 of the License, or (at your option)
  14  * any later version.
  15  *
  16  */
  17 #ifndef _LINUX_CRYPTO_H
  18 #define _LINUX_CRYPTO_H
  19
  20 #include <asm/atomic.h>
  21 #include <linux/module.h>
  22 #include <linux/kernel.h>
  23 #include <linux/list.h>
  24 #include <linux/slab.h>
  25 #include <linux/string.h>
  26 #include <linux/uaccess.h>
  27
  28 /*
  29  * Algorithm masks and types.
  30  */
  31 #define CRYPTO_ALG_TYPE_MASK            0x0000000f
  32 #define CRYPTO_ALG_TYPE_CIPHER          0x00000001
  33 #define CRYPTO_ALG_TYPE_COMPRESS        0x00000002
  34 #define CRYPTO_ALG_TYPE_AEAD            0x00000003
  35 #define CRYPTO_ALG_TYPE_BLKCIPHER       0x00000004
  36 #define CRYPTO_ALG_TYPE_ABLKCIPHER      0x00000005
  37 #define CRYPTO_ALG_TYPE_GIVCIPHER       0x00000006
  38 #define CRYPTO_ALG_TYPE_DIGEST          0x00000008
  39 #define CRYPTO_ALG_TYPE_HASH            0x00000009
  40 #define CRYPTO_ALG_TYPE_AHASH           0x0000000a
  41 #define CRYPTO_ALG_TYPE_SHASH           0x0000000b
  42 #define CRYPTO_ALG_TYPE_RNG             0x0000000c
  43
  44 #define CRYPTO_ALG_TYPE_HASH_MASK       0x0000000e
  45 #define CRYPTO_ALG_TYPE_AHASH_MASK      0x0000000c
  46 #define CRYPTO_ALG_TYPE_BLKCIPHER_MASK  0x0000000c
  47
  48 #define CRYPTO_ALG_LARVAL               0x00000010
  49 #define CRYPTO_ALG_DEAD                 0x00000020
  50 #define CRYPTO_ALG_DYING                0x00000040
  51 #define CRYPTO_ALG_ASYNC                0x00000080
  52
  53 /*
  54  * Set this bit if and only if the algorithm requires another algorithm of
  55  * the same type to handle corner cases.
  56  */
  57 #define CRYPTO_ALG_NEED_FALLBACK        0x00000100
  58
  59 /*
  60  * This bit is set for symmetric key ciphers that have already been wrapped
  61  * with a generic IV generator to prevent them from being wrapped again.
  62  */
  63 #define CRYPTO_ALG_GENIV                0x00000200
  64
  65 /*
  66  * Set if the algorithm has passed automated run-time testing.  Note that
  67  * if there is no run-time testing for a given algorithm it is considered
  68  * to have passed.
  69  */
  70
  71 #define CRYPTO_ALG_TESTED               0x00000400
  72
  73 /*
  74  * Transform masks and values (for crt_flags).
  75  */
  76 #define CRYPTO_TFM_REQ_MASK             0x000fff00
  77 #define CRYPTO_TFM_RES_MASK             0xfff00000
  78
  79 #define CRYPTO_TFM_REQ_WEAK_KEY         0x00000100
  80 #define CRYPTO_TFM_REQ_MAY_SLEEP        0x00000200
  81 #define CRYPTO_TFM_REQ_MAY_BACKLOG      0x00000400
  82 #define CRYPTO_TFM_RES_WEAK_KEY         0x00100000
  83 #define CRYPTO_TFM_RES_BAD_KEY_LEN      0x00200000
  84 #define CRYPTO_TFM_RES_BAD_KEY_SCHED    0x00400000
  85 #define CRYPTO_TFM_RES_BAD_BLOCK_LEN    0x00800000
  86 #define CRYPTO_TFM_RES_BAD_FLAGS        0x01000000
  87
  88 /*
  89  * Miscellaneous stuff.
  90  */
  91 #define CRYPTO_MAX_ALG_NAME             64
  92
  93 /*
  94  * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual
  95  * declaration) is used to ensure that the crypto_tfm context structure is
  96  * aligned correctly for the given architecture so that there are no alignment
  97  * faults for C data types.  In particular, this is required on platforms such
  98  * as arm where pointers are 32-bit aligned but there are data types such as
  99  * u64 which require 64-bit alignment.
 100  */
 101 #if defined(ARCH_KMALLOC_MINALIGN)
 102 #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN
 103 #elif defined(ARCH_SLAB_MINALIGN)
 104 #define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN
 105 #else
 106 #define CRYPTO_MINALIGN __alignof__(unsigned long long)
 107 #endif
 108
 109 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
 110
 111 struct scatterlist;
 112 struct crypto_ablkcipher;
 113 struct crypto_async_request;
 114 struct crypto_aead;
 115 struct crypto_blkcipher;
 116 struct crypto_hash;
 117 struct crypto_ahash;
 118 struct crypto_rng;
 119 struct crypto_tfm;
 120 struct crypto_type;
 121 struct aead_givcrypt_request;
 122 struct skcipher_givcrypt_request;
 123
 124 typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
 125
 126 struct crypto_async_request {
 127         struct list_head list;
 128         crypto_completion_t complete;
 129         void *data;
 130         struct crypto_tfm *tfm;
 131
 132         u32 flags;
 133 };
 134
 135 struct ablkcipher_request {
 136         struct crypto_async_request base;
 137
 138         unsigned int nbytes;
 139
 140         void *info;
 141
 142         struct scatterlist *src;
 143         struct scatterlist *dst;
 144
 145         void *__ctx[] CRYPTO_MINALIGN_ATTR;
 146 };
 147
 148 struct ahash_request {
 149         struct crypto_async_request base;
 150
 151         unsigned int nbytes;
 152         struct scatterlist *src;
 153         u8                 *result;
 154
 155         void *__ctx[] CRYPTO_MINALIGN_ATTR;
 156 };
 157
 158 /**
 159  *      struct aead_request - AEAD request
 160  *      @base: Common attributes for async crypto requests
 161  *      @assoclen: Length in bytes of associated data for authentication
 162  *      @cryptlen: Length of data to be encrypted or decrypted
 163  *      @iv: Initialisation vector
 164  *      @assoc: Associated data
 165  *      @src: Source data
 166  *      @dst: Destination data
 167  *      @__ctx: Start of private context data
 168  */
 169 struct aead_request {
 170         struct crypto_async_request base;
 171
 172         unsigned int assoclen;
 173         unsigned int cryptlen;
 174
 175         u8 *iv;
 176
 177         struct scatterlist *assoc;
 178         struct scatterlist *src;
 179         struct scatterlist *dst;
 180
 181         void *__ctx[] CRYPTO_MINALIGN_ATTR;
 182 };
 183
 184 struct blkcipher_desc {
 185         struct crypto_blkcipher *tfm;
 186         void *info;
 187         u32 flags;
 188 };
 189
 190 struct cipher_desc {
 191         struct crypto_tfm *tfm;
 192         void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 193         unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst,
 194                              const u8 *src, unsigned int nbytes);
 195         void *info;
 196 };
 197
 198 struct hash_desc {
 199         struct crypto_hash *tfm;
 200         u32 flags;
 201 };
 202
 203 /*
 204  * Algorithms: modular crypto algorithm implementations, managed
 205  * via crypto_register_alg() and crypto_unregister_alg().
 206  */
 207 struct ablkcipher_alg {
 208         int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
 209                       unsigned int keylen);
 210         int (*encrypt)(struct ablkcipher_request *req);
 211         int (*decrypt)(struct ablkcipher_request *req);
 212         int (*givencrypt)(struct skcipher_givcrypt_request *req);
 213         int (*givdecrypt)(struct skcipher_givcrypt_request *req);
 214
 215         const char *geniv;
 216
 217         unsigned int min_keysize;
 218         unsigned int max_keysize;
 219         unsigned int ivsize;
 220 };
 221
 222 struct ahash_alg {
 223         int (*init)(struct ahash_request *req);
 224         int (*update)(struct ahash_request *req);
 225         int (*final)(struct ahash_request *req);
 226         int (*digest)(struct ahash_request *req);
 227         int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
 228                         unsigned int keylen);
 229
 230         unsigned int digestsize;
 231 };
 232
 233 struct aead_alg {
 234         int (*setkey)(struct crypto_aead *tfm, const u8 *key,
 235                       unsigned int keylen);
 236         int (*setauthsize)(struct crypto_aead *tfm, unsigned int authsize);
 237         int (*encrypt)(struct aead_request *req);
 238         int (*decrypt)(struct aead_request *req);
 239         int (*givencrypt)(struct aead_givcrypt_request *req);
 240         int (*givdecrypt)(struct aead_givcrypt_request *req);
 241
 242         const char *geniv;
 243
 244         unsigned int ivsize;
 245         unsigned int maxauthsize;
 246 };
 247
 248 struct blkcipher_alg {
 249         int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
 250                       unsigned int keylen);
 251         int (*encrypt)(struct blkcipher_desc *desc,
 252                        struct scatterlist *dst, struct scatterlist *src,
 253                        unsigned int nbytes);
 254         int (*decrypt)(struct blkcipher_desc *desc,
 255                        struct scatterlist *dst, struct scatterlist *src,
 256                        unsigned int nbytes);
 257
 258         const char *geniv;
 259
 260         unsigned int min_keysize;
 261         unsigned int max_keysize;
 262         unsigned int ivsize;
 263 };
 264
 265 struct cipher_alg {
 266         unsigned int cia_min_keysize;
 267         unsigned int cia_max_keysize;
 268         int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,
 269                           unsigned int keylen);
 270         void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 271         void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 272 };
 273
 274 struct digest_alg {
 275         unsigned int dia_digestsize;
 276         void (*dia_init)(struct crypto_tfm *tfm);
 277         void (*dia_update)(struct crypto_tfm *tfm, const u8 *data,
 278                            unsigned int len);
 279         void (*dia_final)(struct crypto_tfm *tfm, u8 *out);
 280         int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key,
 281                           unsigned int keylen);
 282 };
 283
 284 struct hash_alg {
 285         int (*init)(struct hash_desc *desc);
 286         int (*update)(struct hash_desc *desc, struct scatterlist *sg,
 287                       unsigned int nbytes);
 288         int (*final)(struct hash_desc *desc, u8 *out);
 289         int (*digest)(struct hash_desc *desc, struct scatterlist *sg,
 290                       unsigned int nbytes, u8 *out);
 291         int (*setkey)(struct crypto_hash *tfm, const u8 *key,
 292                       unsigned int keylen);
 293
 294         unsigned int digestsize;
 295 };
 296
 297 struct compress_alg {
 298         int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src,
 299                             unsigned int slen, u8 *dst, unsigned int *dlen);
 300         int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src,
 301                               unsigned int slen, u8 *dst, unsigned int *dlen);
 302 };
 303
 304 struct rng_alg {
 305         int (*rng_make_random)(struct crypto_rng *tfm, u8 *rdata,
 306                                unsigned int dlen);
 307         int (*rng_reset)(struct crypto_rng *tfm, u8 *seed, unsigned int slen);
 308
 309         unsigned int seedsize;
 310 };
 311
 312
 313 #define cra_ablkcipher  cra_u.ablkcipher
 314 #define cra_aead        cra_u.aead
 315 #define cra_blkcipher   cra_u.blkcipher
 316 #define cra_cipher      cra_u.cipher
 317 #define cra_digest      cra_u.digest
 318 #define cra_hash        cra_u.hash
 319 #define cra_ahash       cra_u.ahash
 320 #define cra_compress    cra_u.compress
 321 #define cra_rng         cra_u.rng
 322
 323 struct crypto_alg {
 324         struct list_head cra_list;
 325         struct list_head cra_users;
 326
 327         u32 cra_flags;
 328         unsigned int cra_blocksize;
 329         unsigned int cra_ctxsize;
 330         unsigned int cra_alignmask;
 331
 332         int cra_priority;
 333         atomic_t cra_refcnt;
 334
 335         char cra_name[CRYPTO_MAX_ALG_NAME];
 336         char cra_driver_name[CRYPTO_MAX_ALG_NAME];
 337
 338         const struct crypto_type *cra_type;
 339
 340         union {
 341                 struct ablkcipher_alg ablkcipher;
 342                 struct aead_alg aead;
 343                 struct blkcipher_alg blkcipher;
 344                 struct cipher_alg cipher;
 345                 struct digest_alg digest;
 346                 struct hash_alg hash;
 347                 struct ahash_alg ahash;
 348                 struct compress_alg compress;
 349                 struct rng_alg rng;
 350         } cra_u;
 351
 352         int (*cra_init)(struct crypto_tfm *tfm);
 353         void (*cra_exit)(struct crypto_tfm *tfm);
 354         void (*cra_destroy)(struct crypto_alg *alg);
 355
 356         struct module *cra_module;
 357 };
 358
 359 /*
 360  * Algorithm registration interface.
 361  */
 362 int crypto_register_alg(struct crypto_alg *alg);
 363 int crypto_unregister_alg(struct crypto_alg *alg);
 364
 365 /*
 366  * Algorithm query interface.
 367  */
 368 int crypto_has_alg(const char *name, u32 type, u32 mask);
 369
 370 /*
 371  * Transforms: user-instantiated objects which encapsulate algorithms
 372  * and core processing logic.  Managed via crypto_alloc_*() and
 373  * crypto_free_*(), as well as the various helpers below.
 374  */
 375
 376 struct ablkcipher_tfm {
 377         int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
 378                       unsigned int keylen);
 379         int (*encrypt)(struct ablkcipher_request *req);
 380         int (*decrypt)(struct ablkcipher_request *req);
 381         int (*givencrypt)(struct skcipher_givcrypt_request *req);
 382         int (*givdecrypt)(struct skcipher_givcrypt_request *req);
 383
 384         struct crypto_ablkcipher *base;
 385
 386         unsigned int ivsize;
 387         unsigned int reqsize;
 388 };
 389
 390 struct aead_tfm {
 391         int (*setkey)(struct crypto_aead *tfm, const u8 *key,
 392                       unsigned int keylen);
 393         int (*encrypt)(struct aead_request *req);
 394         int (*decrypt)(struct aead_request *req);
 395         int (*givencrypt)(struct aead_givcrypt_request *req);
 396         int (*givdecrypt)(struct aead_givcrypt_request *req);
 397
 398         struct crypto_aead *base;
 399
 400         unsigned int ivsize;
 401         unsigned int authsize;
 402         unsigned int reqsize;
 403 };
 404
 405 struct blkcipher_tfm {
 406         void *iv;
 407         int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
 408                       unsigned int keylen);
 409         int (*encrypt)(struct blkcipher_desc *desc, struct scatterlist *dst,
 410                        struct scatterlist *src, unsigned int nbytes);
 411         int (*decrypt)(struct blkcipher_desc *desc, struct scatterlist *dst,
 412                        struct scatterlist *src, unsigned int nbytes);
 413 };
 414
 415 struct cipher_tfm {
 416         int (*cit_setkey)(struct crypto_tfm *tfm,
 417                           const u8 *key, unsigned int keylen);
 418         void (*cit_encrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 419         void (*cit_decrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 420 };
 421
 422 struct hash_tfm {
 423         int (*init)(struct hash_desc *desc);
 424         int (*update)(struct hash_desc *desc,
 425                       struct scatterlist *sg, unsigned int nsg);
 426         int (*final)(struct hash_desc *desc, u8 *out);
 427         int (*digest)(struct hash_desc *desc, struct scatterlist *sg,
 428                       unsigned int nsg, u8 *out);
 429         int (*setkey)(struct crypto_hash *tfm, const u8 *key,
 430                       unsigned int keylen);
 431         unsigned int digestsize;
 432 };
 433
 434 struct ahash_tfm {
 435         int (*init)(struct ahash_request *req);
 436         int (*update)(struct ahash_request *req);
 437         int (*final)(struct ahash_request *req);
 438         int (*digest)(struct ahash_request *req);
 439         int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
 440                         unsigned int keylen);
 441
 442         unsigned int digestsize;
 443         unsigned int reqsize;
 444 };
 445
 446 struct compress_tfm {
 447         int (*cot_compress)(struct crypto_tfm *tfm,
 448                             const u8 *src, unsigned int slen,
 449                             u8 *dst, unsigned int *dlen);
 450         int (*cot_decompress)(struct crypto_tfm *tfm,
 451                               const u8 *src, unsigned int slen,
 452                               u8 *dst, unsigned int *dlen);
 453 };
 454
 455 struct rng_tfm {
 456         int (*rng_gen_random)(struct crypto_rng *tfm, u8 *rdata,
 457                               unsigned int dlen);
 458         int (*rng_reset)(struct crypto_rng *tfm, u8 *seed, unsigned int slen);
 459 };
 460
 461 #define crt_ablkcipher  crt_u.ablkcipher
 462 #define crt_aead        crt_u.aead
 463 #define crt_blkcipher   crt_u.blkcipher
 464 #define crt_cipher      crt_u.cipher
 465 #define crt_hash        crt_u.hash
 466 #define crt_ahash       crt_u.ahash
 467 #define crt_compress    crt_u.compress
 468 #define crt_rng         crt_u.rng
 469
 470 struct crypto_tfm {
 471
 472         u32 crt_flags;
 473
 474         union {
 475                 struct ablkcipher_tfm ablkcipher;
 476                 struct aead_tfm aead;
 477                 struct blkcipher_tfm blkcipher;
 478                 struct cipher_tfm cipher;
 479                 struct hash_tfm hash;
 480                 struct ahash_tfm ahash;
 481                 struct compress_tfm compress;
 482                 struct rng_tfm rng;
 483         } crt_u;
 484
 485         void (*exit)(struct crypto_tfm *tfm);
 486
 487         struct crypto_alg *__crt_alg;
 488
 489         void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
 490 };
 491
 492 struct crypto_ablkcipher {
 493         struct crypto_tfm base;
 494 };
 495
 496 struct crypto_aead {
 497         struct crypto_tfm base;
 498 };
 499
 500 struct crypto_blkcipher {
 501         struct crypto_tfm base;
 502 };
 503
 504 struct crypto_cipher {
 505         struct crypto_tfm base;
 506 };
 507
 508 struct crypto_comp {
 509         struct crypto_tfm base;
 510 };
 511
 512 struct crypto_hash {
 513         struct crypto_tfm base;
 514 };
 515
 516 struct crypto_rng {
 517         struct crypto_tfm base;
 518 };
 519
 520 enum {
 521         CRYPTOA_UNSPEC,
 522         CRYPTOA_ALG,
 523         CRYPTOA_TYPE,
 524         CRYPTOA_U32,
 525         __CRYPTOA_MAX,
 526 };
 527
 528 #define CRYPTOA_MAX (__CRYPTOA_MAX - 1)
 529
 530 /* Maximum number of (rtattr) parameters for each template. */
 531 #define CRYPTO_MAX_ATTRS 32
 532
 533 struct crypto_attr_alg {
 534         char name[CRYPTO_MAX_ALG_NAME];
 535 };
 536
 537 struct crypto_attr_type {
 538         u32 type;
 539         u32 mask;
 540 };
 541
 542 struct crypto_attr_u32 {
 543         u32 num;
 544 };
 545
 546 /*
 547  * Transform user interface.
 548  */
 549
 550 struct crypto_tfm *crypto_alloc_tfm(const char *alg_name,
 551                                     const struct crypto_type *frontend,
 552                                     u32 type, u32 mask);
 553 struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask);
 554 void crypto_free_tfm(struct crypto_tfm *tfm);
 555
 556 int alg_test(const char *driver, const char *alg, u32 type, u32 mask);
 557
 558 /*
 559  * Transform helpers which query the underlying algorithm.
 560  */
 561 static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
 562 {
 563         return tfm->__crt_alg->cra_name;
 564 }
 565
 566 static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm)
 567 {
 568         return tfm->__crt_alg->cra_driver_name;
 569 }
 570
 571 static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm)
 572 {
 573         return tfm->__crt_alg->cra_priority;
 574 }
 575
 576 static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
 577 {
 578         return module_name(tfm->__crt_alg->cra_module);
 579 }
 580
 581 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
 582 {
 583         return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
 584 }
 585
 586 static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
 587 {
 588         return tfm->__crt_alg->cra_blocksize;
 589 }
 590
 591 static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
 592 {
 593         return tfm->__crt_alg->cra_alignmask;
 594 }
 595
 596 static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm)
 597 {
 598         return tfm->crt_flags;
 599 }
 600
 601 static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags)
 602 {
 603         tfm->crt_flags |= flags;
 604 }
 605
 606 static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags)
 607 {
 608         tfm->crt_flags &= ~flags;
 609 }
 610
 611 static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
 612 {
 613         return tfm->__crt_ctx;
 614 }
 615
 616 static inline unsigned int crypto_tfm_ctx_alignment(void)
 617 {
 618         struct crypto_tfm *tfm;
 619         return __alignof__(tfm->__crt_ctx);
 620 }
 621
 622 /*
 623  * API wrappers.
 624  */
 625 static inline struct crypto_ablkcipher *__crypto_ablkcipher_cast(
 626         struct crypto_tfm *tfm)
 627 {
 628         return (struct crypto_ablkcipher *)tfm;
 629 }
 630
 631 static inline u32 crypto_skcipher_type(u32 type)
 632 {
 633         type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
 634         type |= CRYPTO_ALG_TYPE_BLKCIPHER;
 635         return type;
 636 }
 637
 638 static inline u32 crypto_skcipher_mask(u32 mask)
 639 {
 640         mask &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
 641         mask |= CRYPTO_ALG_TYPE_BLKCIPHER_MASK;
 642         return mask;
 643 }
 644
 645 struct crypto_ablkcipher *crypto_alloc_ablkcipher(const char *alg_name,
 646                                                   u32 type, u32 mask);
 647
 648 static inline struct crypto_tfm *crypto_ablkcipher_tfm(
 649         struct crypto_ablkcipher *tfm)
 650 {
 651         return &tfm->base;
 652 }
 653
 654 static inline void crypto_free_ablkcipher(struct crypto_ablkcipher *tfm)
 655 {
 656         crypto_free_tfm(crypto_ablkcipher_tfm(tfm));
 657 }
 658
 659 static inline int crypto_has_ablkcipher(const char *alg_name, u32 type,
 660                                         u32 mask)
 661 {
 662         return crypto_has_alg(alg_name, crypto_skcipher_type(type),
 663                               crypto_skcipher_mask(mask));
 664 }
 665
 666 static inline struct ablkcipher_tfm *crypto_ablkcipher_crt(
 667         struct crypto_ablkcipher *tfm)
 668 {
 669         return &crypto_ablkcipher_tfm(tfm)->crt_ablkcipher;
 670 }
 671
 672 static inline unsigned int crypto_ablkcipher_ivsize(
 673         struct crypto_ablkcipher *tfm)
 674 {
 675         return crypto_ablkcipher_crt(tfm)->ivsize;
 676 }
 677
 678 static inline unsigned int crypto_ablkcipher_blocksize(
 679         struct crypto_ablkcipher *tfm)
 680 {
 681         return crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(tfm));
 682 }
 683
 684 static inline unsigned int crypto_ablkcipher_alignmask(
 685         struct crypto_ablkcipher *tfm)
 686 {
 687         return crypto_tfm_alg_alignmask(crypto_ablkcipher_tfm(tfm));
 688 }
 689
 690 static inline u32 crypto_ablkcipher_get_flags(struct crypto_ablkcipher *tfm)
 691 {
 692         return crypto_tfm_get_flags(crypto_ablkcipher_tfm(tfm));
 693 }
 694
 695 static inline void crypto_ablkcipher_set_flags(struct crypto_ablkcipher *tfm,
 696                                                u32 flags)
 697 {
 698         crypto_tfm_set_flags(crypto_ablkcipher_tfm(tfm), flags);
 699 }
 700
 701 static inline void crypto_ablkcipher_clear_flags(struct crypto_ablkcipher *tfm,
 702                                                  u32 flags)
 703 {
 704         crypto_tfm_clear_flags(crypto_ablkcipher_tfm(tfm), flags);
 705 }
 706
 707 static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
 708                                            const u8 *key, unsigned int keylen)
 709 {
 710         struct ablkcipher_tfm *crt = crypto_ablkcipher_crt(tfm);
 711
 712         return crt->setkey(crt->base, key, keylen);
 713 }
 714
 715 static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
 716         struct ablkcipher_request *req)
 717 {
 718         return __crypto_ablkcipher_cast(req->base.tfm);
 719 }
 720
 721 static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
 722 {
 723         struct ablkcipher_tfm *crt =
 724                 crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
 725         return crt->encrypt(req);
 726 }
 727
 728 static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
 729 {
 730         struct ablkcipher_tfm *crt =
 731                 crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
 732         return crt->decrypt(req);
 733 }
 734
 735 static inline unsigned int crypto_ablkcipher_reqsize(
 736         struct crypto_ablkcipher *tfm)
 737 {
 738         return crypto_ablkcipher_crt(tfm)->reqsize;
 739 }
 740
 741 static inline void ablkcipher_request_set_tfm(
 742         struct ablkcipher_request *req, struct crypto_ablkcipher *tfm)
 743 {
 744         req->base.tfm = crypto_ablkcipher_tfm(crypto_ablkcipher_crt(tfm)->base);
 745 }
 746
 747 static inline struct ablkcipher_request *ablkcipher_request_cast(
 748         struct crypto_async_request *req)
 749 {
 750         return container_of(req, struct ablkcipher_request, base);
 751 }
 752
 753 static inline struct ablkcipher_request *ablkcipher_request_alloc(
 754         struct crypto_ablkcipher *tfm, gfp_t gfp)
 755 {
 756         struct ablkcipher_request *req;
 757
 758         req = kmalloc(sizeof(struct ablkcipher_request) +
 759                       crypto_ablkcipher_reqsize(tfm), gfp);
 760
 761         if (likely(req))
 762                 ablkcipher_request_set_tfm(req, tfm);
 763
 764         return req;
 765 }
 766
 767 static inline void ablkcipher_request_free(struct ablkcipher_request *req)
 768 {
 769         kfree(req);
 770 }
 771
 772 static inline void ablkcipher_request_set_callback(
 773         struct ablkcipher_request *req,
 774         u32 flags, crypto_completion_t complete, void *data)
 775 {
 776         req->base.complete = complete;
 777         req->base.data = data;
 778         req->base.flags = flags;
 779 }
 780
 781 static inline void ablkcipher_request_set_crypt(
 782         struct ablkcipher_request *req,
 783         struct scatterlist *src, struct scatterlist *dst,
 784         unsigned int nbytes, void *iv)
 785 {
 786         req->src = src;
 787         req->dst = dst;
 788         req->nbytes = nbytes;
 789         req->info = iv;
 790 }
 791
 792 static inline struct crypto_aead *__crypto_aead_cast(struct crypto_tfm *tfm)
 793 {
 794         return (struct crypto_aead *)tfm;
 795 }
 796
 797 struct crypto_aead *crypto_alloc_aead(const char *alg_name, u32 type, u32 mask);
 798
 799 static inline struct crypto_tfm *crypto_aead_tfm(struct crypto_aead *tfm)
 800 {
 801         return &tfm->base;
 802 }
 803
 804 static inline void crypto_free_aead(struct crypto_aead *tfm)
 805 {
 806         crypto_free_tfm(crypto_aead_tfm(tfm));
 807 }
 808
 809 static inline struct aead_tfm *crypto_aead_crt(struct crypto_aead *tfm)
 810 {
 811         return &crypto_aead_tfm(tfm)->crt_aead;
 812 }
 813
 814 static inline unsigned int crypto_aead_ivsize(struct crypto_aead *tfm)
 815 {
 816         return crypto_aead_crt(tfm)->ivsize;
 817 }
 818
 819 static inline unsigned int crypto_aead_authsize(struct crypto_aead *tfm)
 820 {
 821         return crypto_aead_crt(tfm)->authsize;
 822 }
 823
 824 static inline unsigned int crypto_aead_blocksize(struct crypto_aead *tfm)
 825 {
 826         return crypto_tfm_alg_blocksize(crypto_aead_tfm(tfm));
 827 }
 828
 829 static inline unsigned int crypto_aead_alignmask(struct crypto_aead *tfm)
 830 {
 831         return crypto_tfm_alg_alignmask(crypto_aead_tfm(tfm));
 832 }
 833
 834 static inline u32 crypto_aead_get_flags(struct crypto_aead *tfm)
 835 {
 836         return crypto_tfm_get_flags(crypto_aead_tfm(tfm));
 837 }
 838
 839 static inline void crypto_aead_set_flags(struct crypto_aead *tfm, u32 flags)
 840 {
 841         crypto_tfm_set_flags(crypto_aead_tfm(tfm), flags);
 842 }
 843
 844 static inline void crypto_aead_clear_flags(struct crypto_aead *tfm, u32 flags)
 845 {
 846         crypto_tfm_clear_flags(crypto_aead_tfm(tfm), flags);
 847 }
 848
 849 static inline int crypto_aead_setkey(struct crypto_aead *tfm, const u8 *key,
 850                                      unsigned int keylen)
 851 {
 852         struct aead_tfm *crt = crypto_aead_crt(tfm);
 853
 854         return crt->setkey(crt->base, key, keylen);
 855 }
 856
 857 int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize);
 858
 859 static inline struct crypto_aead *crypto_aead_reqtfm(struct aead_request *req)
 860 {
 861         return __crypto_aead_cast(req->base.tfm);
 862 }
 863
 864 static inline int crypto_aead_encrypt(struct aead_request *req)
 865 {
 866         return crypto_aead_crt(crypto_aead_reqtfm(req))->encrypt(req);
 867 }
 868
 869 static inline int crypto_aead_decrypt(struct aead_request *req)
 870 {
 871         return crypto_aead_crt(crypto_aead_reqtfm(req))->decrypt(req);
 872 }
 873
 874 static inline unsigned int crypto_aead_reqsize(struct crypto_aead *tfm)
 875 {
 876         return crypto_aead_crt(tfm)->reqsize;
 877 }
 878
 879 static inline void aead_request_set_tfm(struct aead_request *req,
 880                                         struct crypto_aead *tfm)
 881 {
 882         req->base.tfm = crypto_aead_tfm(crypto_aead_crt(tfm)->base);
 883 }
 884
 885 static inline struct aead_request *aead_request_alloc(struct crypto_aead *tfm,
 886                                                       gfp_t gfp)
 887 {
 888         struct aead_request *req;
 889
 890         req = kmalloc(sizeof(*req) + crypto_aead_reqsize(tfm), gfp);
 891
 892         if (likely(req))
 893                 aead_request_set_tfm(req, tfm);
 894
 895         return req;
 896 }
 897
 898 static inline void aead_request_free(struct aead_request *req)
 899 {
 900         kfree(req);
 901 }
 902
 903 static inline void aead_request_set_callback(struct aead_request *req,
 904                                              u32 flags,
 905                                              crypto_completion_t complete,
 906                                              void *data)
 907 {
 908         req->base.complete = complete;
 909         req->base.data = data;
 910         req->base.flags = flags;
 911 }
 912
 913 static inline void aead_request_set_crypt(struct aead_request *req,
 914                                           struct scatterlist *src,
 915                                           struct scatterlist *dst,
 916                                           unsigned int cryptlen, u8 *iv)
 917 {
 918         req->src = src;
 919         req->dst = dst;
 920         req->cryptlen = cryptlen;
 921         req->iv = iv;
 922 }
 923
 924 static inline void aead_request_set_assoc(struct aead_request *req,
 925                                           struct scatterlist *assoc,
 926                                           unsigned int assoclen)
 927 {
 928         req->assoc = assoc;
 929         req->assoclen = assoclen;
 930 }
 931
 932 static inline struct crypto_blkcipher *__crypto_blkcipher_cast(
 933         struct crypto_tfm *tfm)
 934 {
 935         return (struct crypto_blkcipher *)tfm;
 936 }
 937
 938 static inline struct crypto_blkcipher *crypto_blkcipher_cast(
 939         struct crypto_tfm *tfm)
 940 {
 941         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER);
 942         return __crypto_blkcipher_cast(tfm);
 943 }
 944
 945 static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
 946         const char *alg_name, u32 type, u32 mask)
 947 {
 948         type &= ~CRYPTO_ALG_TYPE_MASK;
 949         type |= CRYPTO_ALG_TYPE_BLKCIPHER;
 950         mask |= CRYPTO_ALG_TYPE_MASK;
 951
 952         return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask));
 953 }
 954
 955 static inline struct crypto_tfm *crypto_blkcipher_tfm(
 956         struct crypto_blkcipher *tfm)
 957 {
 958         return &tfm->base;
 959 }
 960
 961 static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
 962 {
 963         crypto_free_tfm(crypto_blkcipher_tfm(tfm));
 964 }
 965
 966 static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
 967 {
 968         type &= ~CRYPTO_ALG_TYPE_MASK;
 969         type |= CRYPTO_ALG_TYPE_BLKCIPHER;
 970         mask |= CRYPTO_ALG_TYPE_MASK;
 971
 972         return crypto_has_alg(alg_name, type, mask);
 973 }
 974
 975 static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm)
 976 {
 977         return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm));
 978 }
 979
 980 static inline struct blkcipher_tfm *crypto_blkcipher_crt(
 981         struct crypto_blkcipher *tfm)
 982 {
 983         return &crypto_blkcipher_tfm(tfm)->crt_blkcipher;
 984 }
 985
 986 static inline struct blkcipher_alg *crypto_blkcipher_alg(
 987         struct crypto_blkcipher *tfm)
 988 {
 989         return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher;
 990 }
 991
 992 static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm)
 993 {
 994         return crypto_blkcipher_alg(tfm)->ivsize;
 995 }
 996
 997 static inline unsigned int crypto_blkcipher_blocksize(
 998         struct crypto_blkcipher *tfm)
 999 {
1000         return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm));
1001 }
1002
1003 static inline unsigned int crypto_blkcipher_alignmask(
1004         struct crypto_blkcipher *tfm)
1005 {
1006         return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm));
1007 }
1008
1009 static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm)
1010 {
1011         return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm));
1012 }
1013
1014 static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm,
1015                                               u32 flags)
1016 {
1017         crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags);
1018 }
1019
1020 static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm,
1021                                                 u32 flags)
1022 {
1023         crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags);
1024 }
1025
1026 static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm,
1027                                           const u8 *key, unsigned int keylen)
1028 {
1029         return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm),
1030                                                  key, keylen);
1031 }
1032
1033 static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
1034                                            struct scatterlist *dst,
1035                                            struct scatterlist *src,
1036                                            unsigned int nbytes)
1037 {
1038         desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
1039         return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
1040 }
1041
1042 static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc,
1043                                               struct scatterlist *dst,
1044                                               struct scatterlist *src,
1045                                               unsigned int nbytes)
1046 {
1047         return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
1048 }
1049
1050 static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc,
1051                                            struct scatterlist *dst,
1052                                            struct scatterlist *src,
1053                                            unsigned int nbytes)
1054 {
1055         desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
1056         return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
1057 }
1058
1059 static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc,
1060                                               struct scatterlist *dst,
1061                                               struct scatterlist *src,
1062                                               unsigned int nbytes)
1063 {
1064         return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
1065 }
1066
1067 static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm,
1068                                            const u8 *src, unsigned int len)
1069 {
1070         memcpy(crypto_blkcipher_crt(tfm)->iv, src, len);
1071 }
1072
1073 static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm,
1074                                            u8 *dst, unsigned int len)
1075 {
1076         memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len);
1077 }
1078
1079 static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm)
1080 {
1081         return (struct crypto_cipher *)tfm;
1082 }
1083
1084 static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm)
1085 {
1086         BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
1087         return __crypto_cipher_cast(tfm);
1088 }
1089
1090 static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name,
1091                                                         u32 type, u32 mask)
1092 {
1093         type &= ~CRYPTO_ALG_TYPE_MASK;
1094         type |= CRYPTO_ALG_TYPE_CIPHER;
1095         mask |= CRYPTO_ALG_TYPE_MASK;
1096
1097         return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask));
1098 }
1099
1100 static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm)
1101 {
1102         return &tfm->base;
1103 }
1104
1105 static inline void crypto_free_cipher(struct crypto_cipher *tfm)
1106 {
1107         crypto_free_tfm(crypto_cipher_tfm(tfm));
1108 }
1109
1110 static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask)
1111 {
1112         type &= ~CRYPTO_ALG_TYPE_MASK;
1113         type |= CRYPTO_ALG_TYPE_CIPHER;
1114         mask |= CRYPTO_ALG_TYPE_MASK;
1115
1116         return crypto_has_alg(alg_name, type, mask);
1117 }
1118
1119 static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm)
1120 {
1121         return &crypto_cipher_tfm(tfm)->crt_cipher;
1122 }
1123
1124 static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm)
1125 {
1126         return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm));
1127 }
1128
1129 static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm)
1130 {
1131         return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm));
1132 }
1133
1134 static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm)
1135 {
1136         return crypto_tfm_get_flags(crypto_cipher_tfm(tfm));
1137 }
1138
1139 static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm,
1140                                            u32 flags)
1141 {
1142         crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags);
1143 }
1144
1145 static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm,
1146                                              u32 flags)
1147 {
1148         crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags);
1149 }
1150
1151 static inline int crypto_cipher_setkey(struct crypto_cipher *tfm,
1152                                        const u8 *key, unsigned int keylen)
1153 {
1154         return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm),
1155                                                   key, keylen);
1156 }
1157
1158 static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
1159                                              u8 *dst, const u8 *src)
1160 {
1161         crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm),
1162                                                 dst, src);
1163 }
1164
1165 static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
1166                                              u8 *dst, const u8 *src)
1167 {
1168         crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm),
1169                                                 dst, src);
1170 }
1171
1172 static inline struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm)
1173 {
1174         return (struct crypto_hash *)tfm;
1175 }
1176
1177 static inline struct crypto_hash *crypto_hash_cast(struct crypto_tfm *tfm)
1178 {
1179         BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_HASH) &
1180                CRYPTO_ALG_TYPE_HASH_MASK);
1181         return __crypto_hash_cast(tfm);
1182 }
1183
1184 static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name,
1185                                                     u32 type, u32 mask)
1186 {
1187         type &= ~CRYPTO_ALG_TYPE_MASK;
1188         mask &= ~CRYPTO_ALG_TYPE_MASK;
1189         type |= CRYPTO_ALG_TYPE_HASH;
1190         mask |= CRYPTO_ALG_TYPE_HASH_MASK;
1191
1192         return __crypto_hash_cast(crypto_alloc_base(alg_name, type, mask));
1193 }
1194
1195 static inline struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm)
1196 {
1197         return &tfm->base;
1198 }
1199
1200 static inline void crypto_free_hash(struct crypto_hash *tfm)
1201 {
1202         crypto_free_tfm(crypto_hash_tfm(tfm));
1203 }
1204
1205 static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask)
1206 {
1207         type &= ~CRYPTO_ALG_TYPE_MASK;
1208         mask &= ~CRYPTO_ALG_TYPE_MASK;
1209         type |= CRYPTO_ALG_TYPE_HASH;
1210         mask |= CRYPTO_ALG_TYPE_HASH_MASK;
1211
1212         return crypto_has_alg(alg_name, type, mask);
1213 }
1214
1215 static inline struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm)
1216 {
1217         return &crypto_hash_tfm(tfm)->crt_hash;
1218 }
1219
1220 static inline unsigned int crypto_hash_blocksize(struct crypto_hash *tfm)
1221 {
1222         return crypto_tfm_alg_blocksize(crypto_hash_tfm(tfm));
1223 }
1224
1225 static inline unsigned int crypto_hash_alignmask(struct crypto_hash *tfm)
1226 {
1227         return crypto_tfm_alg_alignmask(crypto_hash_tfm(tfm));
1228 }
1229
1230 static inline unsigned int crypto_hash_digestsize(struct crypto_hash *tfm)
1231 {
1232         return crypto_hash_crt(tfm)->digestsize;
1233 }
1234
1235 static inline u32 crypto_hash_get_flags(struct crypto_hash *tfm)
1236 {
1237         return crypto_tfm_get_flags(crypto_hash_tfm(tfm));
1238 }
1239
1240 static inline void crypto_hash_set_flags(struct crypto_hash *tfm, u32 flags)
1241 {
1242         crypto_tfm_set_flags(crypto_hash_tfm(tfm), flags);
1243 }
1244
1245 static inline void crypto_hash_clear_flags(struct crypto_hash *tfm, u32 flags)
1246 {
1247         crypto_tfm_clear_flags(crypto_hash_tfm(tfm), flags);
1248 }
1249
1250 static inline int crypto_hash_init(struct hash_desc *desc)
1251 {
1252         return crypto_hash_crt(desc->tfm)->init(desc);
1253 }
1254
1255 static inline int crypto_hash_update(struct hash_desc *desc,
1256                                      struct scatterlist *sg,
1257                                      unsigned int nbytes)
1258 {
1259         return crypto_hash_crt(desc->tfm)->update(desc, sg, nbytes);
1260 }
1261
1262 static inline int crypto_hash_final(struct hash_desc *desc, u8 *out)
1263 {
1264         return crypto_hash_crt(desc->tfm)->final(desc, out);
1265 }
1266
1267 static inline int crypto_hash_digest(struct hash_desc *desc,
1268                                      struct scatterlist *sg,
1269                                      unsigned int nbytes, u8 *out)
1270 {
1271         return crypto_hash_crt(desc->tfm)->digest(desc, sg, nbytes, out);
1272 }
1273
1274 static inline int crypto_hash_setkey(struct crypto_hash *hash,
1275                                      const u8 *key, unsigned int keylen)
1276 {
1277         return crypto_hash_crt(hash)->setkey(hash, key, keylen);
1278 }
1279
1280 static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm)
1281 {
1282         return (struct crypto_comp *)tfm;
1283 }
1284
1285 static inline struct crypto_comp *crypto_comp_cast(struct crypto_tfm *tfm)
1286 {
1287         BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_COMPRESS) &
1288                CRYPTO_ALG_TYPE_MASK);
1289         return __crypto_comp_cast(tfm);
1290 }
1291
1292 static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name,
1293                                                     u32 type, u32 mask)
1294 {
1295         type &= ~CRYPTO_ALG_TYPE_MASK;
1296         type |= CRYPTO_ALG_TYPE_COMPRESS;
1297         mask |= CRYPTO_ALG_TYPE_MASK;
1298
1299         return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask));
1300 }
1301
1302 static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm)
1303 {
1304         return &tfm->base;
1305 }
1306
1307 static inline void crypto_free_comp(struct crypto_comp *tfm)
1308 {
1309         crypto_free_tfm(crypto_comp_tfm(tfm));
1310 }
1311
1312 static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask)
1313 {
1314         type &= ~CRYPTO_ALG_TYPE_MASK;
1315         type |= CRYPTO_ALG_TYPE_COMPRESS;
1316         mask |= CRYPTO_ALG_TYPE_MASK;
1317
1318         return crypto_has_alg(alg_name, type, mask);
1319 }
1320
1321 static inline const char *crypto_comp_name(struct crypto_comp *tfm)
1322 {
1323         return crypto_tfm_alg_name(crypto_comp_tfm(tfm));
1324 }
1325
1326 static inline struct compress_tfm *crypto_comp_crt(struct crypto_comp *tfm)
1327 {
1328         return &crypto_comp_tfm(tfm)->crt_compress;
1329 }
1330
1331 static inline int crypto_comp_compress(struct crypto_comp *tfm,
1332                                        const u8 *src, unsigned int slen,
1333                                        u8 *dst, unsigned int *dlen)
1334 {
1335         return crypto_comp_crt(tfm)->cot_compress(crypto_comp_tfm(tfm),
1336                                                   src, slen, dst, dlen);
1337 }
1338
1339 static inline int crypto_comp_decompress(struct crypto_comp *tfm,
1340                                          const u8 *src, unsigned int slen,
1341                                          u8 *dst, unsigned int *dlen)
1342 {
1343         return crypto_comp_crt(tfm)->cot_decompress(crypto_comp_tfm(tfm),
1344                                                     src, slen, dst, dlen);
1345 }
1346
1347 #endif  /* _LINUX_CRYPTO_H */
1348