tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

crypto: ahash - Remove request chaining

Request chaining requires the user to do too much book keeping.
Remove it from ahash.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

Herbert Xu 5bb61dc7 69e5a122

+32 -174
+32 -137
crypto/ahash.c
··· 43 43 }; 44 44 45 45 struct ahash_save_req_state { 46 - struct list_head head; 47 46 struct ahash_request *req0; 48 - struct ahash_request *cur; 49 - int (*op)(struct ahash_request *req); 50 47 crypto_completion_t compl; 51 48 void *data; 52 49 struct scatterlist sg; ··· 51 54 u8 *page; 52 55 unsigned int offset; 53 56 unsigned int nbytes; 57 + bool update; 54 58 }; 55 59 56 - static void ahash_reqchain_done(void *data, int err); 57 60 static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt); 58 61 static void ahash_restore_req(struct ahash_request *req); 59 62 static void ahash_def_finup_done1(void *data, int err); ··· 310 313 } 311 314 EXPORT_SYMBOL_GPL(crypto_ahash_setkey); 312 315 313 - static bool ahash_request_hasvirt(struct ahash_request *req) 314 - { 315 - return ahash_request_isvirt(req); 316 - } 317 - 318 316 static int ahash_reqchain_virt(struct ahash_save_req_state *state, 319 317 int err, u32 mask) 320 318 { 321 - struct ahash_request *req = state->cur; 319 + struct ahash_request *req = state->req0; 320 + struct crypto_ahash *tfm; 321 + 322 + tfm = crypto_ahash_reqtfm(req); 322 323 323 324 for (;;) { 324 325 unsigned len = state->nbytes; 325 - 326 - req->base.err = err; 327 326 328 327 if (!state->offset) 329 328 break; ··· 339 346 state->offset += len; 340 347 req->nbytes = len; 341 348 342 - err = state->op(req); 349 + err = crypto_ahash_alg(tfm)->update(req); 343 350 if (err == -EINPROGRESS) { 344 - if (!list_empty(&state->head) || 345 - state->offset < state->nbytes) 351 + if (state->offset < state->nbytes) 346 352 err = -EBUSY; 347 353 break; 348 354 } ··· 357 365 struct ahash_save_req_state *state, 358 366 int err, u32 mask) 359 367 { 360 - struct ahash_request *req = state->cur; 361 - struct crypto_ahash *tfm; 362 - struct ahash_request *n; 363 - bool update; 364 368 u8 *page; 365 369 366 370 err = ahash_reqchain_virt(state, err, mask); 367 371 if (err == -EINPROGRESS || err == -EBUSY) 368 372 goto out; 369 - 370 - if (req != req0) 371 - list_add_tail(&req->base.list, &req0->base.list); 372 - 373 - tfm = crypto_ahash_reqtfm(req); 374 - update = state->op == crypto_ahash_alg(tfm)->update; 375 - 376 - list_for_each_entry_safe(req, n, &state->head, base.list) { 377 - list_del_init(&req->base.list); 378 - 379 - req->base.flags &= mask; 380 - req->base.complete = ahash_reqchain_done; 381 - req->base.data = state; 382 - state->cur = req; 383 - 384 - if (update && ahash_request_isvirt(req) && req->nbytes) { 385 - unsigned len = req->nbytes; 386 - u8 *result = req->result; 387 - 388 - state->src = req->svirt; 389 - state->nbytes = len; 390 - 391 - len = min(PAGE_SIZE, len); 392 - 393 - memcpy(state->page, req->svirt, len); 394 - state->offset = len; 395 - 396 - ahash_request_set_crypt(req, &state->sg, result, len); 397 - } 398 - 399 - err = state->op(req); 400 - 401 - if (err == -EINPROGRESS) { 402 - if (!list_empty(&state->head) || 403 - state->offset < state->nbytes) 404 - err = -EBUSY; 405 - goto out; 406 - } 407 - 408 - if (err == -EBUSY) 409 - goto out; 410 - 411 - err = ahash_reqchain_virt(state, err, mask); 412 - if (err == -EINPROGRESS || err == -EBUSY) 413 - goto out; 414 - 415 - list_add_tail(&req->base.list, &req0->base.list); 416 - } 417 373 418 374 page = state->page; 419 375 if (page) { ··· 382 442 data = state->data; 383 443 384 444 if (err == -EINPROGRESS) { 385 - if (!list_empty(&state->head) || state->offset < state->nbytes) 445 + if (state->offset < state->nbytes) 386 446 return; 387 447 goto notify; 388 448 } ··· 407 467 int err; 408 468 409 469 if (crypto_ahash_req_chain(tfm) || 410 - (!ahash_request_chained(req) && 411 - (!update || !ahash_request_isvirt(req)))) 470 + !update || !ahash_request_isvirt(req)) 412 471 return op(req); 413 472 414 - if (update && ahash_request_hasvirt(req)) { 415 - gfp_t gfp; 416 - u32 flags; 417 - 418 - flags = ahash_request_flags(req); 419 - gfp = (flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? 420 - GFP_KERNEL : GFP_ATOMIC; 421 - page = (void *)__get_free_page(gfp); 473 + if (update && ahash_request_isvirt(req)) { 474 + page = (void *)__get_free_page(GFP_ATOMIC); 422 475 err = -ENOMEM; 423 476 if (!page) 424 - goto out_set_chain; 477 + goto out; 425 478 } 426 479 427 480 state = &state0; ··· 426 493 state = req->base.data; 427 494 } 428 495 429 - state->op = op; 430 - state->cur = req; 496 + state->update = update; 431 497 state->page = page; 432 498 state->offset = 0; 433 499 state->nbytes = 0; 434 - INIT_LIST_HEAD(&state->head); 435 500 436 501 if (page) 437 502 sg_init_one(&state->sg, page, PAGE_SIZE); ··· 450 519 } 451 520 452 521 err = op(req); 453 - if (err == -EBUSY || err == -EINPROGRESS) 454 - return -EBUSY; 522 + if (err == -EINPROGRESS || err == -EBUSY) { 523 + if (state->offset < state->nbytes) 524 + err = -EBUSY; 525 + return err; 526 + } 455 527 456 528 return ahash_reqchain_finish(req, state, err, ~0); 457 529 458 530 out_free_page: 459 531 free_page((unsigned long)page); 460 532 461 - out_set_chain: 462 - req->base.err = err; 533 + out: 463 534 return err; 464 535 } 465 536 ··· 469 536 { 470 537 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 471 538 472 - if (likely(tfm->using_shash)) { 473 - int err; 474 - 475 - err = crypto_shash_init(prepare_shash_desc(req, tfm)); 476 - req->base.err = err; 477 - return err; 478 - } 479 - 539 + if (likely(tfm->using_shash)) 540 + return crypto_shash_init(prepare_shash_desc(req, tfm)); 480 541 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) 481 542 return -ENOKEY; 482 - 483 543 return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->init); 484 544 } 485 545 EXPORT_SYMBOL_GPL(crypto_ahash_init); ··· 481 555 { 482 556 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 483 557 struct ahash_save_req_state *state; 484 - gfp_t gfp; 485 - u32 flags; 486 558 487 559 if (!ahash_is_async(tfm)) 488 560 return 0; 489 561 490 - flags = ahash_request_flags(req); 491 - gfp = (flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? GFP_KERNEL : GFP_ATOMIC; 492 - state = kmalloc(sizeof(*state), gfp); 562 + state = kmalloc(sizeof(*state), GFP_ATOMIC); 493 563 if (!state) 494 564 return -ENOMEM; 495 565 ··· 518 596 { 519 597 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 520 598 521 - if (likely(tfm->using_shash)) { 522 - int err; 523 - 524 - err = shash_ahash_update(req, ahash_request_ctx(req)); 525 - req->base.err = err; 526 - return err; 527 - } 528 - 599 + if (likely(tfm->using_shash)) 600 + return shash_ahash_update(req, ahash_request_ctx(req)); 529 601 return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->update); 530 602 } 531 603 EXPORT_SYMBOL_GPL(crypto_ahash_update); ··· 528 612 { 529 613 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 530 614 531 - if (likely(tfm->using_shash)) { 532 - int err; 533 - 534 - err = crypto_shash_final(ahash_request_ctx(req), req->result); 535 - req->base.err = err; 536 - return err; 537 - } 538 - 615 + if (likely(tfm->using_shash)) 616 + return crypto_shash_final(ahash_request_ctx(req), req->result); 539 617 return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->final); 540 618 } 541 619 EXPORT_SYMBOL_GPL(crypto_ahash_final); ··· 538 628 { 539 629 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 540 630 541 - if (likely(tfm->using_shash)) { 542 - int err; 543 - 544 - err = shash_ahash_finup(req, ahash_request_ctx(req)); 545 - req->base.err = err; 546 - return err; 547 - } 548 - 631 + if (likely(tfm->using_shash)) 632 + return shash_ahash_finup(req, ahash_request_ctx(req)); 549 633 if (!crypto_ahash_alg(tfm)->finup || 550 - (!crypto_ahash_req_chain(tfm) && ahash_request_hasvirt(req))) 634 + (!crypto_ahash_req_chain(tfm) && ahash_request_isvirt(req))) 551 635 return ahash_def_finup(req); 552 - 553 636 return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->finup); 554 637 } 555 638 EXPORT_SYMBOL_GPL(crypto_ahash_finup); ··· 609 706 { 610 707 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 611 708 612 - if (likely(tfm->using_shash)) { 613 - int err; 614 - 615 - err = shash_ahash_digest(req, prepare_shash_desc(req, tfm)); 616 - req->base.err = err; 617 - return err; 618 - } 619 - 620 - if (!crypto_ahash_req_chain(tfm) && ahash_request_hasvirt(req)) 709 + if (likely(tfm->using_shash)) 710 + return shash_ahash_digest(req, prepare_shash_desc(req, tfm)); 711 + if (!crypto_ahash_req_chain(tfm) && ahash_request_isvirt(req)) 621 712 return ahash_def_digest(req); 622 - 623 713 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) 624 714 return -ENOKEY; 625 - 626 715 return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->digest); 627 716 } 628 717 EXPORT_SYMBOL_GPL(crypto_ahash_digest);
-5
include/crypto/algapi.h
··· 267 267 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK; 268 268 } 269 269 270 - static inline bool crypto_request_chained(struct crypto_async_request *req) 271 - { 272 - return !list_empty(&req->list); 273 - } 274 - 275 270 static inline bool crypto_tfm_req_chain(struct crypto_tfm *tfm) 276 271 { 277 272 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_REQ_CHAIN;
-12
include/crypto/hash.h
··· 630 630 flags &= ~keep; 631 631 req->base.flags &= keep; 632 632 req->base.flags |= flags; 633 - crypto_reqchain_init(&req->base); 634 633 } 635 634 636 635 /** ··· 676 677 req->nbytes = nbytes; 677 678 req->result = result; 678 679 req->base.flags |= CRYPTO_AHASH_REQ_VIRT; 679 - } 680 - 681 - static inline void ahash_request_chain(struct ahash_request *req, 682 - struct ahash_request *head) 683 - { 684 - crypto_request_chain(&req->base, &head->base); 685 680 } 686 681 687 682 /** ··· 977 984 { 978 985 memzero_explicit(desc, 979 986 sizeof(*desc) + crypto_shash_descsize(desc->tfm)); 980 - } 981 - 982 - static inline int ahash_request_err(struct ahash_request *req) 983 - { 984 - return req->base.err; 985 987 } 986 988 987 989 static inline bool ahash_is_async(struct crypto_ahash *tfm)
-5
include/crypto/internal/hash.h
··· 247 247 return container_of(tfm, struct crypto_shash, base); 248 248 } 249 249 250 - static inline bool ahash_request_chained(struct ahash_request *req) 251 - { 252 - return false; 253 - } 254 - 255 250 static inline bool ahash_request_isvirt(struct ahash_request *req) 256 251 { 257 252 return req->base.flags & CRYPTO_AHASH_REQ_VIRT;
-15
include/linux/crypto.h
··· 14 14 15 15 #include <linux/completion.h> 16 16 #include <linux/errno.h> 17 - #include <linux/list.h> 18 17 #include <linux/refcount.h> 19 18 #include <linux/slab.h> 20 19 #include <linux/types.h> ··· 178 179 struct crypto_tfm *tfm; 179 180 180 181 u32 flags; 181 - int err; 182 182 }; 183 183 184 184 /** ··· 469 471 { 470 472 struct crypto_tfm *tfm; 471 473 return __alignof__(tfm->__crt_ctx); 472 - } 473 - 474 - static inline void crypto_reqchain_init(struct crypto_async_request *req) 475 - { 476 - req->err = -EINPROGRESS; 477 - INIT_LIST_HEAD(&req->list); 478 - } 479 - 480 - static inline void crypto_request_chain(struct crypto_async_request *req, 481 - struct crypto_async_request *head) 482 - { 483 - req->err = -EINPROGRESS; 484 - list_add_tail(&req->list, &head->list); 485 474 } 486 475 487 476 static inline bool crypto_tfm_is_async(struct crypto_tfm *tfm)