Blame view
crypto/cryptd.c
29.6 KB
2874c5fd2 treewide: Replace... |
1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
124b53d02 [CRYPTO] cryptd: ... |
2 3 4 5 6 |
/* * Software async crypto daemon. * * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> * |
298c926c6 crypto: cryptd - ... |
7 8 9 10 11 12 |
* Added AEAD support to cryptd. * Authors: Tadeusz Struk (tadeusz.struk@intel.com) * Adrian Hoban <adrian.hoban@intel.com> * Gabriele Paoloni <gabriele.paoloni@intel.com> * Aidan O'Mahony (aidan.o.mahony@intel.com) * Copyright (c) 2010, Intel Corporation. |
124b53d02 [CRYPTO] cryptd: ... |
13 |
*/ |
18e33e6d5 crypto: hash - Mo... |
14 |
#include <crypto/internal/hash.h> |
298c926c6 crypto: cryptd - ... |
15 |
#include <crypto/internal/aead.h> |
4e0958d19 crypto: cryptd - ... |
16 |
#include <crypto/internal/skcipher.h> |
1cac2cbc7 crypto: cryptd - ... |
17 |
#include <crypto/cryptd.h> |
43b970fa8 crypto: cryptd - ... |
18 |
#include <linux/refcount.h> |
124b53d02 [CRYPTO] cryptd: ... |
19 20 21 |
#include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> |
124b53d02 [CRYPTO] cryptd: ... |
22 23 |
#include <linux/list.h> #include <linux/module.h> |
124b53d02 [CRYPTO] cryptd: ... |
24 25 26 |
#include <linux/scatterlist.h> #include <linux/sched.h> #include <linux/slab.h> |
3e56e1686 crypto: cryptd - ... |
27 |
#include <linux/workqueue.h> |
124b53d02 [CRYPTO] cryptd: ... |
28 |
|
eaf356e4b crypto: cryptd - ... |
29 |
static unsigned int cryptd_max_cpu_qlen = 1000; |
c3a536056 crypto: cryptd - ... |
30 31 |
module_param(cryptd_max_cpu_qlen, uint, 0); MODULE_PARM_DESC(cryptd_max_cpu_qlen, "Set cryptd Max queue depth"); |
124b53d02 [CRYPTO] cryptd: ... |
32 |
|
3e56e1686 crypto: cryptd - ... |
33 |
static struct workqueue_struct *cryptd_wq; |
254eff771 crypto: cryptd - ... |
34 |
struct cryptd_cpu_queue { |
124b53d02 [CRYPTO] cryptd: ... |
35 |
struct crypto_queue queue; |
254eff771 crypto: cryptd - ... |
36 37 38 39 |
struct work_struct work; }; struct cryptd_queue { |
a29d8b8e2 percpu: add __per... |
40 |
struct cryptd_cpu_queue __percpu *cpu_queue; |
124b53d02 [CRYPTO] cryptd: ... |
41 42 43 44 |
}; struct cryptd_instance_ctx { struct crypto_spawn spawn; |
254eff771 crypto: cryptd - ... |
45 |
struct cryptd_queue *queue; |
124b53d02 [CRYPTO] cryptd: ... |
46 |
}; |
4e0958d19 crypto: cryptd - ... |
47 48 49 50 |
struct skcipherd_instance_ctx { struct crypto_skcipher_spawn spawn; struct cryptd_queue *queue; }; |
46309d893 crypto: cryptd - ... |
51 52 53 54 |
struct hashd_instance_ctx { struct crypto_shash_spawn spawn; struct cryptd_queue *queue; }; |
298c926c6 crypto: cryptd - ... |
55 56 57 58 |
struct aead_instance_ctx { struct crypto_aead_spawn aead_spawn; struct cryptd_queue *queue; }; |
4e0958d19 crypto: cryptd - ... |
59 |
struct cryptd_skcipher_ctx { |
43b970fa8 crypto: cryptd - ... |
60 |
refcount_t refcnt; |
36b3875a9 crypto: cryptd - ... |
61 |
struct crypto_sync_skcipher *child; |
4e0958d19 crypto: cryptd - ... |
62 63 64 65 66 |
}; struct cryptd_skcipher_request_ctx { crypto_completion_t complete; }; |
b8a28251c [CRYPTO] cryptd: ... |
67 |
struct cryptd_hash_ctx { |
43b970fa8 crypto: cryptd - ... |
68 |
refcount_t refcnt; |
46309d893 crypto: cryptd - ... |
69 |
struct crypto_shash *child; |
b8a28251c [CRYPTO] cryptd: ... |
70 71 72 73 |
}; struct cryptd_hash_request_ctx { crypto_completion_t complete; |
46309d893 crypto: cryptd - ... |
74 |
struct shash_desc desc; |
b8a28251c [CRYPTO] cryptd: ... |
75 |
}; |
124b53d02 [CRYPTO] cryptd: ... |
76 |
|
298c926c6 crypto: cryptd - ... |
77 |
struct cryptd_aead_ctx { |
43b970fa8 crypto: cryptd - ... |
78 |
refcount_t refcnt; |
298c926c6 crypto: cryptd - ... |
79 80 81 82 83 84 |
struct crypto_aead *child; }; struct cryptd_aead_request_ctx { crypto_completion_t complete; }; |
254eff771 crypto: cryptd - ... |
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
static void cryptd_queue_worker(struct work_struct *work); static int cryptd_init_queue(struct cryptd_queue *queue, unsigned int max_cpu_qlen) { int cpu; struct cryptd_cpu_queue *cpu_queue; queue->cpu_queue = alloc_percpu(struct cryptd_cpu_queue); if (!queue->cpu_queue) return -ENOMEM; for_each_possible_cpu(cpu) { cpu_queue = per_cpu_ptr(queue->cpu_queue, cpu); crypto_init_queue(&cpu_queue->queue, max_cpu_qlen); INIT_WORK(&cpu_queue->work, cryptd_queue_worker); } |
c3a536056 crypto: cryptd - ... |
101 102 |
pr_info("cryptd: max_cpu_qlen set to %d ", max_cpu_qlen); |
254eff771 crypto: cryptd - ... |
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
return 0; } static void cryptd_fini_queue(struct cryptd_queue *queue) { int cpu; struct cryptd_cpu_queue *cpu_queue; for_each_possible_cpu(cpu) { cpu_queue = per_cpu_ptr(queue->cpu_queue, cpu); BUG_ON(cpu_queue->queue.qlen); } free_percpu(queue->cpu_queue); } static int cryptd_enqueue_request(struct cryptd_queue *queue, struct crypto_async_request *request) { int cpu, err; struct cryptd_cpu_queue *cpu_queue; |
43b970fa8 crypto: cryptd - ... |
123 |
refcount_t *refcnt; |
254eff771 crypto: cryptd - ... |
124 125 |
cpu = get_cpu(); |
0b44f4861 this_cpu: Use thi... |
126 |
cpu_queue = this_cpu_ptr(queue->cpu_queue); |
254eff771 crypto: cryptd - ... |
127 |
err = crypto_enqueue_request(&cpu_queue->queue, request); |
81760ea6a crypto: cryptd - ... |
128 129 |
refcnt = crypto_tfm_ctx(request->tfm); |
81760ea6a crypto: cryptd - ... |
130 |
|
6b80ea389 crypto: change tr... |
131 |
if (err == -ENOSPC) |
81760ea6a crypto: cryptd - ... |
132 |
goto out_put_cpu; |
3e56e1686 crypto: cryptd - ... |
133 |
queue_work_on(cpu, cryptd_wq, &cpu_queue->work); |
81760ea6a crypto: cryptd - ... |
134 |
|
43b970fa8 crypto: cryptd - ... |
135 |
if (!refcount_read(refcnt)) |
81760ea6a crypto: cryptd - ... |
136 |
goto out_put_cpu; |
43b970fa8 crypto: cryptd - ... |
137 |
refcount_inc(refcnt); |
81760ea6a crypto: cryptd - ... |
138 139 |
out_put_cpu: |
254eff771 crypto: cryptd - ... |
140 141 142 143 144 145 146 147 148 149 150 151 152 153 |
put_cpu(); return err; } /* Called in workqueue context, do one real cryption work (via * req->complete) and reschedule itself if there are more work to * do. */ static void cryptd_queue_worker(struct work_struct *work) { struct cryptd_cpu_queue *cpu_queue; struct crypto_async_request *req, *backlog; cpu_queue = container_of(work, struct cryptd_cpu_queue, work); |
9efade1b3 crypto: cryptd - ... |
154 155 156 157 158 159 160 |
/* * Only handle one request at a time to avoid hogging crypto workqueue. * preempt_disable/enable is used to prevent being preempted by * cryptd_enqueue_request(). local_bh_disable/enable is used to prevent * cryptd_enqueue_request() being accessed from software interrupts. */ local_bh_disable(); |
254eff771 crypto: cryptd - ... |
161 162 163 164 |
preempt_disable(); backlog = crypto_get_backlog(&cpu_queue->queue); req = crypto_dequeue_request(&cpu_queue->queue); preempt_enable(); |
9efade1b3 crypto: cryptd - ... |
165 |
local_bh_enable(); |
254eff771 crypto: cryptd - ... |
166 167 168 169 170 171 172 173 174 |
if (!req) return; if (backlog) backlog->complete(backlog, -EINPROGRESS); req->complete(req, 0); if (cpu_queue->queue.qlen) |
3e56e1686 crypto: cryptd - ... |
175 |
queue_work(cryptd_wq, &cpu_queue->work); |
254eff771 crypto: cryptd - ... |
176 177 178 |
} static inline struct cryptd_queue *cryptd_get_queue(struct crypto_tfm *tfm) |
124b53d02 [CRYPTO] cryptd: ... |
179 180 181 |
{ struct crypto_instance *inst = crypto_tfm_alg_instance(tfm); struct cryptd_instance_ctx *ictx = crypto_instance_ctx(inst); |
254eff771 crypto: cryptd - ... |
182 |
return ictx->queue; |
124b53d02 [CRYPTO] cryptd: ... |
183 |
} |
466a7b9e3 crypto: cryptd - ... |
184 185 186 187 188 189 190 191 |
static inline void cryptd_check_internal(struct rtattr **tb, u32 *type, u32 *mask) { struct crypto_attr_type *algt; algt = crypto_get_attr_type(tb); if (IS_ERR(algt)) return; |
f6da32059 crypto: cryptd - ... |
192 |
|
5e4b8c1fc crypto: aead - Re... |
193 194 |
*type |= algt->type & CRYPTO_ALG_INTERNAL; *mask |= algt->mask & CRYPTO_ALG_INTERNAL; |
466a7b9e3 crypto: cryptd - ... |
195 |
} |
9b8c456e0 crypto: cryptd - ... |
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 |
static int cryptd_init_instance(struct crypto_instance *inst, struct crypto_alg *alg) { if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "cryptd(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) return -ENAMETOOLONG; memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); inst->alg.cra_priority = alg->cra_priority + 50; inst->alg.cra_blocksize = alg->cra_blocksize; inst->alg.cra_alignmask = alg->cra_alignmask; return 0; } |
0b535adfb crypto: cryptd - ... |
212 213 |
static void *cryptd_alloc_instance(struct crypto_alg *alg, unsigned int head, unsigned int tail) |
124b53d02 [CRYPTO] cryptd: ... |
214 |
{ |
0b535adfb crypto: cryptd - ... |
215 |
char *p; |
124b53d02 [CRYPTO] cryptd: ... |
216 |
struct crypto_instance *inst; |
124b53d02 [CRYPTO] cryptd: ... |
217 |
int err; |
0b535adfb crypto: cryptd - ... |
218 219 220 221 222 |
p = kzalloc(head + sizeof(*inst) + tail, GFP_KERNEL); if (!p) return ERR_PTR(-ENOMEM); inst = (void *)(p + head); |
124b53d02 [CRYPTO] cryptd: ... |
223 |
|
9b8c456e0 crypto: cryptd - ... |
224 225 |
err = cryptd_init_instance(inst, alg); if (err) |
124b53d02 [CRYPTO] cryptd: ... |
226 |
goto out_free_inst; |
124b53d02 [CRYPTO] cryptd: ... |
227 |
out: |
0b535adfb crypto: cryptd - ... |
228 |
return p; |
124b53d02 [CRYPTO] cryptd: ... |
229 230 |
out_free_inst: |
0b535adfb crypto: cryptd - ... |
231 232 |
kfree(p); p = ERR_PTR(err); |
124b53d02 [CRYPTO] cryptd: ... |
233 234 |
goto out; } |
4e0958d19 crypto: cryptd - ... |
235 236 237 238 |
static int cryptd_skcipher_setkey(struct crypto_skcipher *parent, const u8 *key, unsigned int keylen) { struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(parent); |
36b3875a9 crypto: cryptd - ... |
239 |
struct crypto_sync_skcipher *child = ctx->child; |
4e0958d19 crypto: cryptd - ... |
240 |
int err; |
36b3875a9 crypto: cryptd - ... |
241 242 243 |
crypto_sync_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_sync_skcipher_set_flags(child, crypto_skcipher_get_flags(parent) & |
4e0958d19 crypto: cryptd - ... |
244 |
CRYPTO_TFM_REQ_MASK); |
36b3875a9 crypto: cryptd - ... |
245 246 247 |
err = crypto_sync_skcipher_setkey(child, key, keylen); crypto_skcipher_set_flags(parent, crypto_sync_skcipher_get_flags(child) & |
4e0958d19 crypto: cryptd - ... |
248 249 250 251 252 253 254 255 256 |
CRYPTO_TFM_RES_MASK); return err; } static void cryptd_skcipher_complete(struct skcipher_request *req, int err) { struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm); struct cryptd_skcipher_request_ctx *rctx = skcipher_request_ctx(req); |
43b970fa8 crypto: cryptd - ... |
257 |
int refcnt = refcount_read(&ctx->refcnt); |
4e0958d19 crypto: cryptd - ... |
258 259 260 261 |
local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); |
43b970fa8 crypto: cryptd - ... |
262 |
if (err != -EINPROGRESS && refcnt && refcount_dec_and_test(&ctx->refcnt)) |
4e0958d19 crypto: cryptd - ... |
263 264 265 266 267 268 269 270 271 272 |
crypto_free_skcipher(tfm); } static void cryptd_skcipher_encrypt(struct crypto_async_request *base, int err) { struct skcipher_request *req = skcipher_request_cast(base); struct cryptd_skcipher_request_ctx *rctx = skcipher_request_ctx(req); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm); |
36b3875a9 crypto: cryptd - ... |
273 274 |
struct crypto_sync_skcipher *child = ctx->child; SYNC_SKCIPHER_REQUEST_ON_STACK(subreq, child); |
4e0958d19 crypto: cryptd - ... |
275 276 277 |
if (unlikely(err == -EINPROGRESS)) goto out; |
36b3875a9 crypto: cryptd - ... |
278 |
skcipher_request_set_sync_tfm(subreq, child); |
4e0958d19 crypto: cryptd - ... |
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 |
skcipher_request_set_callback(subreq, CRYPTO_TFM_REQ_MAY_SLEEP, NULL, NULL); skcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen, req->iv); err = crypto_skcipher_encrypt(subreq); skcipher_request_zero(subreq); req->base.complete = rctx->complete; out: cryptd_skcipher_complete(req, err); } static void cryptd_skcipher_decrypt(struct crypto_async_request *base, int err) { struct skcipher_request *req = skcipher_request_cast(base); struct cryptd_skcipher_request_ctx *rctx = skcipher_request_ctx(req); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm); |
36b3875a9 crypto: cryptd - ... |
300 301 |
struct crypto_sync_skcipher *child = ctx->child; SYNC_SKCIPHER_REQUEST_ON_STACK(subreq, child); |
4e0958d19 crypto: cryptd - ... |
302 303 304 |
if (unlikely(err == -EINPROGRESS)) goto out; |
36b3875a9 crypto: cryptd - ... |
305 |
skcipher_request_set_sync_tfm(subreq, child); |
4e0958d19 crypto: cryptd - ... |
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 |
skcipher_request_set_callback(subreq, CRYPTO_TFM_REQ_MAY_SLEEP, NULL, NULL); skcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen, req->iv); err = crypto_skcipher_decrypt(subreq); skcipher_request_zero(subreq); req->base.complete = rctx->complete; out: cryptd_skcipher_complete(req, err); } static int cryptd_skcipher_enqueue(struct skcipher_request *req, crypto_completion_t compl) { struct cryptd_skcipher_request_ctx *rctx = skcipher_request_ctx(req); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); struct cryptd_queue *queue; queue = cryptd_get_queue(crypto_skcipher_tfm(tfm)); rctx->complete = req->base.complete; req->base.complete = compl; return cryptd_enqueue_request(queue, &req->base); } static int cryptd_skcipher_encrypt_enqueue(struct skcipher_request *req) { return cryptd_skcipher_enqueue(req, cryptd_skcipher_encrypt); } static int cryptd_skcipher_decrypt_enqueue(struct skcipher_request *req) { return cryptd_skcipher_enqueue(req, cryptd_skcipher_decrypt); } static int cryptd_skcipher_init_tfm(struct crypto_skcipher *tfm) { struct skcipher_instance *inst = skcipher_alg_instance(tfm); struct skcipherd_instance_ctx *ictx = skcipher_instance_ctx(inst); struct crypto_skcipher_spawn *spawn = &ictx->spawn; struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm); struct crypto_skcipher *cipher; cipher = crypto_spawn_skcipher(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); |
36b3875a9 crypto: cryptd - ... |
355 |
ctx->child = (struct crypto_sync_skcipher *)cipher; |
4e0958d19 crypto: cryptd - ... |
356 357 358 359 360 361 362 363 |
crypto_skcipher_set_reqsize( tfm, sizeof(struct cryptd_skcipher_request_ctx)); return 0; } static void cryptd_skcipher_exit_tfm(struct crypto_skcipher *tfm) { struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm); |
36b3875a9 crypto: cryptd - ... |
364 |
crypto_free_sync_skcipher(ctx->child); |
4e0958d19 crypto: cryptd - ... |
365 366 367 368 369 370 371 |
} static void cryptd_skcipher_free(struct skcipher_instance *inst) { struct skcipherd_instance_ctx *ctx = skcipher_instance_ctx(inst); crypto_drop_skcipher(&ctx->spawn); |
1a0fad630 crypto: cryptd - ... |
372 |
kfree(inst); |
4e0958d19 crypto: cryptd - ... |
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 |
} static int cryptd_create_skcipher(struct crypto_template *tmpl, struct rtattr **tb, struct cryptd_queue *queue) { struct skcipherd_instance_ctx *ctx; struct skcipher_instance *inst; struct skcipher_alg *alg; const char *name; u32 type; u32 mask; int err; type = 0; mask = CRYPTO_ALG_ASYNC; cryptd_check_internal(tb, &type, &mask); name = crypto_attr_alg_name(tb[1]); if (IS_ERR(name)) return PTR_ERR(name); inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL); if (!inst) return -ENOMEM; ctx = skcipher_instance_ctx(inst); ctx->queue = queue; crypto_set_skcipher_spawn(&ctx->spawn, skcipher_crypto_instance(inst)); err = crypto_grab_skcipher(&ctx->spawn, name, type, mask); if (err) goto out_free_inst; alg = crypto_spawn_skcipher_alg(&ctx->spawn); err = cryptd_init_instance(skcipher_crypto_instance(inst), &alg->base); if (err) goto out_drop_skcipher; inst->alg.base.cra_flags = CRYPTO_ALG_ASYNC | (alg->base.cra_flags & CRYPTO_ALG_INTERNAL); inst->alg.ivsize = crypto_skcipher_alg_ivsize(alg); inst->alg.chunksize = crypto_skcipher_alg_chunksize(alg); inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg); inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(alg); inst->alg.base.cra_ctxsize = sizeof(struct cryptd_skcipher_ctx); inst->alg.init = cryptd_skcipher_init_tfm; inst->alg.exit = cryptd_skcipher_exit_tfm; inst->alg.setkey = cryptd_skcipher_setkey; inst->alg.encrypt = cryptd_skcipher_encrypt_enqueue; inst->alg.decrypt = cryptd_skcipher_decrypt_enqueue; inst->free = cryptd_skcipher_free; err = skcipher_register_instance(tmpl, inst); if (err) { out_drop_skcipher: crypto_drop_skcipher(&ctx->spawn); out_free_inst: kfree(inst); } return err; } |
b8a28251c [CRYPTO] cryptd: ... |
441 442 443 |
static int cryptd_hash_init_tfm(struct crypto_tfm *tfm) { struct crypto_instance *inst = crypto_tfm_alg_instance(tfm); |
46309d893 crypto: cryptd - ... |
444 445 |
struct hashd_instance_ctx *ictx = crypto_instance_ctx(inst); struct crypto_shash_spawn *spawn = &ictx->spawn; |
b8a28251c [CRYPTO] cryptd: ... |
446 |
struct cryptd_hash_ctx *ctx = crypto_tfm_ctx(tfm); |
46309d893 crypto: cryptd - ... |
447 |
struct crypto_shash *hash; |
b8a28251c [CRYPTO] cryptd: ... |
448 |
|
46309d893 crypto: cryptd - ... |
449 450 451 |
hash = crypto_spawn_shash(spawn); if (IS_ERR(hash)) return PTR_ERR(hash); |
b8a28251c [CRYPTO] cryptd: ... |
452 |
|
46309d893 crypto: cryptd - ... |
453 |
ctx->child = hash; |
0d6669e2b crypto: cryptd - ... |
454 455 456 |
crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm), sizeof(struct cryptd_hash_request_ctx) + crypto_shash_descsize(hash)); |
b8a28251c [CRYPTO] cryptd: ... |
457 458 459 460 461 462 |
return 0; } static void cryptd_hash_exit_tfm(struct crypto_tfm *tfm) { struct cryptd_hash_ctx *ctx = crypto_tfm_ctx(tfm); |
b8a28251c [CRYPTO] cryptd: ... |
463 |
|
46309d893 crypto: cryptd - ... |
464 |
crypto_free_shash(ctx->child); |
b8a28251c [CRYPTO] cryptd: ... |
465 466 467 468 469 470 |
} static int cryptd_hash_setkey(struct crypto_ahash *parent, const u8 *key, unsigned int keylen) { struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(parent); |
46309d893 crypto: cryptd - ... |
471 |
struct crypto_shash *child = ctx->child; |
b8a28251c [CRYPTO] cryptd: ... |
472 |
int err; |
46309d893 crypto: cryptd - ... |
473 474 475 476 477 478 |
crypto_shash_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_shash_set_flags(child, crypto_ahash_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_shash_setkey(child, key, keylen); crypto_ahash_set_flags(parent, crypto_shash_get_flags(child) & CRYPTO_TFM_RES_MASK); |
b8a28251c [CRYPTO] cryptd: ... |
479 480 481 482 |
return err; } static int cryptd_hash_enqueue(struct ahash_request *req, |
3e3dc25fe crypto: Resolve s... |
483 |
crypto_completion_t compl) |
b8a28251c [CRYPTO] cryptd: ... |
484 485 486 |
{ struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req); struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); |
254eff771 crypto: cryptd - ... |
487 488 |
struct cryptd_queue *queue = cryptd_get_queue(crypto_ahash_tfm(tfm)); |
b8a28251c [CRYPTO] cryptd: ... |
489 490 |
rctx->complete = req->base.complete; |
3e3dc25fe crypto: Resolve s... |
491 |
req->base.complete = compl; |
b8a28251c [CRYPTO] cryptd: ... |
492 |
|
254eff771 crypto: cryptd - ... |
493 |
return cryptd_enqueue_request(queue, &req->base); |
b8a28251c [CRYPTO] cryptd: ... |
494 |
} |
81760ea6a crypto: cryptd - ... |
495 496 497 498 499 |
static void cryptd_hash_complete(struct ahash_request *req, int err) { struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req); |
43b970fa8 crypto: cryptd - ... |
500 |
int refcnt = refcount_read(&ctx->refcnt); |
81760ea6a crypto: cryptd - ... |
501 502 503 504 |
local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); |
43b970fa8 crypto: cryptd - ... |
505 |
if (err != -EINPROGRESS && refcnt && refcount_dec_and_test(&ctx->refcnt)) |
81760ea6a crypto: cryptd - ... |
506 507 |
crypto_free_ahash(tfm); } |
b8a28251c [CRYPTO] cryptd: ... |
508 509 |
static void cryptd_hash_init(struct crypto_async_request *req_async, int err) { |
46309d893 crypto: cryptd - ... |
510 511 512 513 514 |
struct cryptd_hash_ctx *ctx = crypto_tfm_ctx(req_async->tfm); struct crypto_shash *child = ctx->child; struct ahash_request *req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req); struct shash_desc *desc = &rctx->desc; |
b8a28251c [CRYPTO] cryptd: ... |
515 516 517 |
if (unlikely(err == -EINPROGRESS)) goto out; |
46309d893 crypto: cryptd - ... |
518 |
desc->tfm = child; |
b8a28251c [CRYPTO] cryptd: ... |
519 |
|
46309d893 crypto: cryptd - ... |
520 |
err = crypto_shash_init(desc); |
b8a28251c [CRYPTO] cryptd: ... |
521 522 523 524 |
req->base.complete = rctx->complete; out: |
81760ea6a crypto: cryptd - ... |
525 |
cryptd_hash_complete(req, err); |
b8a28251c [CRYPTO] cryptd: ... |
526 527 528 529 530 531 532 533 534 |
} static int cryptd_hash_init_enqueue(struct ahash_request *req) { return cryptd_hash_enqueue(req, cryptd_hash_init); } static void cryptd_hash_update(struct crypto_async_request *req_async, int err) { |
46309d893 crypto: cryptd - ... |
535 |
struct ahash_request *req = ahash_request_cast(req_async); |
b8a28251c [CRYPTO] cryptd: ... |
536 |
struct cryptd_hash_request_ctx *rctx; |
b8a28251c [CRYPTO] cryptd: ... |
537 538 539 540 541 |
rctx = ahash_request_ctx(req); if (unlikely(err == -EINPROGRESS)) goto out; |
46309d893 crypto: cryptd - ... |
542 |
err = shash_ahash_update(req, &rctx->desc); |
b8a28251c [CRYPTO] cryptd: ... |
543 544 545 546 |
req->base.complete = rctx->complete; out: |
81760ea6a crypto: cryptd - ... |
547 |
cryptd_hash_complete(req, err); |
b8a28251c [CRYPTO] cryptd: ... |
548 549 550 551 552 553 554 555 556 |
} static int cryptd_hash_update_enqueue(struct ahash_request *req) { return cryptd_hash_enqueue(req, cryptd_hash_update); } static void cryptd_hash_final(struct crypto_async_request *req_async, int err) { |
46309d893 crypto: cryptd - ... |
557 558 |
struct ahash_request *req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req); |
b8a28251c [CRYPTO] cryptd: ... |
559 560 561 |
if (unlikely(err == -EINPROGRESS)) goto out; |
46309d893 crypto: cryptd - ... |
562 |
err = crypto_shash_final(&rctx->desc, req->result); |
b8a28251c [CRYPTO] cryptd: ... |
563 564 565 566 |
req->base.complete = rctx->complete; out: |
81760ea6a crypto: cryptd - ... |
567 |
cryptd_hash_complete(req, err); |
b8a28251c [CRYPTO] cryptd: ... |
568 569 570 571 572 573 |
} static int cryptd_hash_final_enqueue(struct ahash_request *req) { return cryptd_hash_enqueue(req, cryptd_hash_final); } |
6fba00d17 crypto: cryptd - ... |
574 575 576 577 578 579 580 581 582 583 584 585 586 |
static void cryptd_hash_finup(struct crypto_async_request *req_async, int err) { struct ahash_request *req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req); if (unlikely(err == -EINPROGRESS)) goto out; err = shash_ahash_finup(req, &rctx->desc); req->base.complete = rctx->complete; out: |
81760ea6a crypto: cryptd - ... |
587 |
cryptd_hash_complete(req, err); |
6fba00d17 crypto: cryptd - ... |
588 589 590 591 592 593 |
} static int cryptd_hash_finup_enqueue(struct ahash_request *req) { return cryptd_hash_enqueue(req, cryptd_hash_finup); } |
b8a28251c [CRYPTO] cryptd: ... |
594 595 |
static void cryptd_hash_digest(struct crypto_async_request *req_async, int err) { |
46309d893 crypto: cryptd - ... |
596 597 598 599 600 |
struct cryptd_hash_ctx *ctx = crypto_tfm_ctx(req_async->tfm); struct crypto_shash *child = ctx->child; struct ahash_request *req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req); struct shash_desc *desc = &rctx->desc; |
b8a28251c [CRYPTO] cryptd: ... |
601 602 603 |
if (unlikely(err == -EINPROGRESS)) goto out; |
46309d893 crypto: cryptd - ... |
604 |
desc->tfm = child; |
b8a28251c [CRYPTO] cryptd: ... |
605 |
|
46309d893 crypto: cryptd - ... |
606 |
err = shash_ahash_digest(req, desc); |
b8a28251c [CRYPTO] cryptd: ... |
607 608 609 610 |
req->base.complete = rctx->complete; out: |
81760ea6a crypto: cryptd - ... |
611 |
cryptd_hash_complete(req, err); |
b8a28251c [CRYPTO] cryptd: ... |
612 613 614 615 616 617 |
} static int cryptd_hash_digest_enqueue(struct ahash_request *req) { return cryptd_hash_enqueue(req, cryptd_hash_digest); } |
6fba00d17 crypto: cryptd - ... |
618 619 620 621 622 623 624 625 626 |
static int cryptd_hash_export(struct ahash_request *req, void *out) { struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req); return crypto_shash_export(&rctx->desc, out); } static int cryptd_hash_import(struct ahash_request *req, const void *in) { |
0bd222359 crypto: cryptd - ... |
627 628 629 630 631 |
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct shash_desc *desc = cryptd_shash_desc(req); desc->tfm = ctx->child; |
6fba00d17 crypto: cryptd - ... |
632 |
|
0bd222359 crypto: cryptd - ... |
633 |
return crypto_shash_import(desc, in); |
6fba00d17 crypto: cryptd - ... |
634 |
} |
9cd899a32 crypto: cryptd - ... |
635 636 |
static int cryptd_create_hash(struct crypto_template *tmpl, struct rtattr **tb, struct cryptd_queue *queue) |
b8a28251c [CRYPTO] cryptd: ... |
637 |
{ |
46309d893 crypto: cryptd - ... |
638 |
struct hashd_instance_ctx *ctx; |
0b535adfb crypto: cryptd - ... |
639 |
struct ahash_instance *inst; |
46309d893 crypto: cryptd - ... |
640 |
struct shash_alg *salg; |
b8a28251c [CRYPTO] cryptd: ... |
641 |
struct crypto_alg *alg; |
466a7b9e3 crypto: cryptd - ... |
642 643 |
u32 type = 0; u32 mask = 0; |
46309d893 crypto: cryptd - ... |
644 |
int err; |
b8a28251c [CRYPTO] cryptd: ... |
645 |
|
466a7b9e3 crypto: cryptd - ... |
646 647 648 |
cryptd_check_internal(tb, &type, &mask); salg = shash_attr_alg(tb[1], type, mask); |
46309d893 crypto: cryptd - ... |
649 |
if (IS_ERR(salg)) |
9cd899a32 crypto: cryptd - ... |
650 |
return PTR_ERR(salg); |
b8a28251c [CRYPTO] cryptd: ... |
651 |
|
46309d893 crypto: cryptd - ... |
652 |
alg = &salg->base; |
0b535adfb crypto: cryptd - ... |
653 654 |
inst = cryptd_alloc_instance(alg, ahash_instance_headroom(), sizeof(*ctx)); |
05ed8758f crypto: cryptd - ... |
655 |
err = PTR_ERR(inst); |
b8a28251c [CRYPTO] cryptd: ... |
656 657 |
if (IS_ERR(inst)) goto out_put_alg; |
0b535adfb crypto: cryptd - ... |
658 |
ctx = ahash_instance_ctx(inst); |
46309d893 crypto: cryptd - ... |
659 |
ctx->queue = queue; |
0b535adfb crypto: cryptd - ... |
660 661 |
err = crypto_init_shash_spawn(&ctx->spawn, salg, ahash_crypto_instance(inst)); |
46309d893 crypto: cryptd - ... |
662 663 |
if (err) goto out_free_inst; |
a208fa8f3 crypto: hash - an... |
664 665 666 |
inst->alg.halg.base.cra_flags = CRYPTO_ALG_ASYNC | (alg->cra_flags & (CRYPTO_ALG_INTERNAL | CRYPTO_ALG_OPTIONAL_KEY)); |
b8a28251c [CRYPTO] cryptd: ... |
667 |
|
0b535adfb crypto: cryptd - ... |
668 |
inst->alg.halg.digestsize = salg->digestsize; |
1a0783402 crypto: cryptd - ... |
669 |
inst->alg.halg.statesize = salg->statesize; |
0b535adfb crypto: cryptd - ... |
670 |
inst->alg.halg.base.cra_ctxsize = sizeof(struct cryptd_hash_ctx); |
b8a28251c [CRYPTO] cryptd: ... |
671 |
|
0b535adfb crypto: cryptd - ... |
672 673 |
inst->alg.halg.base.cra_init = cryptd_hash_init_tfm; inst->alg.halg.base.cra_exit = cryptd_hash_exit_tfm; |
b8a28251c [CRYPTO] cryptd: ... |
674 |
|
0b535adfb crypto: cryptd - ... |
675 676 677 |
inst->alg.init = cryptd_hash_init_enqueue; inst->alg.update = cryptd_hash_update_enqueue; inst->alg.final = cryptd_hash_final_enqueue; |
6fba00d17 crypto: cryptd - ... |
678 679 680 |
inst->alg.finup = cryptd_hash_finup_enqueue; inst->alg.export = cryptd_hash_export; inst->alg.import = cryptd_hash_import; |
841a3ff32 crypto: cryptd - ... |
681 682 |
if (crypto_shash_alg_has_setkey(salg)) inst->alg.setkey = cryptd_hash_setkey; |
0b535adfb crypto: cryptd - ... |
683 |
inst->alg.digest = cryptd_hash_digest_enqueue; |
b8a28251c [CRYPTO] cryptd: ... |
684 |
|
0b535adfb crypto: cryptd - ... |
685 |
err = ahash_register_instance(tmpl, inst); |
9cd899a32 crypto: cryptd - ... |
686 687 688 689 690 |
if (err) { crypto_drop_shash(&ctx->spawn); out_free_inst: kfree(inst); } |
b8a28251c [CRYPTO] cryptd: ... |
691 692 |
out_put_alg: crypto_mod_put(alg); |
9cd899a32 crypto: cryptd - ... |
693 |
return err; |
b8a28251c [CRYPTO] cryptd: ... |
694 |
} |
92b9876bd crypto: cryptd - ... |
695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 |
static int cryptd_aead_setkey(struct crypto_aead *parent, const u8 *key, unsigned int keylen) { struct cryptd_aead_ctx *ctx = crypto_aead_ctx(parent); struct crypto_aead *child = ctx->child; return crypto_aead_setkey(child, key, keylen); } static int cryptd_aead_setauthsize(struct crypto_aead *parent, unsigned int authsize) { struct cryptd_aead_ctx *ctx = crypto_aead_ctx(parent); struct crypto_aead *child = ctx->child; return crypto_aead_setauthsize(child, authsize); } |
298c926c6 crypto: cryptd - ... |
712 713 714 715 716 717 |
static void cryptd_aead_crypt(struct aead_request *req, struct crypto_aead *child, int err, int (*crypt)(struct aead_request *req)) { struct cryptd_aead_request_ctx *rctx; |
81760ea6a crypto: cryptd - ... |
718 |
struct cryptd_aead_ctx *ctx; |
ec9f2006f crypto: cryptd - ... |
719 |
crypto_completion_t compl; |
81760ea6a crypto: cryptd - ... |
720 721 |
struct crypto_aead *tfm; int refcnt; |
ec9f2006f crypto: cryptd - ... |
722 |
|
298c926c6 crypto: cryptd - ... |
723 |
rctx = aead_request_ctx(req); |
ec9f2006f crypto: cryptd - ... |
724 |
compl = rctx->complete; |
298c926c6 crypto: cryptd - ... |
725 |
|
31bd44e76 crypto: cryptd - ... |
726 |
tfm = crypto_aead_reqtfm(req); |
298c926c6 crypto: cryptd - ... |
727 728 729 730 |
if (unlikely(err == -EINPROGRESS)) goto out; aead_request_set_tfm(req, child); err = crypt( req ); |
81760ea6a crypto: cryptd - ... |
731 |
|
298c926c6 crypto: cryptd - ... |
732 |
out: |
81760ea6a crypto: cryptd - ... |
733 |
ctx = crypto_aead_ctx(tfm); |
43b970fa8 crypto: cryptd - ... |
734 |
refcnt = refcount_read(&ctx->refcnt); |
81760ea6a crypto: cryptd - ... |
735 |
|
298c926c6 crypto: cryptd - ... |
736 |
local_bh_disable(); |
ec9f2006f crypto: cryptd - ... |
737 |
compl(&req->base, err); |
298c926c6 crypto: cryptd - ... |
738 |
local_bh_enable(); |
81760ea6a crypto: cryptd - ... |
739 |
|
43b970fa8 crypto: cryptd - ... |
740 |
if (err != -EINPROGRESS && refcnt && refcount_dec_and_test(&ctx->refcnt)) |
81760ea6a crypto: cryptd - ... |
741 |
crypto_free_aead(tfm); |
298c926c6 crypto: cryptd - ... |
742 743 744 745 746 747 748 749 750 |
} static void cryptd_aead_encrypt(struct crypto_async_request *areq, int err) { struct cryptd_aead_ctx *ctx = crypto_tfm_ctx(areq->tfm); struct crypto_aead *child = ctx->child; struct aead_request *req; req = container_of(areq, struct aead_request, base); |
ba3749a71 crypto: cryptd - ... |
751 |
cryptd_aead_crypt(req, child, err, crypto_aead_alg(child)->encrypt); |
298c926c6 crypto: cryptd - ... |
752 753 754 755 756 757 758 759 760 |
} static void cryptd_aead_decrypt(struct crypto_async_request *areq, int err) { struct cryptd_aead_ctx *ctx = crypto_tfm_ctx(areq->tfm); struct crypto_aead *child = ctx->child; struct aead_request *req; req = container_of(areq, struct aead_request, base); |
ba3749a71 crypto: cryptd - ... |
761 |
cryptd_aead_crypt(req, child, err, crypto_aead_alg(child)->decrypt); |
298c926c6 crypto: cryptd - ... |
762 763 764 |
} static int cryptd_aead_enqueue(struct aead_request *req, |
3e3dc25fe crypto: Resolve s... |
765 |
crypto_completion_t compl) |
298c926c6 crypto: cryptd - ... |
766 767 768 769 770 771 |
{ struct cryptd_aead_request_ctx *rctx = aead_request_ctx(req); struct crypto_aead *tfm = crypto_aead_reqtfm(req); struct cryptd_queue *queue = cryptd_get_queue(crypto_aead_tfm(tfm)); rctx->complete = req->base.complete; |
3e3dc25fe crypto: Resolve s... |
772 |
req->base.complete = compl; |
298c926c6 crypto: cryptd - ... |
773 774 775 776 777 778 779 780 781 782 783 784 |
return cryptd_enqueue_request(queue, &req->base); } static int cryptd_aead_encrypt_enqueue(struct aead_request *req) { return cryptd_aead_enqueue(req, cryptd_aead_encrypt ); } static int cryptd_aead_decrypt_enqueue(struct aead_request *req) { return cryptd_aead_enqueue(req, cryptd_aead_decrypt ); } |
f614e546f crypto: cryptd - ... |
785 |
static int cryptd_aead_init_tfm(struct crypto_aead *tfm) |
298c926c6 crypto: cryptd - ... |
786 |
{ |
f614e546f crypto: cryptd - ... |
787 788 |
struct aead_instance *inst = aead_alg_instance(tfm); struct aead_instance_ctx *ictx = aead_instance_ctx(inst); |
298c926c6 crypto: cryptd - ... |
789 |
struct crypto_aead_spawn *spawn = &ictx->aead_spawn; |
f614e546f crypto: cryptd - ... |
790 |
struct cryptd_aead_ctx *ctx = crypto_aead_ctx(tfm); |
298c926c6 crypto: cryptd - ... |
791 792 793 794 795 |
struct crypto_aead *cipher; cipher = crypto_spawn_aead(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); |
298c926c6 crypto: cryptd - ... |
796 |
ctx->child = cipher; |
ec9f2006f crypto: cryptd - ... |
797 798 799 |
crypto_aead_set_reqsize( tfm, max((unsigned)sizeof(struct cryptd_aead_request_ctx), crypto_aead_reqsize(cipher))); |
298c926c6 crypto: cryptd - ... |
800 801 |
return 0; } |
f614e546f crypto: cryptd - ... |
802 |
static void cryptd_aead_exit_tfm(struct crypto_aead *tfm) |
298c926c6 crypto: cryptd - ... |
803 |
{ |
f614e546f crypto: cryptd - ... |
804 |
struct cryptd_aead_ctx *ctx = crypto_aead_ctx(tfm); |
298c926c6 crypto: cryptd - ... |
805 806 807 808 809 810 811 812 |
crypto_free_aead(ctx->child); } static int cryptd_create_aead(struct crypto_template *tmpl, struct rtattr **tb, struct cryptd_queue *queue) { struct aead_instance_ctx *ctx; |
f614e546f crypto: cryptd - ... |
813 814 |
struct aead_instance *inst; struct aead_alg *alg; |
9b8c456e0 crypto: cryptd - ... |
815 816 |
const char *name; u32 type = 0; |
ec9f2006f crypto: cryptd - ... |
817 |
u32 mask = CRYPTO_ALG_ASYNC; |
298c926c6 crypto: cryptd - ... |
818 |
int err; |
466a7b9e3 crypto: cryptd - ... |
819 |
cryptd_check_internal(tb, &type, &mask); |
9b8c456e0 crypto: cryptd - ... |
820 821 822 |
name = crypto_attr_alg_name(tb[1]); if (IS_ERR(name)) return PTR_ERR(name); |
298c926c6 crypto: cryptd - ... |
823 |
|
9b8c456e0 crypto: cryptd - ... |
824 825 826 |
inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL); if (!inst) return -ENOMEM; |
298c926c6 crypto: cryptd - ... |
827 |
|
f614e546f crypto: cryptd - ... |
828 |
ctx = aead_instance_ctx(inst); |
298c926c6 crypto: cryptd - ... |
829 |
ctx->queue = queue; |
f614e546f crypto: cryptd - ... |
830 |
crypto_set_aead_spawn(&ctx->aead_spawn, aead_crypto_instance(inst)); |
9b8c456e0 crypto: cryptd - ... |
831 |
err = crypto_grab_aead(&ctx->aead_spawn, name, type, mask); |
298c926c6 crypto: cryptd - ... |
832 833 |
if (err) goto out_free_inst; |
f614e546f crypto: cryptd - ... |
834 835 |
alg = crypto_spawn_aead_alg(&ctx->aead_spawn); err = cryptd_init_instance(aead_crypto_instance(inst), &alg->base); |
9b8c456e0 crypto: cryptd - ... |
836 837 |
if (err) goto out_drop_aead; |
f614e546f crypto: cryptd - ... |
838 |
inst->alg.base.cra_flags = CRYPTO_ALG_ASYNC | |
5e4b8c1fc crypto: aead - Re... |
839 |
(alg->base.cra_flags & CRYPTO_ALG_INTERNAL); |
f614e546f crypto: cryptd - ... |
840 |
inst->alg.base.cra_ctxsize = sizeof(struct cryptd_aead_ctx); |
298c926c6 crypto: cryptd - ... |
841 |
|
f614e546f crypto: cryptd - ... |
842 843 844 845 846 847 848 849 850 851 852 |
inst->alg.ivsize = crypto_aead_alg_ivsize(alg); inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg); inst->alg.init = cryptd_aead_init_tfm; inst->alg.exit = cryptd_aead_exit_tfm; inst->alg.setkey = cryptd_aead_setkey; inst->alg.setauthsize = cryptd_aead_setauthsize; inst->alg.encrypt = cryptd_aead_encrypt_enqueue; inst->alg.decrypt = cryptd_aead_decrypt_enqueue; err = aead_register_instance(tmpl, inst); |
298c926c6 crypto: cryptd - ... |
853 |
if (err) { |
9b8c456e0 crypto: cryptd - ... |
854 855 |
out_drop_aead: crypto_drop_aead(&ctx->aead_spawn); |
298c926c6 crypto: cryptd - ... |
856 857 858 |
out_free_inst: kfree(inst); } |
298c926c6 crypto: cryptd - ... |
859 860 |
return err; } |
254eff771 crypto: cryptd - ... |
861 |
static struct cryptd_queue queue; |
124b53d02 [CRYPTO] cryptd: ... |
862 |
|
9cd899a32 crypto: cryptd - ... |
863 |
static int cryptd_create(struct crypto_template *tmpl, struct rtattr **tb) |
124b53d02 [CRYPTO] cryptd: ... |
864 865 866 867 868 |
{ struct crypto_attr_type *algt; algt = crypto_get_attr_type(tb); if (IS_ERR(algt)) |
9cd899a32 crypto: cryptd - ... |
869 |
return PTR_ERR(algt); |
124b53d02 [CRYPTO] cryptd: ... |
870 871 872 |
switch (algt->type & algt->mask & CRYPTO_ALG_TYPE_MASK) { case CRYPTO_ALG_TYPE_BLKCIPHER: |
4e0958d19 crypto: cryptd - ... |
873 |
return cryptd_create_skcipher(tmpl, tb, &queue); |
84ede58df crypto: hash - re... |
874 |
case CRYPTO_ALG_TYPE_HASH: |
9cd899a32 crypto: cryptd - ... |
875 |
return cryptd_create_hash(tmpl, tb, &queue); |
298c926c6 crypto: cryptd - ... |
876 877 |
case CRYPTO_ALG_TYPE_AEAD: return cryptd_create_aead(tmpl, tb, &queue); |
124b53d02 [CRYPTO] cryptd: ... |
878 |
} |
9cd899a32 crypto: cryptd - ... |
879 |
return -EINVAL; |
124b53d02 [CRYPTO] cryptd: ... |
880 881 882 883 884 |
} static void cryptd_free(struct crypto_instance *inst) { struct cryptd_instance_ctx *ctx = crypto_instance_ctx(inst); |
0b535adfb crypto: cryptd - ... |
885 |
struct hashd_instance_ctx *hctx = crypto_instance_ctx(inst); |
298c926c6 crypto: cryptd - ... |
886 |
struct aead_instance_ctx *aead_ctx = crypto_instance_ctx(inst); |
0b535adfb crypto: cryptd - ... |
887 888 889 890 891 892 |
switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) { case CRYPTO_ALG_TYPE_AHASH: crypto_drop_shash(&hctx->spawn); kfree(ahash_instance(inst)); return; |
298c926c6 crypto: cryptd - ... |
893 |
case CRYPTO_ALG_TYPE_AEAD: |
f614e546f crypto: cryptd - ... |
894 895 |
crypto_drop_aead(&aead_ctx->aead_spawn); kfree(aead_instance(inst)); |
298c926c6 crypto: cryptd - ... |
896 897 898 899 |
return; default: crypto_drop_spawn(&ctx->spawn); kfree(inst); |
0b535adfb crypto: cryptd - ... |
900 |
} |
124b53d02 [CRYPTO] cryptd: ... |
901 902 903 904 |
} static struct crypto_template cryptd_tmpl = { .name = "cryptd", |
9cd899a32 crypto: cryptd - ... |
905 |
.create = cryptd_create, |
124b53d02 [CRYPTO] cryptd: ... |
906 907 908 |
.free = cryptd_free, .module = THIS_MODULE, }; |
4e0958d19 crypto: cryptd - ... |
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 |
struct cryptd_skcipher *cryptd_alloc_skcipher(const char *alg_name, u32 type, u32 mask) { char cryptd_alg_name[CRYPTO_MAX_ALG_NAME]; struct cryptd_skcipher_ctx *ctx; struct crypto_skcipher *tfm; if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME, "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-EINVAL); tfm = crypto_alloc_skcipher(cryptd_alg_name, type, mask); if (IS_ERR(tfm)) return ERR_CAST(tfm); if (tfm->base.__crt_alg->cra_module != THIS_MODULE) { crypto_free_skcipher(tfm); return ERR_PTR(-EINVAL); } ctx = crypto_skcipher_ctx(tfm); |
43b970fa8 crypto: cryptd - ... |
930 |
refcount_set(&ctx->refcnt, 1); |
4e0958d19 crypto: cryptd - ... |
931 932 933 934 935 936 937 938 |
return container_of(tfm, struct cryptd_skcipher, base); } EXPORT_SYMBOL_GPL(cryptd_alloc_skcipher); struct crypto_skcipher *cryptd_skcipher_child(struct cryptd_skcipher *tfm) { struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(&tfm->base); |
36b3875a9 crypto: cryptd - ... |
939 |
return &ctx->child->base; |
4e0958d19 crypto: cryptd - ... |
940 941 942 943 944 945 |
} EXPORT_SYMBOL_GPL(cryptd_skcipher_child); bool cryptd_skcipher_queued(struct cryptd_skcipher *tfm) { struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(&tfm->base); |
43b970fa8 crypto: cryptd - ... |
946 |
return refcount_read(&ctx->refcnt) - 1; |
4e0958d19 crypto: cryptd - ... |
947 948 949 950 951 952 |
} EXPORT_SYMBOL_GPL(cryptd_skcipher_queued); void cryptd_free_skcipher(struct cryptd_skcipher *tfm) { struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(&tfm->base); |
43b970fa8 crypto: cryptd - ... |
953 |
if (refcount_dec_and_test(&ctx->refcnt)) |
4e0958d19 crypto: cryptd - ... |
954 955 956 |
crypto_free_skcipher(&tfm->base); } EXPORT_SYMBOL_GPL(cryptd_free_skcipher); |
ace136636 crypto: cryptd - ... |
957 958 959 960 |
struct cryptd_ahash *cryptd_alloc_ahash(const char *alg_name, u32 type, u32 mask) { char cryptd_alg_name[CRYPTO_MAX_ALG_NAME]; |
81760ea6a crypto: cryptd - ... |
961 |
struct cryptd_hash_ctx *ctx; |
ace136636 crypto: cryptd - ... |
962 963 964 965 966 967 968 969 970 971 972 973 |
struct crypto_ahash *tfm; if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME, "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-EINVAL); tfm = crypto_alloc_ahash(cryptd_alg_name, type, mask); if (IS_ERR(tfm)) return ERR_CAST(tfm); if (tfm->base.__crt_alg->cra_module != THIS_MODULE) { crypto_free_ahash(tfm); return ERR_PTR(-EINVAL); } |
81760ea6a crypto: cryptd - ... |
974 |
ctx = crypto_ahash_ctx(tfm); |
43b970fa8 crypto: cryptd - ... |
975 |
refcount_set(&ctx->refcnt, 1); |
81760ea6a crypto: cryptd - ... |
976 |
|
ace136636 crypto: cryptd - ... |
977 978 979 980 981 982 983 984 985 986 987 |
return __cryptd_ahash_cast(tfm); } EXPORT_SYMBOL_GPL(cryptd_alloc_ahash); struct crypto_shash *cryptd_ahash_child(struct cryptd_ahash *tfm) { struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(&tfm->base); return ctx->child; } EXPORT_SYMBOL_GPL(cryptd_ahash_child); |
0e1227d35 crypto: ghash - A... |
988 989 990 991 992 993 |
struct shash_desc *cryptd_shash_desc(struct ahash_request *req) { struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req); return &rctx->desc; } EXPORT_SYMBOL_GPL(cryptd_shash_desc); |
81760ea6a crypto: cryptd - ... |
994 995 996 |
bool cryptd_ahash_queued(struct cryptd_ahash *tfm) { struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(&tfm->base); |
43b970fa8 crypto: cryptd - ... |
997 |
return refcount_read(&ctx->refcnt) - 1; |
81760ea6a crypto: cryptd - ... |
998 999 |
} EXPORT_SYMBOL_GPL(cryptd_ahash_queued); |
ace136636 crypto: cryptd - ... |
1000 1001 |
void cryptd_free_ahash(struct cryptd_ahash *tfm) { |
81760ea6a crypto: cryptd - ... |
1002 |
struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(&tfm->base); |
43b970fa8 crypto: cryptd - ... |
1003 |
if (refcount_dec_and_test(&ctx->refcnt)) |
81760ea6a crypto: cryptd - ... |
1004 |
crypto_free_ahash(&tfm->base); |
ace136636 crypto: cryptd - ... |
1005 1006 |
} EXPORT_SYMBOL_GPL(cryptd_free_ahash); |
298c926c6 crypto: cryptd - ... |
1007 1008 1009 1010 |
struct cryptd_aead *cryptd_alloc_aead(const char *alg_name, u32 type, u32 mask) { char cryptd_alg_name[CRYPTO_MAX_ALG_NAME]; |
81760ea6a crypto: cryptd - ... |
1011 |
struct cryptd_aead_ctx *ctx; |
298c926c6 crypto: cryptd - ... |
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 |
struct crypto_aead *tfm; if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME, "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-EINVAL); tfm = crypto_alloc_aead(cryptd_alg_name, type, mask); if (IS_ERR(tfm)) return ERR_CAST(tfm); if (tfm->base.__crt_alg->cra_module != THIS_MODULE) { crypto_free_aead(tfm); return ERR_PTR(-EINVAL); } |
81760ea6a crypto: cryptd - ... |
1024 1025 |
ctx = crypto_aead_ctx(tfm); |
43b970fa8 crypto: cryptd - ... |
1026 |
refcount_set(&ctx->refcnt, 1); |
81760ea6a crypto: cryptd - ... |
1027 |
|
298c926c6 crypto: cryptd - ... |
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 |
return __cryptd_aead_cast(tfm); } EXPORT_SYMBOL_GPL(cryptd_alloc_aead); struct crypto_aead *cryptd_aead_child(struct cryptd_aead *tfm) { struct cryptd_aead_ctx *ctx; ctx = crypto_aead_ctx(&tfm->base); return ctx->child; } EXPORT_SYMBOL_GPL(cryptd_aead_child); |
81760ea6a crypto: cryptd - ... |
1039 1040 1041 |
bool cryptd_aead_queued(struct cryptd_aead *tfm) { struct cryptd_aead_ctx *ctx = crypto_aead_ctx(&tfm->base); |
43b970fa8 crypto: cryptd - ... |
1042 |
return refcount_read(&ctx->refcnt) - 1; |
81760ea6a crypto: cryptd - ... |
1043 1044 |
} EXPORT_SYMBOL_GPL(cryptd_aead_queued); |
298c926c6 crypto: cryptd - ... |
1045 1046 |
void cryptd_free_aead(struct cryptd_aead *tfm) { |
81760ea6a crypto: cryptd - ... |
1047 |
struct cryptd_aead_ctx *ctx = crypto_aead_ctx(&tfm->base); |
43b970fa8 crypto: cryptd - ... |
1048 |
if (refcount_dec_and_test(&ctx->refcnt)) |
81760ea6a crypto: cryptd - ... |
1049 |
crypto_free_aead(&tfm->base); |
298c926c6 crypto: cryptd - ... |
1050 1051 |
} EXPORT_SYMBOL_GPL(cryptd_free_aead); |
124b53d02 [CRYPTO] cryptd: ... |
1052 1053 1054 |
static int __init cryptd_init(void) { int err; |
3e56e1686 crypto: cryptd - ... |
1055 1056 1057 1058 |
cryptd_wq = alloc_workqueue("cryptd", WQ_MEM_RECLAIM | WQ_CPU_INTENSIVE, 1); if (!cryptd_wq) return -ENOMEM; |
c3a536056 crypto: cryptd - ... |
1059 |
err = cryptd_init_queue(&queue, cryptd_max_cpu_qlen); |
124b53d02 [CRYPTO] cryptd: ... |
1060 |
if (err) |
3e56e1686 crypto: cryptd - ... |
1061 |
goto err_destroy_wq; |
124b53d02 [CRYPTO] cryptd: ... |
1062 1063 1064 |
err = crypto_register_template(&cryptd_tmpl); if (err) |
3e56e1686 crypto: cryptd - ... |
1065 |
goto err_fini_queue; |
124b53d02 [CRYPTO] cryptd: ... |
1066 |
|
3e56e1686 crypto: cryptd - ... |
1067 1068 1069 1070 1071 1072 |
return 0; err_fini_queue: cryptd_fini_queue(&queue); err_destroy_wq: destroy_workqueue(cryptd_wq); |
124b53d02 [CRYPTO] cryptd: ... |
1073 1074 1075 1076 1077 |
return err; } static void __exit cryptd_exit(void) { |
3e56e1686 crypto: cryptd - ... |
1078 |
destroy_workqueue(cryptd_wq); |
254eff771 crypto: cryptd - ... |
1079 |
cryptd_fini_queue(&queue); |
124b53d02 [CRYPTO] cryptd: ... |
1080 1081 |
crypto_unregister_template(&cryptd_tmpl); } |
b2bac6acf crypto: cryptd - ... |
1082 |
subsys_initcall(cryptd_init); |
124b53d02 [CRYPTO] cryptd: ... |
1083 1084 1085 1086 |
module_exit(cryptd_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Software async crypto daemon"); |
4943ba16b crypto: include c... |
1087 |
MODULE_ALIAS_CRYPTO("cryptd"); |