crypto/pcrypt.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * pcrypt - Parallel crypto wrapper.
   4  *
   5  * Copyright (C) 2009 secunet Security Networks AG
   6  * Copyright (C) 2009 Steffen Klassert <steffen.klassert@secunet.com>
   7  */
   8
   9 #include <crypto/algapi.h>
  10 #include <crypto/internal/aead.h>
  11 #include <linux/atomic.h>
  12 #include <linux/err.h>
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/slab.h>
  16 #include <linux/notifier.h>
  17 #include <linux/kobject.h>
  18 #include <linux/cpu.h>
  19 #include <crypto/pcrypt.h>
  20
  21 static struct padata_instance *pencrypt;
  22 static struct padata_instance *pdecrypt;
  23 static struct kset           *pcrypt_kset;
  24
  25 struct pcrypt_instance_ctx {
  26         struct crypto_aead_spawn spawn;
  27         struct padata_shell *psenc;
  28         struct padata_shell *psdec;
  29         atomic_t tfm_count;
  30 };
  31
  32 struct pcrypt_aead_ctx {
  33         struct crypto_aead *child;
  34         unsigned int cb_cpu;
  35 };
  36
  37 static inline struct pcrypt_instance_ctx *pcrypt_tfm_ictx(
  38         struct crypto_aead *tfm)
  39 {
  40         return aead_instance_ctx(aead_alg_instance(tfm));
  41 }
  42
  43 static int pcrypt_aead_setkey(struct crypto_aead *parent,
  44                               const u8 *key, unsigned int keylen)
  45 {
  46         struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(parent);
  47
  48         return crypto_aead_setkey(ctx->child, key, keylen);
  49 }
  50
  51 static int pcrypt_aead_setauthsize(struct crypto_aead *parent,
  52                                    unsigned int authsize)
  53 {
  54         struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(parent);
  55
  56         return crypto_aead_setauthsize(ctx->child, authsize);
  57 }
  58
  59 static void pcrypt_aead_serial(struct padata_priv *padata)
  60 {
  61         struct pcrypt_request *preq = pcrypt_padata_request(padata);
  62         struct aead_request *req = pcrypt_request_ctx(preq);
  63
  64         aead_request_complete(req->base.data, padata->info);
  65 }
  66
  67 static void pcrypt_aead_done(struct crypto_async_request *areq, int err)
  68 {
  69         struct aead_request *req = areq->data;
  70         struct pcrypt_request *preq = aead_request_ctx(req);
  71         struct padata_priv *padata = pcrypt_request_padata(preq);
  72
  73         padata->info = err;
  74
  75         padata_do_serial(padata);
  76 }
  77
  78 static void pcrypt_aead_enc(struct padata_priv *padata)
  79 {
  80         struct pcrypt_request *preq = pcrypt_padata_request(padata);
  81         struct aead_request *req = pcrypt_request_ctx(preq);
  82         int ret;
  83
  84         ret = crypto_aead_encrypt(req);
  85
  86         if (ret == -EINPROGRESS)
  87                 return;
  88
  89         padata->info = ret;
  90         padata_do_serial(padata);
  91 }
  92
  93 static int pcrypt_aead_encrypt(struct aead_request *req)
  94 {
  95         int err;
  96         struct pcrypt_request *preq = aead_request_ctx(req);
  97         struct aead_request *creq = pcrypt_request_ctx(preq);
  98         struct padata_priv *padata = pcrypt_request_padata(preq);
  99         struct crypto_aead *aead = crypto_aead_reqtfm(req);
 100         struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(aead);
 101         u32 flags = aead_request_flags(req);
 102         struct pcrypt_instance_ctx *ictx;
 103
 104         ictx = pcrypt_tfm_ictx(aead);
 105
 106         memset(padata, 0, sizeof(struct padata_priv));
 107
 108         padata->parallel = pcrypt_aead_enc;
 109         padata->serial = pcrypt_aead_serial;
 110
 111         aead_request_set_tfm(creq, ctx->child);
 112         aead_request_set_callback(creq, flags & ~CRYPTO_TFM_REQ_MAY_SLEEP,
 113                                   pcrypt_aead_done, req);
 114         aead_request_set_crypt(creq, req->src, req->dst,
 115                                req->cryptlen, req->iv);
 116         aead_request_set_ad(creq, req->assoclen);
 117
 118         err = padata_do_parallel(ictx->psenc, padata, &ctx->cb_cpu);
 119         if (!err)
 120                 return -EINPROGRESS;
 121
 122         return err;
 123 }
 124
 125 static void pcrypt_aead_dec(struct padata_priv *padata)
 126 {
 127         struct pcrypt_request *preq = pcrypt_padata_request(padata);
 128         struct aead_request *req = pcrypt_request_ctx(preq);
 129         int ret;
 130
 131         ret = crypto_aead_decrypt(req);
 132
 133         if (ret == -EINPROGRESS)
 134                 return;
 135
 136         padata->info = ret;
 137         padata_do_serial(padata);
 138 }
 139
 140 static int pcrypt_aead_decrypt(struct aead_request *req)
 141 {
 142         int err;
 143         struct pcrypt_request *preq = aead_request_ctx(req);
 144         struct aead_request *creq = pcrypt_request_ctx(preq);
 145         struct padata_priv *padata = pcrypt_request_padata(preq);
 146         struct crypto_aead *aead = crypto_aead_reqtfm(req);
 147         struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(aead);
 148         u32 flags = aead_request_flags(req);
 149         struct pcrypt_instance_ctx *ictx;
 150
 151         ictx = pcrypt_tfm_ictx(aead);
 152
 153         memset(padata, 0, sizeof(struct padata_priv));
 154
 155         padata->parallel = pcrypt_aead_dec;
 156         padata->serial = pcrypt_aead_serial;
 157
 158         aead_request_set_tfm(creq, ctx->child);
 159         aead_request_set_callback(creq, flags & ~CRYPTO_TFM_REQ_MAY_SLEEP,
 160                                   pcrypt_aead_done, req);
 161         aead_request_set_crypt(creq, req->src, req->dst,
 162                                req->cryptlen, req->iv);
 163         aead_request_set_ad(creq, req->assoclen);
 164
 165         err = padata_do_parallel(ictx->psdec, padata, &ctx->cb_cpu);
 166         if (!err)
 167                 return -EINPROGRESS;
 168
 169         return err;
 170 }
 171
 172 static int pcrypt_aead_init_tfm(struct crypto_aead *tfm)
 173 {
 174         int cpu, cpu_index;
 175         struct aead_instance *inst = aead_alg_instance(tfm);
 176         struct pcrypt_instance_ctx *ictx = aead_instance_ctx(inst);
 177         struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(tfm);
 178         struct crypto_aead *cipher;
 179
 180         cpu_index = (unsigned int)atomic_inc_return(&ictx->tfm_count) %
 181                     cpumask_weight(cpu_online_mask);
 182
 183         ctx->cb_cpu = cpumask_first(cpu_online_mask);
 184         for (cpu = 0; cpu < cpu_index; cpu++)
 185                 ctx->cb_cpu = cpumask_next(ctx->cb_cpu, cpu_online_mask);
 186
 187         cipher = crypto_spawn_aead(&ictx->spawn);
 188
 189         if (IS_ERR(cipher))
 190                 return PTR_ERR(cipher);
 191
 192         ctx->child = cipher;
 193         crypto_aead_set_reqsize(tfm, sizeof(struct pcrypt_request) +
 194                                      sizeof(struct aead_request) +
 195                                      crypto_aead_reqsize(cipher));
 196
 197         return 0;
 198 }
 199
 200 static void pcrypt_aead_exit_tfm(struct crypto_aead *tfm)
 201 {
 202         struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(tfm);
 203
 204         crypto_free_aead(ctx->child);
 205 }
 206
 207 static void pcrypt_free(struct aead_instance *inst)
 208 {
 209         struct pcrypt_instance_ctx *ctx = aead_instance_ctx(inst);
 210
 211         crypto_drop_aead(&ctx->spawn);
 212         padata_free_shell(ctx->psdec);
 213         padata_free_shell(ctx->psenc);
 214         kfree(inst);
 215 }
 216
 217 static int pcrypt_init_instance(struct crypto_instance *inst,
 218                                 struct crypto_alg *alg)
 219 {
 220         if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME,
 221                      "pcrypt(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
 222                 return -ENAMETOOLONG;
 223
 224         memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
 225
 226         inst->alg.cra_priority = alg->cra_priority + 100;
 227         inst->alg.cra_blocksize = alg->cra_blocksize;
 228         inst->alg.cra_alignmask = alg->cra_alignmask;
 229
 230         return 0;
 231 }
 232
 233 static int pcrypt_create_aead(struct crypto_template *tmpl, struct rtattr **tb,
 234                               u32 type, u32 mask)
 235 {
 236         struct pcrypt_instance_ctx *ctx;
 237         struct crypto_attr_type *algt;
 238         struct aead_instance *inst;
 239         struct aead_alg *alg;
 240         const char *name;
 241         int err;
 242
 243         algt = crypto_get_attr_type(tb);
 244         if (IS_ERR(algt))
 245                 return PTR_ERR(algt);
 246
 247         name = crypto_attr_alg_name(tb[1]);
 248         if (IS_ERR(name))
 249                 return PTR_ERR(name);
 250
 251         inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
 252         if (!inst)
 253                 return -ENOMEM;
 254
 255         err = -ENOMEM;
 256
 257         ctx = aead_instance_ctx(inst);
 258         ctx->psenc = padata_alloc_shell(pencrypt);
 259         if (!ctx->psenc)
 260                 goto out_free_inst;
 261
 262         ctx->psdec = padata_alloc_shell(pdecrypt);
 263         if (!ctx->psdec)
 264                 goto out_free_psenc;
 265
 266         crypto_set_aead_spawn(&ctx->spawn, aead_crypto_instance(inst));
 267
 268         err = crypto_grab_aead(&ctx->spawn, name, 0, 0);
 269         if (err)
 270                 goto out_free_psdec;
 271
 272         alg = crypto_spawn_aead_alg(&ctx->spawn);
 273         err = pcrypt_init_instance(aead_crypto_instance(inst), &alg->base);
 274         if (err)
 275                 goto out_drop_aead;
 276
 277         inst->alg.base.cra_flags = CRYPTO_ALG_ASYNC;
 278
 279         inst->alg.ivsize = crypto_aead_alg_ivsize(alg);
 280         inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg);
 281
 282         inst->alg.base.cra_ctxsize = sizeof(struct pcrypt_aead_ctx);
 283
 284         inst->alg.init = pcrypt_aead_init_tfm;
 285         inst->alg.exit = pcrypt_aead_exit_tfm;
 286
 287         inst->alg.setkey = pcrypt_aead_setkey;
 288         inst->alg.setauthsize = pcrypt_aead_setauthsize;
 289         inst->alg.encrypt = pcrypt_aead_encrypt;
 290         inst->alg.decrypt = pcrypt_aead_decrypt;
 291
 292         inst->free = pcrypt_free;
 293
 294         err = aead_register_instance(tmpl, inst);
 295         if (err)
 296                 goto out_drop_aead;
 297
 298 out:
 299         return err;
 300
 301 out_drop_aead:
 302         crypto_drop_aead(&ctx->spawn);
 303 out_free_psdec:
 304         padata_free_shell(ctx->psdec);
 305 out_free_psenc:
 306         padata_free_shell(ctx->psenc);
 307 out_free_inst:
 308         kfree(inst);
 309         goto out;
 310 }
 311
 312 static int pcrypt_create(struct crypto_template *tmpl, struct rtattr **tb)
 313 {
 314         struct crypto_attr_type *algt;
 315
 316         algt = crypto_get_attr_type(tb);
 317         if (IS_ERR(algt))
 318                 return PTR_ERR(algt);
 319
 320         switch (algt->type & algt->mask & CRYPTO_ALG_TYPE_MASK) {
 321         case CRYPTO_ALG_TYPE_AEAD:
 322                 return pcrypt_create_aead(tmpl, tb, algt->type, algt->mask);
 323         }
 324
 325         return -EINVAL;
 326 }
 327
 328 static int pcrypt_sysfs_add(struct padata_instance *pinst, const char *name)
 329 {
 330         int ret;
 331
 332         pinst->kobj.kset = pcrypt_kset;
 333         ret = kobject_add(&pinst->kobj, NULL, "%s", name);
 334         if (!ret)
 335                 kobject_uevent(&pinst->kobj, KOBJ_ADD);
 336
 337         return ret;
 338 }
 339
 340 static int pcrypt_init_padata(struct padata_instance **pinst, const char *name)
 341 {
 342         int ret = -ENOMEM;
 343
 344         *pinst = padata_alloc_possible(name);
 345         if (!*pinst)
 346                 return ret;
 347
 348         ret = pcrypt_sysfs_add(*pinst, name);
 349         if (ret)
 350                 padata_free(*pinst);
 351
 352         return ret;
 353 }
 354
 355 static void pcrypt_fini_padata(struct padata_instance *pinst)
 356 {
 357         padata_stop(pinst);
 358         padata_free(pinst);
 359 }
 360
 361 static struct crypto_template pcrypt_tmpl = {
 362         .name = "pcrypt",
 363         .create = pcrypt_create,
 364         .module = THIS_MODULE,
 365 };
 366
 367 static int __init pcrypt_init(void)
 368 {
 369         int err = -ENOMEM;
 370
 371         pcrypt_kset = kset_create_and_add("pcrypt", NULL, kernel_kobj);
 372         if (!pcrypt_kset)
 373                 goto err;
 374
 375         err = pcrypt_init_padata(&pencrypt, "pencrypt");
 376         if (err)
 377                 goto err_unreg_kset;
 378
 379         err = pcrypt_init_padata(&pdecrypt, "pdecrypt");
 380         if (err)
 381                 goto err_deinit_pencrypt;
 382
 383         padata_start(pencrypt);
 384         padata_start(pdecrypt);
 385
 386         return crypto_register_template(&pcrypt_tmpl);
 387
 388 err_deinit_pencrypt:
 389         pcrypt_fini_padata(pencrypt);
 390 err_unreg_kset:
 391         kset_unregister(pcrypt_kset);
 392 err:
 393         return err;
 394 }
 395
 396 static void __exit pcrypt_exit(void)
 397 {
 398         crypto_unregister_template(&pcrypt_tmpl);
 399
 400         pcrypt_fini_padata(pencrypt);
 401         pcrypt_fini_padata(pdecrypt);
 402
 403         kset_unregister(pcrypt_kset);
 404 }
 405
 406 subsys_initcall(pcrypt_init);
 407 module_exit(pcrypt_exit);
 408
 409 MODULE_LICENSE("GPL");
 410 MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");
 411 MODULE_DESCRIPTION("Parallel crypto wrapper");
 412 MODULE_ALIAS_CRYPTO("pcrypt");