Skip to content

Commit 3e8afe3

Browse files
JuliaLawallherbertx
JuliaLawall
authored and
herbertx
committed
crypto: use ERR_CAST
Replace PTR_ERR followed by ERR_PTR by ERR_CAST, to be more concise. The semantic patch that makes this change is as follows: (http://coccinelle.lip6.fr/) // <smpl> @@ expression err,x; @@ - err = PTR_ERR(x); if (IS_ERR(x)) - return ERR_PTR(err); + return ERR_CAST(x); // </smpl> Signed-off-by: Julia Lawall <[email protected]> Signed-off-by: Herbert Xu <[email protected]>
1 parent 7b5c253 commit 3e8afe3

File tree

11 files changed

+27
-59
lines changed

11 files changed

+27
-59
lines changed

‎crypto/aead.c

+2-4
Original file line numberDiff line numberDiff line change
@@ -282,18 +282,16 @@ struct crypto_instance *aead_geniv_alloc(struct crypto_template *tmpl,
282282
int err;
283283

284284
algt = crypto_get_attr_type(tb);
285-
err = PTR_ERR(algt);
286285
if (IS_ERR(algt))
287-
return ERR_PTR(err);
286+
return ERR_CAST(algt);
288287

289288
if ((algt->type ^ (CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_GENIV)) &
290289
algt->mask)
291290
return ERR_PTR(-EINVAL);
292291

293292
name = crypto_attr_alg_name(tb[1]);
294-
err = PTR_ERR(name);
295293
if (IS_ERR(name))
296-
return ERR_PTR(err);
294+
return ERR_CAST(name);
297295

298296
inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
299297
if (!inst)

‎crypto/algapi.c

+1-3
Original file line numberDiff line numberDiff line change
@@ -749,12 +749,10 @@ struct crypto_alg *crypto_attr_alg2(struct rtattr *rta,
749749
u32 type, u32 mask)
750750
{
751751
const char *name;
752-
int err;
753752

754753
name = crypto_attr_alg_name(rta);
755-
err = PTR_ERR(name);
756754
if (IS_ERR(name))
757-
return ERR_PTR(err);
755+
return ERR_CAST(name);
758756

759757
return crypto_find_alg(name, frontend, type, mask);
760758
}

‎crypto/authenc.c

+1-2
Original file line numberDiff line numberDiff line change
@@ -592,9 +592,8 @@ static struct crypto_instance *crypto_authenc_alloc(struct rtattr **tb)
592592
int err;
593593

594594
algt = crypto_get_attr_type(tb);
595-
err = PTR_ERR(algt);
596595
if (IS_ERR(algt))
597-
return ERR_PTR(err);
596+
return ERR_CAST(algt);
598597

599598
if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
600599
return ERR_PTR(-EINVAL);

‎crypto/authencesn.c

+1-2
Original file line numberDiff line numberDiff line change
@@ -715,9 +715,8 @@ static struct crypto_instance *crypto_authenc_esn_alloc(struct rtattr **tb)
715715
int err;
716716

717717
algt = crypto_get_attr_type(tb);
718-
err = PTR_ERR(algt);
719718
if (IS_ERR(algt))
720-
return ERR_PTR(err);
719+
return ERR_CAST(algt);
721720

722721
if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
723722
return ERR_PTR(-EINVAL);

‎crypto/blkcipher.c

+2-4
Original file line numberDiff line numberDiff line change
@@ -588,18 +588,16 @@ struct crypto_instance *skcipher_geniv_alloc(struct crypto_template *tmpl,
588588
int err;
589589

590590
algt = crypto_get_attr_type(tb);
591-
err = PTR_ERR(algt);
592591
if (IS_ERR(algt))
593-
return ERR_PTR(err);
592+
return ERR_CAST(algt);
594593

595594
if ((algt->type ^ (CRYPTO_ALG_TYPE_GIVCIPHER | CRYPTO_ALG_GENIV)) &
596595
algt->mask)
597596
return ERR_PTR(-EINVAL);
598597

599598
name = crypto_attr_alg_name(tb[1]);
600-
err = PTR_ERR(name);
601599
if (IS_ERR(name))
602-
return ERR_PTR(err);
600+
return ERR_CAST(name);
603601

604602
inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
605603
if (!inst)

‎crypto/ccm.c

+7-16
Original file line numberDiff line numberDiff line change
@@ -484,18 +484,16 @@ static struct crypto_instance *crypto_ccm_alloc_common(struct rtattr **tb,
484484
int err;
485485

486486
algt = crypto_get_attr_type(tb);
487-
err = PTR_ERR(algt);
488487
if (IS_ERR(algt))
489-
return ERR_PTR(err);
488+
return ERR_CAST(algt);
490489

491490
if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
492491
return ERR_PTR(-EINVAL);
493492

494493
cipher = crypto_alg_mod_lookup(cipher_name, CRYPTO_ALG_TYPE_CIPHER,
495494
CRYPTO_ALG_TYPE_MASK);
496-
err = PTR_ERR(cipher);
497495
if (IS_ERR(cipher))
498-
return ERR_PTR(err);
496+
return ERR_CAST(cipher);
499497

500498
err = -EINVAL;
501499
if (cipher->cra_blocksize != 16)
@@ -573,15 +571,13 @@ static struct crypto_instance *crypto_ccm_alloc_common(struct rtattr **tb,
573571

574572
static struct crypto_instance *crypto_ccm_alloc(struct rtattr **tb)
575573
{
576-
int err;
577574
const char *cipher_name;
578575
char ctr_name[CRYPTO_MAX_ALG_NAME];
579576
char full_name[CRYPTO_MAX_ALG_NAME];
580577

581578
cipher_name = crypto_attr_alg_name(tb[1]);
582-
err = PTR_ERR(cipher_name);
583579
if (IS_ERR(cipher_name))
584-
return ERR_PTR(err);
580+
return ERR_CAST(cipher_name);
585581

586582
if (snprintf(ctr_name, CRYPTO_MAX_ALG_NAME, "ctr(%s)",
587583
cipher_name) >= CRYPTO_MAX_ALG_NAME)
@@ -612,20 +608,17 @@ static struct crypto_template crypto_ccm_tmpl = {
612608

613609
static struct crypto_instance *crypto_ccm_base_alloc(struct rtattr **tb)
614610
{
615-
int err;
616611
const char *ctr_name;
617612
const char *cipher_name;
618613
char full_name[CRYPTO_MAX_ALG_NAME];
619614

620615
ctr_name = crypto_attr_alg_name(tb[1]);
621-
err = PTR_ERR(ctr_name);
622616
if (IS_ERR(ctr_name))
623-
return ERR_PTR(err);
617+
return ERR_CAST(ctr_name);
624618

625619
cipher_name = crypto_attr_alg_name(tb[2]);
626-
err = PTR_ERR(cipher_name);
627620
if (IS_ERR(cipher_name))
628-
return ERR_PTR(err);
621+
return ERR_CAST(cipher_name);
629622

630623
if (snprintf(full_name, CRYPTO_MAX_ALG_NAME, "ccm_base(%s,%s)",
631624
ctr_name, cipher_name) >= CRYPTO_MAX_ALG_NAME)
@@ -760,17 +753,15 @@ static struct crypto_instance *crypto_rfc4309_alloc(struct rtattr **tb)
760753
int err;
761754

762755
algt = crypto_get_attr_type(tb);
763-
err = PTR_ERR(algt);
764756
if (IS_ERR(algt))
765-
return ERR_PTR(err);
757+
return ERR_CAST(algt);
766758

767759
if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
768760
return ERR_PTR(-EINVAL);
769761

770762
ccm_name = crypto_attr_alg_name(tb[1]);
771-
err = PTR_ERR(ccm_name);
772763
if (IS_ERR(ccm_name))
773-
return ERR_PTR(err);
764+
return ERR_CAST(ccm_name);
774765

775766
inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
776767
if (!inst)

‎crypto/chainiv.c

+1-2
Original file line numberDiff line numberDiff line change
@@ -291,9 +291,8 @@ static struct crypto_instance *chainiv_alloc(struct rtattr **tb)
291291
int err;
292292

293293
algt = crypto_get_attr_type(tb);
294-
err = PTR_ERR(algt);
295294
if (IS_ERR(algt))
296-
return ERR_PTR(err);
295+
return ERR_CAST(algt);
297296

298297
err = crypto_get_default_rng();
299298
if (err)

‎crypto/ctr.c

+1-2
Original file line numberDiff line numberDiff line change
@@ -334,9 +334,8 @@ static struct crypto_instance *crypto_rfc3686_alloc(struct rtattr **tb)
334334

335335
alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_BLKCIPHER,
336336
CRYPTO_ALG_TYPE_MASK);
337-
err = PTR_ERR(alg);
338337
if (IS_ERR(alg))
339-
return ERR_PTR(err);
338+
return ERR_CAST(alg);
340339

341340
/* We only support 16-byte blocks. */
342341
err = -EINVAL;

‎crypto/cts.c

+1-2
Original file line numberDiff line numberDiff line change
@@ -282,9 +282,8 @@ static struct crypto_instance *crypto_cts_alloc(struct rtattr **tb)
282282

283283
alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_BLKCIPHER,
284284
CRYPTO_ALG_TYPE_MASK);
285-
err = PTR_ERR(alg);
286285
if (IS_ERR(alg))
287-
return ERR_PTR(err);
286+
return ERR_CAST(alg);
288287

289288
inst = ERR_PTR(-EINVAL);
290289
if (!is_power_of_2(alg->cra_blocksize))

‎crypto/gcm.c

+9-20
Original file line numberDiff line numberDiff line change
@@ -701,19 +701,17 @@ static struct crypto_instance *crypto_gcm_alloc_common(struct rtattr **tb,
701701
int err;
702702

703703
algt = crypto_get_attr_type(tb);
704-
err = PTR_ERR(algt);
705704
if (IS_ERR(algt))
706-
return ERR_PTR(err);
705+
return ERR_CAST(algt);
707706

708707
if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
709708
return ERR_PTR(-EINVAL);
710709

711710
ghash_alg = crypto_find_alg(ghash_name, &crypto_ahash_type,
712711
CRYPTO_ALG_TYPE_HASH,
713712
CRYPTO_ALG_TYPE_AHASH_MASK);
714-
err = PTR_ERR(ghash_alg);
715713
if (IS_ERR(ghash_alg))
716-
return ERR_PTR(err);
714+
return ERR_CAST(ghash_alg);
717715

718716
err = -ENOMEM;
719717
inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
@@ -787,15 +785,13 @@ static struct crypto_instance *crypto_gcm_alloc_common(struct rtattr **tb,
787785

788786
static struct crypto_instance *crypto_gcm_alloc(struct rtattr **tb)
789787
{
790-
int err;
791788
const char *cipher_name;
792789
char ctr_name[CRYPTO_MAX_ALG_NAME];
793790
char full_name[CRYPTO_MAX_ALG_NAME];
794791

795792
cipher_name = crypto_attr_alg_name(tb[1]);
796-
err = PTR_ERR(cipher_name);
797793
if (IS_ERR(cipher_name))
798-
return ERR_PTR(err);
794+
return ERR_CAST(cipher_name);
799795

800796
if (snprintf(ctr_name, CRYPTO_MAX_ALG_NAME, "ctr(%s)", cipher_name) >=
801797
CRYPTO_MAX_ALG_NAME)
@@ -826,20 +822,17 @@ static struct crypto_template crypto_gcm_tmpl = {
826822

827823
static struct crypto_instance *crypto_gcm_base_alloc(struct rtattr **tb)
828824
{
829-
int err;
830825
const char *ctr_name;
831826
const char *ghash_name;
832827
char full_name[CRYPTO_MAX_ALG_NAME];
833828

834829
ctr_name = crypto_attr_alg_name(tb[1]);
835-
err = PTR_ERR(ctr_name);
836830
if (IS_ERR(ctr_name))
837-
return ERR_PTR(err);
831+
return ERR_CAST(ctr_name);
838832

839833
ghash_name = crypto_attr_alg_name(tb[2]);
840-
err = PTR_ERR(ghash_name);
841834
if (IS_ERR(ghash_name))
842-
return ERR_PTR(err);
835+
return ERR_CAST(ghash_name);
843836

844837
if (snprintf(full_name, CRYPTO_MAX_ALG_NAME, "gcm_base(%s,%s)",
845838
ctr_name, ghash_name) >= CRYPTO_MAX_ALG_NAME)
@@ -971,17 +964,15 @@ static struct crypto_instance *crypto_rfc4106_alloc(struct rtattr **tb)
971964
int err;
972965

973966
algt = crypto_get_attr_type(tb);
974-
err = PTR_ERR(algt);
975967
if (IS_ERR(algt))
976-
return ERR_PTR(err);
968+
return ERR_CAST(algt);
977969

978970
if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
979971
return ERR_PTR(-EINVAL);
980972

981973
ccm_name = crypto_attr_alg_name(tb[1]);
982-
err = PTR_ERR(ccm_name);
983974
if (IS_ERR(ccm_name))
984-
return ERR_PTR(err);
975+
return ERR_CAST(ccm_name);
985976

986977
inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
987978
if (!inst)
@@ -1222,17 +1213,15 @@ static struct crypto_instance *crypto_rfc4543_alloc(struct rtattr **tb)
12221213
int err;
12231214

12241215
algt = crypto_get_attr_type(tb);
1225-
err = PTR_ERR(algt);
12261216
if (IS_ERR(algt))
1227-
return ERR_PTR(err);
1217+
return ERR_CAST(algt);
12281218

12291219
if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
12301220
return ERR_PTR(-EINVAL);
12311221

12321222
ccm_name = crypto_attr_alg_name(tb[1]);
1233-
err = PTR_ERR(ccm_name);
12341223
if (IS_ERR(ccm_name))
1235-
return ERR_PTR(err);
1224+
return ERR_CAST(ccm_name);
12361225

12371226
inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
12381227
if (!inst)

‎crypto/seqiv.c

+1-2
Original file line numberDiff line numberDiff line change
@@ -305,9 +305,8 @@ static struct crypto_instance *seqiv_alloc(struct rtattr **tb)
305305
int err;
306306

307307
algt = crypto_get_attr_type(tb);
308-
err = PTR_ERR(algt);
309308
if (IS_ERR(algt))
310-
return ERR_PTR(err);
309+
return ERR_CAST(algt);
311310

312311
err = crypto_get_default_rng();
313312
if (err)

0 commit comments

Comments
 (0)