arch/s390/crypto/paes_s390.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Cryptographic API.
   4  *
   5  * s390 implementation of the AES Cipher Algorithm with protected keys.
   6  *
   7  * s390 Version:
   8  *   Copyright IBM Corp. 2017
   9  *   Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
  10  *              Harald Freudenberger <freude@de.ibm.com>
  11  */
  12
  13 #define KMSG_COMPONENT "paes_s390"
  14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  15
  16 #include <crypto/aes.h>
  17 #include <crypto/algapi.h>
  18 #include <linux/bug.h>
  19 #include <linux/err.h>
  20 #include <linux/module.h>
  21 #include <linux/cpufeature.h>
  22 #include <linux/init.h>
  23 #include <linux/spinlock.h>
  24 #include <crypto/xts.h>
  25 #include <asm/cpacf.h>
  26 #include <asm/pkey.h>
  27
  28 static u8 *ctrblk;
  29 static DEFINE_SPINLOCK(ctrblk_lock);
  30
  31 static cpacf_mask_t km_functions, kmc_functions, kmctr_functions;
  32
  33 struct key_blob {
  34         __u8 key[MAXKEYBLOBSIZE];
  35         unsigned int keylen;
  36 };
  37
  38 struct s390_paes_ctx {
  39         struct key_blob kb;
  40         struct pkey_protkey pk;
  41         unsigned long fc;
  42 };
  43
  44 struct s390_pxts_ctx {
  45         struct key_blob kb[2];
  46         struct pkey_protkey pk[2];
  47         unsigned long fc;
  48 };
  49
  50 static inline int __paes_convert_key(struct key_blob *kb,
  51                                      struct pkey_protkey *pk)
  52 {
  53         int i, ret;
  54
  55         /* try three times in case of failure */
  56         for (i = 0; i < 3; i++) {
  57                 ret = pkey_keyblob2pkey(kb->key, kb->keylen, pk);
  58                 if (ret == 0)
  59                         break;
  60         }
  61
  62         return ret;
  63 }
  64
  65 static int __paes_set_key(struct s390_paes_ctx *ctx)
  66 {
  67         unsigned long fc;
  68
  69         if (__paes_convert_key(&ctx->kb, &ctx->pk))
  70                 return -EINVAL;
  71
  72         /* Pick the correct function code based on the protected key type */
  73         fc = (ctx->pk.type == PKEY_KEYTYPE_AES_128) ? CPACF_KM_PAES_128 :
  74                 (ctx->pk.type == PKEY_KEYTYPE_AES_192) ? CPACF_KM_PAES_192 :
  75                 (ctx->pk.type == PKEY_KEYTYPE_AES_256) ? CPACF_KM_PAES_256 : 0;
  76
  77         /* Check if the function code is available */
  78         ctx->fc = (fc && cpacf_test_func(&km_functions, fc)) ? fc : 0;
  79
  80         return ctx->fc ? 0 : -EINVAL;
  81 }
  82
  83 static int ecb_paes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
  84                             unsigned int key_len)
  85 {
  86         struct s390_paes_ctx *ctx = crypto_tfm_ctx(tfm);
  87
  88         memcpy(ctx->kb.key, in_key, key_len);
  89         ctx->kb.keylen = key_len;
  90         if (__paes_set_key(ctx)) {
  91                 tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
  92                 return -EINVAL;
  93         }
  94         return 0;
  95 }
  96
  97 static int ecb_paes_crypt(struct blkcipher_desc *desc,
  98                           unsigned long modifier,
  99                           struct blkcipher_walk *walk)
 100 {
 101         struct s390_paes_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
 102         unsigned int nbytes, n, k;
 103         int ret;
 104
 105         ret = blkcipher_walk_virt(desc, walk);
 106         while ((nbytes = walk->nbytes) >= AES_BLOCK_SIZE) {
 107                 /* only use complete blocks */
 108                 n = nbytes & ~(AES_BLOCK_SIZE - 1);
 109                 k = cpacf_km(ctx->fc | modifier, ctx->pk.protkey,
 110                              walk->dst.virt.addr, walk->src.virt.addr, n);
 111                 if (k)
 112                         ret = blkcipher_walk_done(desc, walk, nbytes - k);
 113                 if (k < n) {
 114                         if (__paes_set_key(ctx) != 0)
 115                                 return blkcipher_walk_done(desc, walk, -EIO);
 116                 }
 117         }
 118         return ret;
 119 }
 120
 121 static int ecb_paes_encrypt(struct blkcipher_desc *desc,
 122                             struct scatterlist *dst, struct scatterlist *src,
 123                             unsigned int nbytes)
 124 {
 125         struct blkcipher_walk walk;
 126
 127         blkcipher_walk_init(&walk, dst, src, nbytes);
 128         return ecb_paes_crypt(desc, CPACF_ENCRYPT, &walk);
 129 }
 130
 131 static int ecb_paes_decrypt(struct blkcipher_desc *desc,
 132                             struct scatterlist *dst, struct scatterlist *src,
 133                             unsigned int nbytes)
 134 {
 135         struct blkcipher_walk walk;
 136
 137         blkcipher_walk_init(&walk, dst, src, nbytes);
 138         return ecb_paes_crypt(desc, CPACF_DECRYPT, &walk);
 139 }
 140
 141 static struct crypto_alg ecb_paes_alg = {
 142         .cra_name               =       "ecb(paes)",
 143         .cra_driver_name        =       "ecb-paes-s390",
 144         .cra_priority           =       401,    /* combo: aes + ecb + 1 */
 145         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
 146         .cra_blocksize          =       AES_BLOCK_SIZE,
 147         .cra_ctxsize            =       sizeof(struct s390_paes_ctx),
 148         .cra_type               =       &crypto_blkcipher_type,
 149         .cra_module             =       THIS_MODULE,
 150         .cra_list               =       LIST_HEAD_INIT(ecb_paes_alg.cra_list),
 151         .cra_u                  =       {
 152                 .blkcipher = {
 153                         .min_keysize            =       MINKEYBLOBSIZE,
 154                         .max_keysize            =       MAXKEYBLOBSIZE,
 155                         .setkey                 =       ecb_paes_set_key,
 156                         .encrypt                =       ecb_paes_encrypt,
 157                         .decrypt                =       ecb_paes_decrypt,
 158                 }
 159         }
 160 };
 161
 162 static int __cbc_paes_set_key(struct s390_paes_ctx *ctx)
 163 {
 164         unsigned long fc;
 165
 166         if (__paes_convert_key(&ctx->kb, &ctx->pk))
 167                 return -EINVAL;
 168
 169         /* Pick the correct function code based on the protected key type */
 170         fc = (ctx->pk.type == PKEY_KEYTYPE_AES_128) ? CPACF_KMC_PAES_128 :
 171                 (ctx->pk.type == PKEY_KEYTYPE_AES_192) ? CPACF_KMC_PAES_192 :
 172                 (ctx->pk.type == PKEY_KEYTYPE_AES_256) ? CPACF_KMC_PAES_256 : 0;
 173
 174         /* Check if the function code is available */
 175         ctx->fc = (fc && cpacf_test_func(&kmc_functions, fc)) ? fc : 0;
 176
 177         return ctx->fc ? 0 : -EINVAL;
 178 }
 179
 180 static int cbc_paes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
 181                             unsigned int key_len)
 182 {
 183         struct s390_paes_ctx *ctx = crypto_tfm_ctx(tfm);
 184
 185         memcpy(ctx->kb.key, in_key, key_len);
 186         ctx->kb.keylen = key_len;
 187         if (__cbc_paes_set_key(ctx)) {
 188                 tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
 189                 return -EINVAL;
 190         }
 191         return 0;
 192 }
 193
 194 static int cbc_paes_crypt(struct blkcipher_desc *desc, unsigned long modifier,
 195                           struct blkcipher_walk *walk)
 196 {
 197         struct s390_paes_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
 198         unsigned int nbytes, n, k;
 199         int ret;
 200         struct {
 201                 u8 iv[AES_BLOCK_SIZE];
 202                 u8 key[MAXPROTKEYSIZE];
 203         } param;
 204
 205         ret = blkcipher_walk_virt(desc, walk);
 206         memcpy(param.iv, walk->iv, AES_BLOCK_SIZE);
 207         memcpy(param.key, ctx->pk.protkey, MAXPROTKEYSIZE);
 208         while ((nbytes = walk->nbytes) >= AES_BLOCK_SIZE) {
 209                 /* only use complete blocks */
 210                 n = nbytes & ~(AES_BLOCK_SIZE - 1);
 211                 k = cpacf_kmc(ctx->fc | modifier, &param,
 212                               walk->dst.virt.addr, walk->src.virt.addr, n);
 213                 if (k)
 214                         ret = blkcipher_walk_done(desc, walk, nbytes - k);
 215                 if (k < n) {
 216                         if (__cbc_paes_set_key(ctx) != 0)
 217                                 return blkcipher_walk_done(desc, walk, -EIO);
 218                         memcpy(param.key, ctx->pk.protkey, MAXPROTKEYSIZE);
 219                 }
 220         }
 221         memcpy(walk->iv, param.iv, AES_BLOCK_SIZE);
 222         return ret;
 223 }
 224
 225 static int cbc_paes_encrypt(struct blkcipher_desc *desc,
 226                             struct scatterlist *dst, struct scatterlist *src,
 227                             unsigned int nbytes)
 228 {
 229         struct blkcipher_walk walk;
 230
 231         blkcipher_walk_init(&walk, dst, src, nbytes);
 232         return cbc_paes_crypt(desc, 0, &walk);
 233 }
 234
 235 static int cbc_paes_decrypt(struct blkcipher_desc *desc,
 236                             struct scatterlist *dst, struct scatterlist *src,
 237                             unsigned int nbytes)
 238 {
 239         struct blkcipher_walk walk;
 240
 241         blkcipher_walk_init(&walk, dst, src, nbytes);
 242         return cbc_paes_crypt(desc, CPACF_DECRYPT, &walk);
 243 }
 244
 245 static struct crypto_alg cbc_paes_alg = {
 246         .cra_name               =       "cbc(paes)",
 247         .cra_driver_name        =       "cbc-paes-s390",
 248         .cra_priority           =       402,    /* ecb-paes-s390 + 1 */
 249         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
 250         .cra_blocksize          =       AES_BLOCK_SIZE,
 251         .cra_ctxsize            =       sizeof(struct s390_paes_ctx),
 252         .cra_type               =       &crypto_blkcipher_type,
 253         .cra_module             =       THIS_MODULE,
 254         .cra_list               =       LIST_HEAD_INIT(cbc_paes_alg.cra_list),
 255         .cra_u                  =       {
 256                 .blkcipher = {
 257                         .min_keysize            =       MINKEYBLOBSIZE,
 258                         .max_keysize            =       MAXKEYBLOBSIZE,
 259                         .ivsize                 =       AES_BLOCK_SIZE,
 260                         .setkey                 =       cbc_paes_set_key,
 261                         .encrypt                =       cbc_paes_encrypt,
 262                         .decrypt                =       cbc_paes_decrypt,
 263                 }
 264         }
 265 };
 266
 267 static int __xts_paes_set_key(struct s390_pxts_ctx *ctx)
 268 {
 269         unsigned long fc;
 270
 271         if (__paes_convert_key(&ctx->kb[0], &ctx->pk[0]) ||
 272             __paes_convert_key(&ctx->kb[1], &ctx->pk[1]))
 273                 return -EINVAL;
 274
 275         if (ctx->pk[0].type != ctx->pk[1].type)
 276                 return -EINVAL;
 277
 278         /* Pick the correct function code based on the protected key type */
 279         fc = (ctx->pk[0].type == PKEY_KEYTYPE_AES_128) ? CPACF_KM_PXTS_128 :
 280                 (ctx->pk[0].type == PKEY_KEYTYPE_AES_256) ?
 281                 CPACF_KM_PXTS_256 : 0;
 282
 283         /* Check if the function code is available */
 284         ctx->fc = (fc && cpacf_test_func(&km_functions, fc)) ? fc : 0;
 285
 286         return ctx->fc ? 0 : -EINVAL;
 287 }
 288
 289 static int xts_paes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
 290                             unsigned int key_len)
 291 {
 292         struct s390_pxts_ctx *ctx = crypto_tfm_ctx(tfm);
 293         u8 ckey[2 * AES_MAX_KEY_SIZE];
 294         unsigned int ckey_len, keytok_len;
 295
 296         if (key_len % 2)
 297                 return -EINVAL;
 298
 299         keytok_len = key_len / 2;
 300         memcpy(ctx->kb[0].key, in_key, keytok_len);
 301         ctx->kb[0].keylen = keytok_len;
 302         memcpy(ctx->kb[1].key, in_key + keytok_len, keytok_len);
 303         ctx->kb[1].keylen = keytok_len;
 304         if (__xts_paes_set_key(ctx)) {
 305                 tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
 306                 return -EINVAL;
 307         }
 308
 309         /*
 310          * xts_check_key verifies the key length is not odd and makes
 311          * sure that the two keys are not the same. This can be done
 312          * on the two protected keys as well
 313          */
 314         ckey_len = (ctx->pk[0].type == PKEY_KEYTYPE_AES_128) ?
 315                 AES_KEYSIZE_128 : AES_KEYSIZE_256;
 316         memcpy(ckey, ctx->pk[0].protkey, ckey_len);
 317         memcpy(ckey + ckey_len, ctx->pk[1].protkey, ckey_len);
 318         return xts_check_key(tfm, ckey, 2*ckey_len);
 319 }
 320
 321 static int xts_paes_crypt(struct blkcipher_desc *desc, unsigned long modifier,
 322                           struct blkcipher_walk *walk)
 323 {
 324         struct s390_pxts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
 325         unsigned int keylen, offset, nbytes, n, k;
 326         int ret;
 327         struct {
 328                 u8 key[MAXPROTKEYSIZE]; /* key + verification pattern */
 329                 u8 tweak[16];
 330                 u8 block[16];
 331                 u8 bit[16];
 332                 u8 xts[16];
 333         } pcc_param;
 334         struct {
 335                 u8 key[MAXPROTKEYSIZE]; /* key + verification pattern */
 336                 u8 init[16];
 337         } xts_param;
 338
 339         ret = blkcipher_walk_virt(desc, walk);
 340         keylen = (ctx->pk[0].type == PKEY_KEYTYPE_AES_128) ? 48 : 64;
 341         offset = (ctx->pk[0].type == PKEY_KEYTYPE_AES_128) ? 16 : 0;
 342 retry:
 343         memset(&pcc_param, 0, sizeof(pcc_param));
 344         memcpy(pcc_param.tweak, walk->iv, sizeof(pcc_param.tweak));
 345         memcpy(pcc_param.key + offset, ctx->pk[1].protkey, keylen);
 346         cpacf_pcc(ctx->fc, pcc_param.key + offset);
 347
 348         memcpy(xts_param.key + offset, ctx->pk[0].protkey, keylen);
 349         memcpy(xts_param.init, pcc_param.xts, 16);
 350
 351         while ((nbytes = walk->nbytes) >= AES_BLOCK_SIZE) {
 352                 /* only use complete blocks */
 353                 n = nbytes & ~(AES_BLOCK_SIZE - 1);
 354                 k = cpacf_km(ctx->fc | modifier, xts_param.key + offset,
 355                              walk->dst.virt.addr, walk->src.virt.addr, n);
 356                 if (k)
 357                         ret = blkcipher_walk_done(desc, walk, nbytes - k);
 358                 if (k < n) {
 359                         if (__xts_paes_set_key(ctx) != 0)
 360                                 return blkcipher_walk_done(desc, walk, -EIO);
 361                         goto retry;
 362                 }
 363         }
 364         return ret;
 365 }
 366
 367 static int xts_paes_encrypt(struct blkcipher_desc *desc,
 368                             struct scatterlist *dst, struct scatterlist *src,
 369                             unsigned int nbytes)
 370 {
 371         struct blkcipher_walk walk;
 372
 373         blkcipher_walk_init(&walk, dst, src, nbytes);
 374         return xts_paes_crypt(desc, 0, &walk);
 375 }
 376
 377 static int xts_paes_decrypt(struct blkcipher_desc *desc,
 378                             struct scatterlist *dst, struct scatterlist *src,
 379                             unsigned int nbytes)
 380 {
 381         struct blkcipher_walk walk;
 382
 383         blkcipher_walk_init(&walk, dst, src, nbytes);
 384         return xts_paes_crypt(desc, CPACF_DECRYPT, &walk);
 385 }
 386
 387 static struct crypto_alg xts_paes_alg = {
 388         .cra_name               =       "xts(paes)",
 389         .cra_driver_name        =       "xts-paes-s390",
 390         .cra_priority           =       402,    /* ecb-paes-s390 + 1 */
 391         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
 392         .cra_blocksize          =       AES_BLOCK_SIZE,
 393         .cra_ctxsize            =       sizeof(struct s390_pxts_ctx),
 394         .cra_type               =       &crypto_blkcipher_type,
 395         .cra_module             =       THIS_MODULE,
 396         .cra_list               =       LIST_HEAD_INIT(xts_paes_alg.cra_list),
 397         .cra_u                  =       {
 398                 .blkcipher = {
 399                         .min_keysize            =       2 * MINKEYBLOBSIZE,
 400                         .max_keysize            =       2 * MAXKEYBLOBSIZE,
 401                         .ivsize                 =       AES_BLOCK_SIZE,
 402                         .setkey                 =       xts_paes_set_key,
 403                         .encrypt                =       xts_paes_encrypt,
 404                         .decrypt                =       xts_paes_decrypt,
 405                 }
 406         }
 407 };
 408
 409 static int __ctr_paes_set_key(struct s390_paes_ctx *ctx)
 410 {
 411         unsigned long fc;
 412
 413         if (__paes_convert_key(&ctx->kb, &ctx->pk))
 414                 return -EINVAL;
 415
 416         /* Pick the correct function code based on the protected key type */
 417         fc = (ctx->pk.type == PKEY_KEYTYPE_AES_128) ? CPACF_KMCTR_PAES_128 :
 418                 (ctx->pk.type == PKEY_KEYTYPE_AES_192) ? CPACF_KMCTR_PAES_192 :
 419                 (ctx->pk.type == PKEY_KEYTYPE_AES_256) ?
 420                 CPACF_KMCTR_PAES_256 : 0;
 421
 422         /* Check if the function code is available */
 423         ctx->fc = (fc && cpacf_test_func(&kmctr_functions, fc)) ? fc : 0;
 424
 425         return ctx->fc ? 0 : -EINVAL;
 426 }
 427
 428 static int ctr_paes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
 429                             unsigned int key_len)
 430 {
 431         struct s390_paes_ctx *ctx = crypto_tfm_ctx(tfm);
 432
 433         memcpy(ctx->kb.key, in_key, key_len);
 434         ctx->kb.keylen = key_len;
 435         if (__ctr_paes_set_key(ctx)) {
 436                 tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
 437                 return -EINVAL;
 438         }
 439         return 0;
 440 }
 441
 442 static unsigned int __ctrblk_init(u8 *ctrptr, u8 *iv, unsigned int nbytes)
 443 {
 444         unsigned int i, n;
 445
 446         /* only use complete blocks, max. PAGE_SIZE */
 447         memcpy(ctrptr, iv, AES_BLOCK_SIZE);
 448         n = (nbytes > PAGE_SIZE) ? PAGE_SIZE : nbytes & ~(AES_BLOCK_SIZE - 1);
 449         for (i = (n / AES_BLOCK_SIZE) - 1; i > 0; i--) {
 450                 memcpy(ctrptr + AES_BLOCK_SIZE, ctrptr, AES_BLOCK_SIZE);
 451                 crypto_inc(ctrptr + AES_BLOCK_SIZE, AES_BLOCK_SIZE);
 452                 ctrptr += AES_BLOCK_SIZE;
 453         }
 454         return n;
 455 }
 456
 457 static int ctr_paes_crypt(struct blkcipher_desc *desc, unsigned long modifier,
 458                           struct blkcipher_walk *walk)
 459 {
 460         struct s390_paes_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
 461         u8 buf[AES_BLOCK_SIZE], *ctrptr;
 462         unsigned int nbytes, n, k;
 463         int ret, locked;
 464
 465         locked = spin_trylock(&ctrblk_lock);
 466
 467         ret = blkcipher_walk_virt_block(desc, walk, AES_BLOCK_SIZE);
 468         while ((nbytes = walk->nbytes) >= AES_BLOCK_SIZE) {
 469                 n = AES_BLOCK_SIZE;
 470                 if (nbytes >= 2*AES_BLOCK_SIZE && locked)
 471                         n = __ctrblk_init(ctrblk, walk->iv, nbytes);
 472                 ctrptr = (n > AES_BLOCK_SIZE) ? ctrblk : walk->iv;
 473                 k = cpacf_kmctr(ctx->fc | modifier, ctx->pk.protkey,
 474                                 walk->dst.virt.addr, walk->src.virt.addr,
 475                                 n, ctrptr);
 476                 if (k) {
 477                         if (ctrptr == ctrblk)
 478                                 memcpy(walk->iv, ctrptr + k - AES_BLOCK_SIZE,
 479                                        AES_BLOCK_SIZE);
 480                         crypto_inc(walk->iv, AES_BLOCK_SIZE);
 481                         ret = blkcipher_walk_done(desc, walk, nbytes - n);
 482                 }
 483                 if (k < n) {
 484                         if (__ctr_paes_set_key(ctx) != 0) {
 485                                 if (locked)
 486                                         spin_unlock(&ctrblk_lock);
 487                                 return blkcipher_walk_done(desc, walk, -EIO);
 488                         }
 489                 }
 490         }
 491         if (locked)
 492                 spin_unlock(&ctrblk_lock);
 493         /*
 494          * final block may be < AES_BLOCK_SIZE, copy only nbytes
 495          */
 496         if (nbytes) {
 497                 while (1) {
 498                         if (cpacf_kmctr(ctx->fc | modifier,
 499                                         ctx->pk.protkey, buf,
 500                                         walk->src.virt.addr, AES_BLOCK_SIZE,
 501                                         walk->iv) == AES_BLOCK_SIZE)
 502                                 break;
 503                         if (__ctr_paes_set_key(ctx) != 0)
 504                                 return blkcipher_walk_done(desc, walk, -EIO);
 505                 }
 506                 memcpy(walk->dst.virt.addr, buf, nbytes);
 507                 crypto_inc(walk->iv, AES_BLOCK_SIZE);
 508                 ret = blkcipher_walk_done(desc, walk, 0);
 509         }
 510
 511         return ret;
 512 }
 513
 514 static int ctr_paes_encrypt(struct blkcipher_desc *desc,
 515                             struct scatterlist *dst, struct scatterlist *src,
 516                             unsigned int nbytes)
 517 {
 518         struct blkcipher_walk walk;
 519
 520         blkcipher_walk_init(&walk, dst, src, nbytes);
 521         return ctr_paes_crypt(desc, 0, &walk);
 522 }
 523
 524 static int ctr_paes_decrypt(struct blkcipher_desc *desc,
 525                             struct scatterlist *dst, struct scatterlist *src,
 526                             unsigned int nbytes)
 527 {
 528         struct blkcipher_walk walk;
 529
 530         blkcipher_walk_init(&walk, dst, src, nbytes);
 531         return ctr_paes_crypt(desc, CPACF_DECRYPT, &walk);
 532 }
 533
 534 static struct crypto_alg ctr_paes_alg = {
 535         .cra_name               =       "ctr(paes)",
 536         .cra_driver_name        =       "ctr-paes-s390",
 537         .cra_priority           =       402,    /* ecb-paes-s390 + 1 */
 538         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
 539         .cra_blocksize          =       1,
 540         .cra_ctxsize            =       sizeof(struct s390_paes_ctx),
 541         .cra_type               =       &crypto_blkcipher_type,
 542         .cra_module             =       THIS_MODULE,
 543         .cra_list               =       LIST_HEAD_INIT(ctr_paes_alg.cra_list),
 544         .cra_u                  =       {
 545                 .blkcipher = {
 546                         .min_keysize            =       MINKEYBLOBSIZE,
 547                         .max_keysize            =       MAXKEYBLOBSIZE,
 548                         .ivsize                 =       AES_BLOCK_SIZE,
 549                         .setkey                 =       ctr_paes_set_key,
 550                         .encrypt                =       ctr_paes_encrypt,
 551                         .decrypt                =       ctr_paes_decrypt,
 552                 }
 553         }
 554 };
 555
 556 static inline void __crypto_unregister_alg(struct crypto_alg *alg)
 557 {
 558         if (!list_empty(&alg->cra_list))
 559                 crypto_unregister_alg(alg);
 560 }
 561
 562 static void paes_s390_fini(void)
 563 {
 564         if (ctrblk)
 565                 free_page((unsigned long) ctrblk);
 566         __crypto_unregister_alg(&ctr_paes_alg);
 567         __crypto_unregister_alg(&xts_paes_alg);
 568         __crypto_unregister_alg(&cbc_paes_alg);
 569         __crypto_unregister_alg(&ecb_paes_alg);
 570 }
 571
 572 static int __init paes_s390_init(void)
 573 {
 574         int ret;
 575
 576         /* Query available functions for KM, KMC and KMCTR */
 577         cpacf_query(CPACF_KM, &km_functions);
 578         cpacf_query(CPACF_KMC, &kmc_functions);
 579         cpacf_query(CPACF_KMCTR, &kmctr_functions);
 580
 581         if (cpacf_test_func(&km_functions, CPACF_KM_PAES_128) ||
 582             cpacf_test_func(&km_functions, CPACF_KM_PAES_192) ||
 583             cpacf_test_func(&km_functions, CPACF_KM_PAES_256)) {
 584                 ret = crypto_register_alg(&ecb_paes_alg);
 585                 if (ret)
 586                         goto out_err;
 587         }
 588
 589         if (cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_128) ||
 590             cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_192) ||
 591             cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_256)) {
 592                 ret = crypto_register_alg(&cbc_paes_alg);
 593                 if (ret)
 594                         goto out_err;
 595         }
 596
 597         if (cpacf_test_func(&km_functions, CPACF_KM_PXTS_128) ||
 598             cpacf_test_func(&km_functions, CPACF_KM_PXTS_256)) {
 599                 ret = crypto_register_alg(&xts_paes_alg);
 600                 if (ret)
 601                         goto out_err;
 602         }
 603
 604         if (cpacf_test_func(&kmctr_functions, CPACF_KMCTR_PAES_128) ||
 605             cpacf_test_func(&kmctr_functions, CPACF_KMCTR_PAES_192) ||
 606             cpacf_test_func(&kmctr_functions, CPACF_KMCTR_PAES_256)) {
 607                 ret = crypto_register_alg(&ctr_paes_alg);
 608                 if (ret)
 609                         goto out_err;
 610                 ctrblk = (u8 *) __get_free_page(GFP_KERNEL);
 611                 if (!ctrblk) {
 612                         ret = -ENOMEM;
 613                         goto out_err;
 614                 }
 615         }
 616
 617         return 0;
 618 out_err:
 619         paes_s390_fini();
 620         return ret;
 621 }
 622
 623 module_init(paes_s390_init);
 624 module_exit(paes_s390_fini);
 625
 626 MODULE_ALIAS_CRYPTO("paes");
 627
 628 MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm with protected keys");
 629 MODULE_LICENSE("GPL");