crypto: remove propagation of CRYPTO_TFM_RES_* flags

The CRYPTO_TFM_RES_* flags were apparently meant as a way to make the
->setkey() functions provide more information about errors.  But these
flags weren't actually being used or tested, and in many cases they
weren't being set correctly anyway.  So they've now been removed.

Also, if someone ever actually needs to start better distinguishing
->setkey() errors (which is somewhat unlikely, as this has been unneeded
for a long time), we'd be much better off just defining different return
values, like -EINVAL if the key is invalid for the algorithm vs.
-EKEYREJECTED if the key was rejected by a policy like "no weak keys".
That would be much simpler, less error-prone, and easier to test.

So just remove CRYPTO_TFM_RES_MASK and all the unneeded logic that
propagates these flags around.

Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/arch/arm/crypto/ghash-ce-glue.c b/arch/arm/crypto/ghash-ce-glue.c
index 7e8b2f55685c51fb5edd201b9b08df53b2942feb..a00fd329255fb7810e4d8c429364176fe1ca8fe9 100644 (file)
--- a/arch/arm/crypto/ghash-ce-glue.c
+++ b/arch/arm/crypto/ghash-ce-glue.c
@@ -294,16 +294,11 @@ static int ghash_async_setkey(struct crypto_ahash *tfm, const u8 *key,
 {
        struct ghash_async_ctx *ctx = crypto_ahash_ctx(tfm);
        struct crypto_ahash *child = &ctx->cryptd_tfm->base;
-       int err;
 
        crypto_ahash_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_ahash_set_flags(child, crypto_ahash_get_flags(tfm)
                               & CRYPTO_TFM_REQ_MASK);
-       err = crypto_ahash_setkey(child, key, keylen);
-       crypto_ahash_set_flags(tfm, crypto_ahash_get_flags(child)
-                              & CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_ahash_setkey(child, key, keylen);
 }
 
 static int ghash_async_init_tfm(struct crypto_tfm *tfm)

diff --git a/arch/s390/crypto/aes_s390.c b/arch/s390/crypto/aes_s390.c
index 2db167e5871c7f80c752e3ac51da518c94110457..1c23d84a9097d92d99c107e59e4dab4939ee7c17 100644 (file)
--- a/arch/s390/crypto/aes_s390.c
+++ b/arch/s390/crypto/aes_s390.c
@@ -72,19 +72,12 @@ static int setkey_fallback_cip(struct crypto_tfm *tfm, const u8 *in_key,
                unsigned int key_len)
 {
        struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
-       int ret;
 
        sctx->fallback.cip->base.crt_flags &= ~CRYPTO_TFM_REQ_MASK;
        sctx->fallback.cip->base.crt_flags |= (tfm->crt_flags &
                        CRYPTO_TFM_REQ_MASK);
 
-       ret = crypto_cipher_setkey(sctx->fallback.cip, in_key, key_len);
-       if (ret) {
-               tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
-               tfm->crt_flags |= (sctx->fallback.cip->base.crt_flags &
-                               CRYPTO_TFM_RES_MASK);
-       }
-       return ret;
+       return crypto_cipher_setkey(sctx->fallback.cip, in_key, key_len);
 }
 
 static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
@@ -182,18 +175,13 @@ static int setkey_fallback_skcipher(struct crypto_skcipher *tfm, const u8 *key,
                                    unsigned int len)
 {
        struct s390_aes_ctx *sctx = crypto_skcipher_ctx(tfm);
-       int ret;
 
        crypto_skcipher_clear_flags(sctx->fallback.skcipher,
                                    CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(sctx->fallback.skcipher,
                                  crypto_skcipher_get_flags(tfm) &
                                  CRYPTO_TFM_REQ_MASK);
-       ret = crypto_skcipher_setkey(sctx->fallback.skcipher, key, len);
-       crypto_skcipher_set_flags(tfm,
-                                 crypto_skcipher_get_flags(sctx->fallback.skcipher) &
-                                 CRYPTO_TFM_RES_MASK);
-       return ret;
+       return crypto_skcipher_setkey(sctx->fallback.skcipher, key, len);
 }
 
 static int fallback_skcipher_crypt(struct s390_aes_ctx *sctx,
@@ -389,17 +377,12 @@ static int xts_fallback_setkey(struct crypto_skcipher *tfm, const u8 *key,
                               unsigned int len)
 {
        struct s390_xts_ctx *xts_ctx = crypto_skcipher_ctx(tfm);
-       int ret;
 
        crypto_skcipher_clear_flags(xts_ctx->fallback, CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(xts_ctx->fallback,
                                  crypto_skcipher_get_flags(tfm) &
                                  CRYPTO_TFM_REQ_MASK);
-       ret = crypto_skcipher_setkey(xts_ctx->fallback, key, len);
-       crypto_skcipher_set_flags(tfm,
-                                 crypto_skcipher_get_flags(xts_ctx->fallback) &
-                                 CRYPTO_TFM_RES_MASK);
-       return ret;
+       return crypto_skcipher_setkey(xts_ctx->fallback, key, len);
 }
 
 static int xts_aes_set_key(struct crypto_skcipher *tfm, const u8 *in_key,

diff --git a/arch/x86/crypto/ghash-clmulni-intel_glue.c b/arch/x86/crypto/ghash-clmulni-intel_glue.c
index 4a9c9833a7d6a613804a789091495bd277b9ccb5..a4b728518e28e5867ece03c8db470429c88bd155 100644 (file)
--- a/arch/x86/crypto/ghash-clmulni-intel_glue.c
+++ b/arch/x86/crypto/ghash-clmulni-intel_glue.c
@@ -255,16 +255,11 @@ static int ghash_async_setkey(struct crypto_ahash *tfm, const u8 *key,
 {
        struct ghash_async_ctx *ctx = crypto_ahash_ctx(tfm);
        struct crypto_ahash *child = &ctx->cryptd_tfm->base;
-       int err;
 
        crypto_ahash_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_ahash_set_flags(child, crypto_ahash_get_flags(tfm)
                               & CRYPTO_TFM_REQ_MASK);
-       err = crypto_ahash_setkey(child, key, keylen);
-       crypto_ahash_set_flags(tfm, crypto_ahash_get_flags(child)
-                              & CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_ahash_setkey(child, key, keylen);
 }
 
 static int ghash_async_init_tfm(struct crypto_tfm *tfm)

diff --git a/crypto/adiantum.c b/crypto/adiantum.c
index aded260922684061047a2bceac0aaedc0d5ee8d8..30cffb45b88f83c1bb8c74d48c0a49ebcd8c1f8b 100644 (file)
--- a/crypto/adiantum.c
+++ b/crypto/adiantum.c
@@ -135,9 +135,6 @@ static int adiantum_setkey(struct crypto_skcipher *tfm, const u8 *key,
                                  crypto_skcipher_get_flags(tfm) &
                                  CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(tctx->streamcipher, key, keylen);
-       crypto_skcipher_set_flags(tfm,
-                               crypto_skcipher_get_flags(tctx->streamcipher) &
-                               CRYPTO_TFM_RES_MASK);
        if (err)
                return err;
 
@@ -167,9 +164,6 @@ static int adiantum_setkey(struct crypto_skcipher *tfm, const u8 *key,
                                CRYPTO_TFM_REQ_MASK);
        err = crypto_cipher_setkey(tctx->blockcipher, keyp,
                                   BLOCKCIPHER_KEY_SIZE);
-       crypto_skcipher_set_flags(tfm,
-                                 crypto_cipher_get_flags(tctx->blockcipher) &
-                                 CRYPTO_TFM_RES_MASK);
        if (err)
                goto out;
        keyp += BLOCKCIPHER_KEY_SIZE;
@@ -182,8 +176,6 @@ static int adiantum_setkey(struct crypto_skcipher *tfm, const u8 *key,
        crypto_shash_set_flags(tctx->hash, crypto_skcipher_get_flags(tfm) &
                                           CRYPTO_TFM_REQ_MASK);
        err = crypto_shash_setkey(tctx->hash, keyp, NHPOLY1305_KEY_SIZE);
-       crypto_skcipher_set_flags(tfm, crypto_shash_get_flags(tctx->hash) &
-                                      CRYPTO_TFM_RES_MASK);
        keyp += NHPOLY1305_KEY_SIZE;
        WARN_ON(keyp != &data->derived_keys[ARRAY_SIZE(data->derived_keys)]);
 out:

diff --git a/crypto/authenc.c b/crypto/authenc.c
index 0da80632e8721240f161e2fbfd26b89ec712d438..15aaddd34171f40f663888ac23add9e1e214ccf4 100644 (file)
--- a/crypto/authenc.c
+++ b/crypto/authenc.c
@@ -97,9 +97,6 @@ static int crypto_authenc_setkey(struct crypto_aead *authenc, const u8 *key,
        crypto_ahash_set_flags(auth, crypto_aead_get_flags(authenc) &
                                    CRYPTO_TFM_REQ_MASK);
        err = crypto_ahash_setkey(auth, keys.authkey, keys.authkeylen);
-       crypto_aead_set_flags(authenc, crypto_ahash_get_flags(auth) &
-                                      CRYPTO_TFM_RES_MASK);
-
        if (err)
                goto out;
 
@@ -107,9 +104,6 @@ static int crypto_authenc_setkey(struct crypto_aead *authenc, const u8 *key,
        crypto_skcipher_set_flags(enc, crypto_aead_get_flags(authenc) &
                                       CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(enc, keys.enckey, keys.enckeylen);
-       crypto_aead_set_flags(authenc, crypto_skcipher_get_flags(enc) &
-                                      CRYPTO_TFM_RES_MASK);
-
 out:
        memzero_explicit(&keys, sizeof(keys));
        return err;

diff --git a/crypto/authencesn.c b/crypto/authencesn.c
index 749527e1b617540260b8e67be4975d8cbc327d22..fc81324ce881e2000af81db8632776414da864b5 100644 (file)
--- a/crypto/authencesn.c
+++ b/crypto/authencesn.c
@@ -71,9 +71,6 @@ static int crypto_authenc_esn_setkey(struct crypto_aead *authenc_esn, const u8 *
        crypto_ahash_set_flags(auth, crypto_aead_get_flags(authenc_esn) &
                                     CRYPTO_TFM_REQ_MASK);
        err = crypto_ahash_setkey(auth, keys.authkey, keys.authkeylen);
-       crypto_aead_set_flags(authenc_esn, crypto_ahash_get_flags(auth) &
-                                          CRYPTO_TFM_RES_MASK);
-
        if (err)
                goto out;
 
@@ -81,9 +78,6 @@ static int crypto_authenc_esn_setkey(struct crypto_aead *authenc_esn, const u8 *
        crypto_skcipher_set_flags(enc, crypto_aead_get_flags(authenc_esn) &
                                         CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(enc, keys.enckey, keys.enckeylen);
-       crypto_aead_set_flags(authenc_esn, crypto_skcipher_get_flags(enc) &
-                                          CRYPTO_TFM_RES_MASK);
-
 out:
        memzero_explicit(&keys, sizeof(keys));
        return err;

diff --git a/crypto/ccm.c b/crypto/ccm.c
index 380eb619f6575f40f57b46d261e7f0573a5fb372..44104524e95a8816d044a4d3c9d91550a2acacda 100644 (file)
--- a/crypto/ccm.c
+++ b/crypto/ccm.c
@@ -91,26 +91,19 @@ static int crypto_ccm_setkey(struct crypto_aead *aead, const u8 *key,
        struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
        struct crypto_skcipher *ctr = ctx->ctr;
        struct crypto_ahash *mac = ctx->mac;
-       int err = 0;
+       int err;
 
        crypto_skcipher_clear_flags(ctr, CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(ctr, crypto_aead_get_flags(aead) &
                                       CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(ctr, key, keylen);
-       crypto_aead_set_flags(aead, crypto_skcipher_get_flags(ctr) &
-                             CRYPTO_TFM_RES_MASK);
        if (err)
-               goto out;
+               return err;
 
        crypto_ahash_clear_flags(mac, CRYPTO_TFM_REQ_MASK);
        crypto_ahash_set_flags(mac, crypto_aead_get_flags(aead) &
                                    CRYPTO_TFM_REQ_MASK);
-       err = crypto_ahash_setkey(mac, key, keylen);
-       crypto_aead_set_flags(aead, crypto_ahash_get_flags(mac) &
-                             CRYPTO_TFM_RES_MASK);
-
-out:
-       return err;
+       return crypto_ahash_setkey(mac, key, keylen);
 }
 
 static int crypto_ccm_setauthsize(struct crypto_aead *tfm,
@@ -604,7 +597,6 @@ static int crypto_rfc4309_setkey(struct crypto_aead *parent, const u8 *key,
 {
        struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(parent);
        struct crypto_aead *child = ctx->child;
-       int err;
 
        if (keylen < 3)
                return -EINVAL;
@@ -615,11 +607,7 @@ static int crypto_rfc4309_setkey(struct crypto_aead *parent, const u8 *key,
        crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_aead_set_flags(child, crypto_aead_get_flags(parent) &
                                     CRYPTO_TFM_REQ_MASK);
-       err = crypto_aead_setkey(child, key, keylen);
-       crypto_aead_set_flags(parent, crypto_aead_get_flags(child) &
-                                     CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_aead_setkey(child, key, keylen);
 }
 
 static int crypto_rfc4309_setauthsize(struct crypto_aead *parent,

diff --git a/crypto/chacha20poly1305.c b/crypto/chacha20poly1305.c
index 74e824e537e65481c34458df9f0e48e35800d091..88cbdaba43b8881045677e8dd5580613d901aac1 100644 (file)
--- a/crypto/chacha20poly1305.c
+++ b/crypto/chacha20poly1305.c
@@ -477,7 +477,6 @@ static int chachapoly_setkey(struct crypto_aead *aead, const u8 *key,
                             unsigned int keylen)
 {
        struct chachapoly_ctx *ctx = crypto_aead_ctx(aead);
-       int err;
 
        if (keylen != ctx->saltlen + CHACHA_KEY_SIZE)
                return -EINVAL;
@@ -488,11 +487,7 @@ static int chachapoly_setkey(struct crypto_aead *aead, const u8 *key,
        crypto_skcipher_clear_flags(ctx->chacha, CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(ctx->chacha, crypto_aead_get_flags(aead) &
                                               CRYPTO_TFM_REQ_MASK);
-
-       err = crypto_skcipher_setkey(ctx->chacha, key, keylen);
-       crypto_aead_set_flags(aead, crypto_skcipher_get_flags(ctx->chacha) &
-                                   CRYPTO_TFM_RES_MASK);
-       return err;
+       return crypto_skcipher_setkey(ctx->chacha, key, keylen);
 }
 
 static int chachapoly_setauthsize(struct crypto_aead *tfm,

diff --git a/crypto/cipher.c b/crypto/cipher.c
index 0fb7042a709d589d25341194fddf9bf378ee08c8..fd78150deb1c14c6830df06b4511df2e4802d293 100644 (file)
--- a/crypto/cipher.c
+++ b/crypto/cipher.c
@@ -45,7 +45,6 @@ int crypto_cipher_setkey(struct crypto_cipher *tfm,
        struct cipher_alg *cia = crypto_cipher_alg(tfm);
        unsigned long alignmask = crypto_cipher_alignmask(tfm);
 
-       crypto_cipher_clear_flags(tfm, CRYPTO_TFM_RES_MASK);
        if (keylen < cia->cia_min_keysize || keylen > cia->cia_max_keysize)
                return -EINVAL;
 

diff --git a/crypto/cryptd.c b/crypto/cryptd.c
index 2c6649b1092327ff94d5599f47424e14b123463e..cd94243a1605863b304c74a803cd005b9c689ff9 100644 (file)
--- a/crypto/cryptd.c
+++ b/crypto/cryptd.c
@@ -252,17 +252,12 @@ static int cryptd_skcipher_setkey(struct crypto_skcipher *parent,
 {
        struct cryptd_skcipher_ctx *ctx = crypto_skcipher_ctx(parent);
        struct crypto_sync_skcipher *child = ctx->child;
-       int err;
 
        crypto_sync_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_sync_skcipher_set_flags(child,
                                       crypto_skcipher_get_flags(parent) &
                                         CRYPTO_TFM_REQ_MASK);
-       err = crypto_sync_skcipher_setkey(child, key, keylen);
-       crypto_skcipher_set_flags(parent,
-                                 crypto_sync_skcipher_get_flags(child) &
-                                         CRYPTO_TFM_RES_MASK);
-       return err;
+       return crypto_sync_skcipher_setkey(child, key, keylen);
 }
 
 static void cryptd_skcipher_complete(struct skcipher_request *req, int err)
@@ -491,15 +486,11 @@ static int cryptd_hash_setkey(struct crypto_ahash *parent,
 {
        struct cryptd_hash_ctx *ctx   = crypto_ahash_ctx(parent);
        struct crypto_shash *child = ctx->child;
-       int err;
 
        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);
-       return err;
+       return crypto_shash_setkey(child, key, keylen);
 }
 
 static int cryptd_hash_enqueue(struct ahash_request *req,

diff --git a/crypto/ctr.c b/crypto/ctr.c
index 1e9d6b86b3c672b162bf4490899fe881d1f179ed..b63b19de68a96160a870d49fd79273cc9c0a790d 100644 (file)
--- a/crypto/ctr.c
+++ b/crypto/ctr.c
@@ -170,7 +170,6 @@ static int crypto_rfc3686_setkey(struct crypto_skcipher *parent,
 {
        struct crypto_rfc3686_ctx *ctx = crypto_skcipher_ctx(parent);
        struct crypto_skcipher *child = ctx->child;
-       int err;
 
        /* the nonce is stored in bytes at end of key */
        if (keylen < CTR_RFC3686_NONCE_SIZE)
@@ -184,11 +183,7 @@ static int crypto_rfc3686_setkey(struct crypto_skcipher *parent,
        crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(parent) &
                                         CRYPTO_TFM_REQ_MASK);
-       err = crypto_skcipher_setkey(child, key, keylen);
-       crypto_skcipher_set_flags(parent, crypto_skcipher_get_flags(child) &
-                                         CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_skcipher_setkey(child, key, keylen);
 }
 
 static int crypto_rfc3686_crypt(struct skcipher_request *req)

diff --git a/crypto/cts.c b/crypto/cts.c
index 6b6087dbb62a21b53be48a2e3b6d1ae88b1c1a0c..a0bb994f8b1174d3391d9022aa6e5532a0331a6a 100644 (file)
--- a/crypto/cts.c
+++ b/crypto/cts.c
@@ -78,15 +78,11 @@ static int crypto_cts_setkey(struct crypto_skcipher *parent, const u8 *key,
 {
        struct crypto_cts_ctx *ctx = crypto_skcipher_ctx(parent);
        struct crypto_skcipher *child = ctx->child;
-       int err;
 
        crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(parent) &
                                         CRYPTO_TFM_REQ_MASK);
-       err = crypto_skcipher_setkey(child, key, keylen);
-       crypto_skcipher_set_flags(parent, crypto_skcipher_get_flags(child) &
-                                         CRYPTO_TFM_RES_MASK);
-       return err;
+       return crypto_skcipher_setkey(child, key, keylen);
 }
 
 static void cts_cbc_crypt_done(struct crypto_async_request *areq, int err)

diff --git a/crypto/essiv.c b/crypto/essiv.c
index f49bd6fc6972f61ec6e6064ff6471e1703efc48f..61d9000ae4ad00eb2e595d66e7d609ffa9eac74e 100644 (file)
--- a/crypto/essiv.c
+++ b/crypto/essiv.c
@@ -75,9 +75,6 @@ static int essiv_skcipher_setkey(struct crypto_skcipher *tfm,
                                  crypto_skcipher_get_flags(tfm) &
                                  CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(tctx->u.skcipher, key, keylen);
-       crypto_skcipher_set_flags(tfm,
-                                 crypto_skcipher_get_flags(tctx->u.skcipher) &
-                                 CRYPTO_TFM_RES_MASK);
        if (err)
                return err;
 
@@ -90,13 +87,8 @@ static int essiv_skcipher_setkey(struct crypto_skcipher *tfm,
        crypto_cipher_set_flags(tctx->essiv_cipher,
                                crypto_skcipher_get_flags(tfm) &
                                CRYPTO_TFM_REQ_MASK);
-       err = crypto_cipher_setkey(tctx->essiv_cipher, salt,
-                                  crypto_shash_digestsize(tctx->hash));
-       crypto_skcipher_set_flags(tfm,
-                                 crypto_cipher_get_flags(tctx->essiv_cipher) &
-                                 CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_cipher_setkey(tctx->essiv_cipher, salt,
+                                   crypto_shash_digestsize(tctx->hash));
 }
 
 static int essiv_aead_setkey(struct crypto_aead *tfm, const u8 *key,
@@ -112,8 +104,6 @@ static int essiv_aead_setkey(struct crypto_aead *tfm, const u8 *key,
        crypto_aead_set_flags(tctx->u.aead, crypto_aead_get_flags(tfm) &
                                            CRYPTO_TFM_REQ_MASK);
        err = crypto_aead_setkey(tctx->u.aead, key, keylen);
-       crypto_aead_set_flags(tfm, crypto_aead_get_flags(tctx->u.aead) &
-                                  CRYPTO_TFM_RES_MASK);
        if (err)
                return err;
 
@@ -130,12 +120,8 @@ static int essiv_aead_setkey(struct crypto_aead *tfm, const u8 *key,
        crypto_cipher_clear_flags(tctx->essiv_cipher, CRYPTO_TFM_REQ_MASK);
        crypto_cipher_set_flags(tctx->essiv_cipher, crypto_aead_get_flags(tfm) &
                                                    CRYPTO_TFM_REQ_MASK);
-       err = crypto_cipher_setkey(tctx->essiv_cipher, salt,
-                                  crypto_shash_digestsize(tctx->hash));
-       crypto_aead_set_flags(tfm, crypto_cipher_get_flags(tctx->essiv_cipher) &
-                                  CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_cipher_setkey(tctx->essiv_cipher, salt,
+                                   crypto_shash_digestsize(tctx->hash));
 }
 
 static int essiv_aead_setauthsize(struct crypto_aead *tfm,

diff --git a/crypto/gcm.c b/crypto/gcm.c
index 73884208f07532761ac3c957c8c29897628ca455..7041cb1b6fd56deba2d827d4fb40071516b4dedb 100644 (file)
--- a/crypto/gcm.c
+++ b/crypto/gcm.c
@@ -111,8 +111,6 @@ static int crypto_gcm_setkey(struct crypto_aead *aead, const u8 *key,
        crypto_skcipher_set_flags(ctr, crypto_aead_get_flags(aead) &
                                       CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(ctr, key, keylen);
-       crypto_aead_set_flags(aead, crypto_skcipher_get_flags(ctr) &
-                                   CRYPTO_TFM_RES_MASK);
        if (err)
                return err;
 
@@ -141,9 +139,6 @@ static int crypto_gcm_setkey(struct crypto_aead *aead, const u8 *key,
        crypto_ahash_set_flags(ghash, crypto_aead_get_flags(aead) &
                               CRYPTO_TFM_REQ_MASK);
        err = crypto_ahash_setkey(ghash, (u8 *)&data->hash, sizeof(be128));
-       crypto_aead_set_flags(aead, crypto_ahash_get_flags(ghash) &
-                             CRYPTO_TFM_RES_MASK);
-
 out:
        kzfree(data);
        return err;
@@ -727,7 +722,6 @@ static int crypto_rfc4106_setkey(struct crypto_aead *parent, const u8 *key,
 {
        struct crypto_rfc4106_ctx *ctx = crypto_aead_ctx(parent);
        struct crypto_aead *child = ctx->child;
-       int err;
 
        if (keylen < 4)
                return -EINVAL;
@@ -738,11 +732,7 @@ static int crypto_rfc4106_setkey(struct crypto_aead *parent, const u8 *key,
        crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_aead_set_flags(child, crypto_aead_get_flags(parent) &
                                     CRYPTO_TFM_REQ_MASK);
-       err = crypto_aead_setkey(child, key, keylen);
-       crypto_aead_set_flags(parent, crypto_aead_get_flags(child) &
-                                     CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_aead_setkey(child, key, keylen);
 }
 
 static int crypto_rfc4106_setauthsize(struct crypto_aead *parent,
@@ -956,7 +946,6 @@ static int crypto_rfc4543_setkey(struct crypto_aead *parent, const u8 *key,
 {
        struct crypto_rfc4543_ctx *ctx = crypto_aead_ctx(parent);
        struct crypto_aead *child = ctx->child;
-       int err;
 
        if (keylen < 4)
                return -EINVAL;
@@ -967,11 +956,7 @@ static int crypto_rfc4543_setkey(struct crypto_aead *parent, const u8 *key,
        crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_aead_set_flags(child, crypto_aead_get_flags(parent) &
                                     CRYPTO_TFM_REQ_MASK);
-       err = crypto_aead_setkey(child, key, keylen);
-       crypto_aead_set_flags(parent, crypto_aead_get_flags(child) &
-                                     CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_aead_setkey(child, key, keylen);
 }
 
 static int crypto_rfc4543_setauthsize(struct crypto_aead *parent,

diff --git a/crypto/lrw.c b/crypto/lrw.c
index be829f6afc8e5bbcf6fabec3a0135740b1cb966c..8ebd79276c78c0c07297ce69d710fff9d57b8ec0 100644 (file)
--- a/crypto/lrw.c
+++ b/crypto/lrw.c
@@ -79,8 +79,6 @@ static int setkey(struct crypto_skcipher *parent, const u8 *key,
        crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(parent) &
                                         CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(child, key, keylen - bsize);
-       crypto_skcipher_set_flags(parent, crypto_skcipher_get_flags(child) &
-                                         CRYPTO_TFM_RES_MASK);
        if (err)
                return err;
 

diff --git a/crypto/simd.c b/crypto/simd.c
index 48876266cf2dbcba77191d2833ac22c72a6985fb..56885af49c24ca118b1fd79d51c11be2d8d991aa 100644 (file)
--- a/crypto/simd.c
+++ b/crypto/simd.c
@@ -52,15 +52,11 @@ static int simd_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key,
 {
        struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
        struct crypto_skcipher *child = &ctx->cryptd_tfm->base;
-       int err;
 
        crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(tfm) &
                                         CRYPTO_TFM_REQ_MASK);
-       err = crypto_skcipher_setkey(child, key, key_len);
-       crypto_skcipher_set_flags(tfm, crypto_skcipher_get_flags(child) &
-                                      CRYPTO_TFM_RES_MASK);
-       return err;
+       return crypto_skcipher_setkey(child, key, key_len);
 }
 
 static int simd_skcipher_encrypt(struct skcipher_request *req)
@@ -295,15 +291,11 @@ static int simd_aead_setkey(struct crypto_aead *tfm, const u8 *key,
 {
        struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
        struct crypto_aead *child = &ctx->cryptd_tfm->base;
-       int err;
 
        crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_aead_set_flags(child, crypto_aead_get_flags(tfm) &
                                     CRYPTO_TFM_REQ_MASK);
-       err = crypto_aead_setkey(child, key, key_len);
-       crypto_aead_set_flags(tfm, crypto_aead_get_flags(child) &
-                                  CRYPTO_TFM_RES_MASK);
-       return err;
+       return crypto_aead_setkey(child, key, key_len);
 }
 
 static int simd_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize)

diff --git a/crypto/skcipher.c b/crypto/skcipher.c
index 8c8735f75478f518b28c0e9dac7643654cf53a87..89137a197fc8f5c68eb7b31c1d2c5e8c953e5b00 100644 (file)
--- a/crypto/skcipher.c
+++ b/crypto/skcipher.c
@@ -876,15 +876,11 @@ static int skcipher_setkey_simple(struct crypto_skcipher *tfm, const u8 *key,
                                  unsigned int keylen)
 {
        struct crypto_cipher *cipher = skcipher_cipher_simple(tfm);
-       int err;
 
        crypto_cipher_clear_flags(cipher, CRYPTO_TFM_REQ_MASK);
        crypto_cipher_set_flags(cipher, crypto_skcipher_get_flags(tfm) &
                                CRYPTO_TFM_REQ_MASK);
-       err = crypto_cipher_setkey(cipher, key, keylen);
-       crypto_skcipher_set_flags(tfm, crypto_cipher_get_flags(cipher) &
-                                 CRYPTO_TFM_RES_MASK);
-       return err;
+       return crypto_cipher_setkey(cipher, key, keylen);
 }
 
 static int skcipher_init_tfm_simple(struct crypto_skcipher *tfm)

diff --git a/crypto/xts.c b/crypto/xts.c
index ab117633d64e775520a6ab542282e4a839a8a714..19d55489e78b5d02f0bd79c871d3dd5c14821d3b 100644 (file)
--- a/crypto/xts.c
+++ b/crypto/xts.c
@@ -61,8 +61,6 @@ static int setkey(struct crypto_skcipher *parent, const u8 *key,
        crypto_cipher_set_flags(tweak, crypto_skcipher_get_flags(parent) &
                                       CRYPTO_TFM_REQ_MASK);
        err = crypto_cipher_setkey(tweak, key + keylen, keylen);
-       crypto_skcipher_set_flags(parent, crypto_cipher_get_flags(tweak) &
-                                         CRYPTO_TFM_RES_MASK);
        if (err)
                return err;
 
@@ -71,11 +69,7 @@ static int setkey(struct crypto_skcipher *parent, const u8 *key,
        crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(parent) &
                                         CRYPTO_TFM_REQ_MASK);
-       err = crypto_skcipher_setkey(child, key, keylen);
-       crypto_skcipher_set_flags(parent, crypto_skcipher_get_flags(child) &
-                                         CRYPTO_TFM_RES_MASK);
-
-       return err;
+       return crypto_skcipher_setkey(child, key, keylen);
 }
 
 /*

diff --git a/drivers/crypto/amcc/crypto4xx_alg.c b/drivers/crypto/amcc/crypto4xx_alg.c
index 121eb81df64f73b1a2811062deff72750e32efee..f7fc0c46412548de2c4cebf3ef93eb06abbbb439 100644 (file)
--- a/drivers/crypto/amcc/crypto4xx_alg.c
+++ b/drivers/crypto/amcc/crypto4xx_alg.c
@@ -289,19 +289,11 @@ static int crypto4xx_sk_setup_fallback(struct crypto4xx_ctx *ctx,
                                       const u8 *key,
                                       unsigned int keylen)
 {
-       int rc;
-
        crypto_sync_skcipher_clear_flags(ctx->sw_cipher.cipher,
                                    CRYPTO_TFM_REQ_MASK);
        crypto_sync_skcipher_set_flags(ctx->sw_cipher.cipher,
                crypto_skcipher_get_flags(cipher) & CRYPTO_TFM_REQ_MASK);
-       rc = crypto_sync_skcipher_setkey(ctx->sw_cipher.cipher, key, keylen);
-       crypto_skcipher_clear_flags(cipher, CRYPTO_TFM_RES_MASK);
-       crypto_skcipher_set_flags(cipher,
-               crypto_sync_skcipher_get_flags(ctx->sw_cipher.cipher) &
-                       CRYPTO_TFM_RES_MASK);
-
-       return rc;
+       return crypto_sync_skcipher_setkey(ctx->sw_cipher.cipher, key, keylen);
 }
 
 int crypto4xx_setkey_aes_ctr(struct crypto_skcipher *cipher,
@@ -376,18 +368,10 @@ static int crypto4xx_aead_setup_fallback(struct crypto4xx_ctx *ctx,
                                         const u8 *key,
                                         unsigned int keylen)
 {
-       int rc;
-
        crypto_aead_clear_flags(ctx->sw_cipher.aead, CRYPTO_TFM_REQ_MASK);
        crypto_aead_set_flags(ctx->sw_cipher.aead,
                crypto_aead_get_flags(cipher) & CRYPTO_TFM_REQ_MASK);
-       rc = crypto_aead_setkey(ctx->sw_cipher.aead, key, keylen);
-       crypto_aead_clear_flags(cipher, CRYPTO_TFM_RES_MASK);
-       crypto_aead_set_flags(cipher,
-               crypto_aead_get_flags(ctx->sw_cipher.aead) &
-                       CRYPTO_TFM_RES_MASK);
-
-       return rc;
+       return crypto_aead_setkey(ctx->sw_cipher.aead, key, keylen);
 }
 
 /**

diff --git a/drivers/crypto/atmel-aes.c b/drivers/crypto/atmel-aes.c
index 898f66cb2eb2675324f2c0dd1d01ab0b71a737a4..466c15b474da46f59a84d4fa106fc7df36827778 100644 (file)
--- a/drivers/crypto/atmel-aes.c
+++ b/drivers/crypto/atmel-aes.c
@@ -2041,7 +2041,6 @@ static int atmel_aes_authenc_setkey(struct crypto_aead *tfm, const u8 *key,
 {
        struct atmel_aes_authenc_ctx *ctx = crypto_aead_ctx(tfm);
        struct crypto_authenc_keys keys;
-       u32 flags;
        int err;
 
        if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
@@ -2051,11 +2050,9 @@ static int atmel_aes_authenc_setkey(struct crypto_aead *tfm, const u8 *key,
                goto badkey;
 
        /* Save auth key. */
-       flags = crypto_aead_get_flags(tfm);
        err = atmel_sha_authenc_setkey(ctx->auth,
                                       keys.authkey, keys.authkeylen,
-                                      &flags);
-       crypto_aead_set_flags(tfm, flags & CRYPTO_TFM_RES_MASK);
+                                      crypto_aead_get_flags(tfm));
        if (err) {
                memzero_explicit(&keys, sizeof(keys));
                return err;

diff --git a/drivers/crypto/atmel-authenc.h b/drivers/crypto/atmel-authenc.h
index d6de810df44fee7ee5da8a908439f7a51c4e353b..c6530a1c8c20ac1274989e5e38fe8189710b81a9 100644 (file)
--- a/drivers/crypto/atmel-authenc.h
+++ b/drivers/crypto/atmel-authenc.h
@@ -30,8 +30,7 @@ unsigned int atmel_sha_authenc_get_reqsize(void);
 struct atmel_sha_authenc_ctx *atmel_sha_authenc_spawn(unsigned long mode);
 void atmel_sha_authenc_free(struct atmel_sha_authenc_ctx *auth);
 int atmel_sha_authenc_setkey(struct atmel_sha_authenc_ctx *auth,
-                            const u8 *key, unsigned int keylen,
-                            u32 *flags);
+                            const u8 *key, unsigned int keylen, u32 flags);
 
 int atmel_sha_authenc_schedule(struct ahash_request *req,
                               struct atmel_sha_authenc_ctx *auth,

diff --git a/drivers/crypto/atmel-sha.c b/drivers/crypto/atmel-sha.c
index d3bcd14201c264d0b5991ca3a249ad758b0b0dfc..079fdb8114e9bbb4cf198e85138d5fe68d5877cb 100644 (file)
--- a/drivers/crypto/atmel-sha.c
+++ b/drivers/crypto/atmel-sha.c
@@ -2207,18 +2207,13 @@ void atmel_sha_authenc_free(struct atmel_sha_authenc_ctx *auth)
 EXPORT_SYMBOL_GPL(atmel_sha_authenc_free);
 
 int atmel_sha_authenc_setkey(struct atmel_sha_authenc_ctx *auth,
-                            const u8 *key, unsigned int keylen,
-                            u32 *flags)
+                            const u8 *key, unsigned int keylen, u32 flags)
 {
        struct crypto_ahash *tfm = auth->tfm;
-       int err;
 
        crypto_ahash_clear_flags(tfm, CRYPTO_TFM_REQ_MASK);
-       crypto_ahash_set_flags(tfm, *flags & CRYPTO_TFM_REQ_MASK);
-       err = crypto_ahash_setkey(tfm, key, keylen);
-       *flags = crypto_ahash_get_flags(tfm);
-
-       return err;
+       crypto_ahash_set_flags(tfm, flags & CRYPTO_TFM_REQ_MASK);
+       return crypto_ahash_setkey(tfm, key, keylen);
 }
 EXPORT_SYMBOL_GPL(atmel_sha_authenc_setkey);
 

diff --git a/drivers/crypto/bcm/cipher.c b/drivers/crypto/bcm/cipher.c
index 184a3e1245cf83ab286878ca90434da89a8cf5eb..c8b9408541a95ac1fa937ca80ee03bd946d0df97 100644 (file)
--- a/drivers/crypto/bcm/cipher.c
+++ b/drivers/crypto/bcm/cipher.c
@@ -2893,13 +2893,8 @@ static int aead_authenc_setkey(struct crypto_aead *cipher,
                ctx->fallback_cipher->base.crt_flags |=
                    tfm->crt_flags & CRYPTO_TFM_REQ_MASK;
                ret = crypto_aead_setkey(ctx->fallback_cipher, key, keylen);
-               if (ret) {
+               if (ret)
                        flow_log("  fallback setkey() returned:%d\n", ret);
-                       tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
-                       tfm->crt_flags |=
-                           (ctx->fallback_cipher->base.crt_flags &
-                            CRYPTO_TFM_RES_MASK);
-               }
        }
 
        ctx->spu_resp_hdr_len = spu->spu_response_hdr_len(ctx->authkeylen,
@@ -2965,13 +2960,8 @@ static int aead_gcm_ccm_setkey(struct crypto_aead *cipher,
                    tfm->crt_flags & CRYPTO_TFM_REQ_MASK;
                ret = crypto_aead_setkey(ctx->fallback_cipher, key,
                                         keylen + ctx->salt_len);
-               if (ret) {
+               if (ret)
                        flow_log("  fallback setkey() returned:%d\n", ret);
-                       tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
-                       tfm->crt_flags |=
-                           (ctx->fallback_cipher->base.crt_flags &
-                            CRYPTO_TFM_RES_MASK);
-               }
        }
 
        ctx->spu_resp_hdr_len = spu->spu_response_hdr_len(ctx->authkeylen,

diff --git a/drivers/crypto/chelsio/chcr_algo.c b/drivers/crypto/chelsio/chcr_algo.c
index 720b2ff5546404ac1897d794ee64b019e87bbbd7..b4b9b22125d17773df2ab9cac17c72328eb9d772 100644 (file)
--- a/drivers/crypto/chelsio/chcr_algo.c
+++ b/drivers/crypto/chelsio/chcr_algo.c
@@ -870,20 +870,13 @@ static int chcr_cipher_fallback_setkey(struct crypto_skcipher *cipher,
                                       const u8 *key,
                                       unsigned int keylen)
 {
-       struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
        struct ablk_ctx *ablkctx = ABLK_CTX(c_ctx(cipher));
-       int err = 0;
 
        crypto_sync_skcipher_clear_flags(ablkctx->sw_cipher,
                                CRYPTO_TFM_REQ_MASK);
        crypto_sync_skcipher_set_flags(ablkctx->sw_cipher,
                                cipher->base.crt_flags & CRYPTO_TFM_REQ_MASK);
-       err = crypto_sync_skcipher_setkey(ablkctx->sw_cipher, key, keylen);
-       tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
-       tfm->crt_flags |=
-               crypto_sync_skcipher_get_flags(ablkctx->sw_cipher) &
-               CRYPTO_TFM_RES_MASK;
-       return err;
+       return crypto_sync_skcipher_setkey(ablkctx->sw_cipher, key, keylen);
 }
 
 static int chcr_aes_cbc_setkey(struct crypto_skcipher *cipher,
@@ -3302,9 +3295,6 @@ static int chcr_aead_ccm_setkey(struct crypto_aead *aead,
        crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(aead) &
                              CRYPTO_TFM_REQ_MASK);
        error = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
-       crypto_aead_clear_flags(aead, CRYPTO_TFM_RES_MASK);
-       crypto_aead_set_flags(aead, crypto_aead_get_flags(aeadctx->sw_cipher) &
-                             CRYPTO_TFM_RES_MASK);
        if (error)
                return error;
        return chcr_ccm_common_setkey(aead, key, keylen);
@@ -3324,9 +3314,6 @@ static int chcr_aead_rfc4309_setkey(struct crypto_aead *aead, const u8 *key,
        crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(aead) &
                              CRYPTO_TFM_REQ_MASK);
        error = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
-       crypto_aead_clear_flags(aead, CRYPTO_TFM_RES_MASK);
-       crypto_aead_set_flags(aead, crypto_aead_get_flags(aeadctx->sw_cipher) &
-                             CRYPTO_TFM_RES_MASK);
        if (error)
                return error;
        keylen -= 3;
@@ -3348,9 +3335,6 @@ static int chcr_gcm_setkey(struct crypto_aead *aead, const u8 *key,
        crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(aead)
                              & CRYPTO_TFM_REQ_MASK);
        ret = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
-       crypto_aead_clear_flags(aead, CRYPTO_TFM_RES_MASK);
-       crypto_aead_set_flags(aead, crypto_aead_get_flags(aeadctx->sw_cipher) &
-                             CRYPTO_TFM_RES_MASK);
        if (ret)
                goto out;
 
@@ -3416,9 +3400,6 @@ static int chcr_authenc_setkey(struct crypto_aead *authenc, const u8 *key,
        crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(authenc)
                              & CRYPTO_TFM_REQ_MASK);
        err = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
-       crypto_aead_clear_flags(authenc, CRYPTO_TFM_RES_MASK);
-       crypto_aead_set_flags(authenc, crypto_aead_get_flags(aeadctx->sw_cipher)
-                             & CRYPTO_TFM_RES_MASK);
        if (err)
                goto out;
 
@@ -3544,9 +3525,6 @@ static int chcr_aead_digest_null_setkey(struct crypto_aead *authenc,
        crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(authenc)
                              & CRYPTO_TFM_REQ_MASK);
        err = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
-       crypto_aead_clear_flags(authenc, CRYPTO_TFM_RES_MASK);
-       crypto_aead_set_flags(authenc, crypto_aead_get_flags(aeadctx->sw_cipher)
-                             & CRYPTO_TFM_RES_MASK);
        if (err)
                goto out;
 

diff --git a/drivers/crypto/geode-aes.c b/drivers/crypto/geode-aes.c
index eb6e6b618361ccc47c60df41498d69dfd3f5c5b4..f4f18bfc2247bfc550e082a2c8e7188122f1015a 100644 (file)
--- a/drivers/crypto/geode-aes.c
+++ b/drivers/crypto/geode-aes.c
@@ -110,7 +110,6 @@ static int geode_setkey_cip(struct crypto_tfm *tfm, const u8 *key,
                unsigned int len)
 {
        struct geode_aes_tfm_ctx *tctx = crypto_tfm_ctx(tfm);
-       unsigned int ret;
 
        tctx->keylen = len;
 
@@ -130,20 +129,13 @@ static int geode_setkey_cip(struct crypto_tfm *tfm, const u8 *key,
        tctx->fallback.cip->base.crt_flags |=
                (tfm->crt_flags & CRYPTO_TFM_REQ_MASK);
 
-       ret = crypto_cipher_setkey(tctx->fallback.cip, key, len);
-       if (ret) {
-               tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
-               tfm->crt_flags |= (tctx->fallback.cip->base.crt_flags &
-                                  CRYPTO_TFM_RES_MASK);
-       }
-       return ret;
+       return crypto_cipher_setkey(tctx->fallback.cip, key, len);
 }
 
 static int geode_setkey_skcipher(struct crypto_skcipher *tfm, const u8 *key,
                                 unsigned int len)
 {
        struct geode_aes_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
-       unsigned int ret;
 
        tctx->keylen = len;
 
@@ -164,11 +156,7 @@ static int geode_setkey_skcipher(struct crypto_skcipher *tfm, const u8 *key,
        crypto_skcipher_set_flags(tctx->fallback.skcipher,
                                  crypto_skcipher_get_flags(tfm) &
                                  CRYPTO_TFM_REQ_MASK);
-       ret = crypto_skcipher_setkey(tctx->fallback.skcipher, key, len);
-       crypto_skcipher_set_flags(tfm,
-                                 crypto_skcipher_get_flags(tctx->fallback.skcipher) &
-                                 CRYPTO_TFM_RES_MASK);
-       return ret;
+       return crypto_skcipher_setkey(tctx->fallback.skcipher, key, len);
 }
 
 static void

diff --git a/drivers/crypto/inside-secure/safexcel_cipher.c b/drivers/crypto/inside-secure/safexcel_cipher.c
index 5ee66532f336793774c33b24496d985a208e7bcb..0c5e80c3f6e3c345a921925811fdede4711abd61 100644 (file)
--- a/drivers/crypto/inside-secure/safexcel_cipher.c
+++ b/drivers/crypto/inside-secure/safexcel_cipher.c
@@ -499,9 +499,6 @@ static int safexcel_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
                goto badkey;
        }
 
-       crypto_aead_set_flags(ctfm, crypto_aead_get_flags(ctfm) &
-                                   CRYPTO_TFM_RES_MASK);
-
        if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma &&
            (memcmp(ctx->ipad, istate.state, ctx->state_sz) ||
             memcmp(ctx->opad, ostate.state, ctx->state_sz)))
@@ -2583,8 +2580,6 @@ static int safexcel_aead_gcm_setkey(struct crypto_aead *ctfm, const u8 *key,
        crypto_cipher_set_flags(ctx->hkaes, crypto_aead_get_flags(ctfm) &
                                CRYPTO_TFM_REQ_MASK);
        ret = crypto_cipher_setkey(ctx->hkaes, key, len);
-       crypto_aead_set_flags(ctfm, crypto_cipher_get_flags(ctx->hkaes) &
-                             CRYPTO_TFM_RES_MASK);
        if (ret)
                return ret;
 

diff --git a/drivers/crypto/inside-secure/safexcel_hash.c b/drivers/crypto/inside-secure/safexcel_hash.c
index 088d7f8aab5e88700442a58736a738ccf0594e94..43962bc709c6c064089cd4d9a8191a2879a9df4f 100644 (file)
--- a/drivers/crypto/inside-secure/safexcel_hash.c
+++ b/drivers/crypto/inside-secure/safexcel_hash.c
@@ -2069,8 +2069,6 @@ static int safexcel_xcbcmac_setkey(struct crypto_ahash *tfm, const u8 *key,
        crypto_cipher_set_flags(ctx->kaes, crypto_ahash_get_flags(tfm) &
                                CRYPTO_TFM_REQ_MASK);
        ret = crypto_cipher_setkey(ctx->kaes, key, len);
-       crypto_ahash_set_flags(tfm, crypto_cipher_get_flags(ctx->kaes) &
-                              CRYPTO_TFM_RES_MASK);
        if (ret)
                return ret;
 
@@ -2090,8 +2088,6 @@ static int safexcel_xcbcmac_setkey(struct crypto_ahash *tfm, const u8 *key,
        ret = crypto_cipher_setkey(ctx->kaes,
                                   (u8 *)key_tmp + 2 * AES_BLOCK_SIZE,
                                   AES_MIN_KEY_SIZE);
-       crypto_ahash_set_flags(tfm, crypto_cipher_get_flags(ctx->kaes) &
-                              CRYPTO_TFM_RES_MASK);
        if (ret)
                return ret;
 
@@ -2174,8 +2170,6 @@ static int safexcel_cmac_setkey(struct crypto_ahash *tfm, const u8 *key,
        crypto_cipher_set_flags(ctx->kaes, crypto_ahash_get_flags(tfm) &
                                CRYPTO_TFM_REQ_MASK);
        ret = crypto_cipher_setkey(ctx->kaes, key, len);
-       crypto_ahash_set_flags(tfm, crypto_cipher_get_flags(ctx->kaes) &
-                              CRYPTO_TFM_RES_MASK);
        if (ret)
                return ret;
 

diff --git a/drivers/crypto/mediatek/mtk-aes.c b/drivers/crypto/mediatek/mtk-aes.c
index 00e580bf8536d43f7e33a21e805fbe237a7148f4..78d660d963e231ae428579552e8bea0b1c207e4c 100644 (file)
--- a/drivers/crypto/mediatek/mtk-aes.c
+++ b/drivers/crypto/mediatek/mtk-aes.c
@@ -1031,8 +1031,6 @@ static int mtk_aes_gcm_setkey(struct crypto_aead *aead, const u8 *key,
        crypto_skcipher_set_flags(ctr, crypto_aead_get_flags(aead) &
                                  CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(ctr, key, keylen);
-       crypto_aead_set_flags(aead, crypto_skcipher_get_flags(ctr) &
-                             CRYPTO_TFM_RES_MASK);
        if (err)
                return err;
 

diff --git a/drivers/crypto/mxs-dcp.c b/drivers/crypto/mxs-dcp.c
index f438b425c6554cd6a5cae82afc7e937517896a8f..435ac1c83df9072bd32378718cadeecb6ae52853 100644 (file)
--- a/drivers/crypto/mxs-dcp.c
+++ b/drivers/crypto/mxs-dcp.c
@@ -492,7 +492,6 @@ static int mxs_dcp_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
                              unsigned int len)
 {
        struct dcp_async_ctx *actx = crypto_skcipher_ctx(tfm);
-       unsigned int ret;
 
        /*
         * AES 128 is supposed by the hardware, store key into temporary
@@ -513,16 +512,7 @@ static int mxs_dcp_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
        crypto_sync_skcipher_clear_flags(actx->fallback, CRYPTO_TFM_REQ_MASK);
        crypto_sync_skcipher_set_flags(actx->fallback,
                                  tfm->base.crt_flags & CRYPTO_TFM_REQ_MASK);
-
-       ret = crypto_sync_skcipher_setkey(actx->fallback, key, len);
-       if (!ret)
-               return 0;
-
-       tfm->base.crt_flags &= ~CRYPTO_TFM_RES_MASK;
-       tfm->base.crt_flags |= crypto_sync_skcipher_get_flags(actx->fallback) &
-                              CRYPTO_TFM_RES_MASK;
-
-       return ret;
+       return crypto_sync_skcipher_setkey(actx->fallback, key, len);
 }
 
 static int mxs_dcp_aes_fallback_init_tfm(struct crypto_skcipher *tfm)

diff --git a/drivers/crypto/picoxcell_crypto.c b/drivers/crypto/picoxcell_crypto.c
index ced4cbed9ea04c89f8d80de6201385cad72d52af..7384e91c8b32b58280504d9db825df05657555c9 100644 (file)
--- a/drivers/crypto/picoxcell_crypto.c
+++ b/drivers/crypto/picoxcell_crypto.c
@@ -465,9 +465,6 @@ static int spacc_aead_setkey(struct crypto_aead *tfm, const u8 *key,
        crypto_aead_set_flags(ctx->sw_cipher, crypto_aead_get_flags(tfm) &
                                              CRYPTO_TFM_REQ_MASK);
        err = crypto_aead_setkey(ctx->sw_cipher, key, keylen);
-       crypto_aead_clear_flags(tfm, CRYPTO_TFM_RES_MASK);
-       crypto_aead_set_flags(tfm, crypto_aead_get_flags(ctx->sw_cipher) &
-                                  CRYPTO_TFM_RES_MASK);
        if (err)
                return err;
 
@@ -802,12 +799,6 @@ static int spacc_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
                                          CRYPTO_TFM_REQ_MASK);
 
                err = crypto_sync_skcipher_setkey(ctx->sw_cipher, key, len);
-
-               tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
-               tfm->crt_flags |=
-                       crypto_sync_skcipher_get_flags(ctx->sw_cipher) &
-                       CRYPTO_TFM_RES_MASK;
-
                if (err)
                        goto sw_setkey_failed;
        }

diff --git a/drivers/crypto/sahara.c b/drivers/crypto/sahara.c
index d4ea2f11ca688120fca768a5d11997ef3974f895..466e30bd529c7a22244a9c83c8574dd26c515d42 100644 (file)
--- a/drivers/crypto/sahara.c
+++ b/drivers/crypto/sahara.c
@@ -601,7 +601,6 @@ static int sahara_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
                             unsigned int keylen)
 {
        struct sahara_ctx *ctx = crypto_skcipher_ctx(tfm);
-       int ret;
 
        ctx->keylen = keylen;
 
@@ -621,13 +620,7 @@ static int sahara_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
        crypto_sync_skcipher_clear_flags(ctx->fallback, CRYPTO_TFM_REQ_MASK);
        crypto_sync_skcipher_set_flags(ctx->fallback, tfm->base.crt_flags &
                                                 CRYPTO_TFM_REQ_MASK);
-
-       ret = crypto_sync_skcipher_setkey(ctx->fallback, key, keylen);
-
-       tfm->base.crt_flags &= ~CRYPTO_TFM_RES_MASK;
-       tfm->base.crt_flags |= crypto_sync_skcipher_get_flags(ctx->fallback) &
-                              CRYPTO_TFM_RES_MASK;
-       return ret;
+       return crypto_sync_skcipher_setkey(ctx->fallback, key, keylen);
 }
 
 static int sahara_aes_crypt(struct skcipher_request *req, unsigned long mode)

diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index accd0c8038fd2b96ed19413aebe73290edf9d915..763863dbc079a8c2befad111819fab54b19930a9 100644 (file)
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -107,8 +107,6 @@
 #define CRYPTO_TFM_NEED_KEY            0x00000001
 
 #define CRYPTO_TFM_REQ_MASK            0x000fff00
-#define CRYPTO_TFM_RES_MASK            0xfff00000
-
 #define CRYPTO_TFM_REQ_FORBID_WEAK_KEYS        0x00000100
 #define CRYPTO_TFM_REQ_MAY_SLEEP       0x00000200
 #define CRYPTO_TFM_REQ_MAY_BACKLOG     0x00000400