crypto: drop mask=CRYPTO_ALG_ASYNC from 'shash' tfm allocations

'shash' algorithms are always synchronous, so passing CRYPTO_ALG_ASYNC
in the mask to crypto_alloc_shash() has no effect.  Many users therefore
already don't pass it, but some still do.  This inconsistency can cause
confusion, especially since the way the 'mask' argument works is
somewhat counterintuitive.

Thus, just remove the unneeded CRYPTO_ALG_ASYNC flags.

This patch shouldn't change any actual behavior.

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

diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index 61c392752fe4bbfeba5b1b404bf64cff7e9d8b00..ccfcf00f2798d3c7cbad526517fcdd86c2f02314 100644 (file)
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -3623,7 +3623,7 @@ static int receive_protocol(struct drbd_connection *connection, struct packet_in
                 * change.
                 */
 
-               peer_integrity_tfm = crypto_alloc_shash(integrity_alg, 0, CRYPTO_ALG_ASYNC);
+               peer_integrity_tfm = crypto_alloc_shash(integrity_alg, 0, 0);
                if (IS_ERR(peer_integrity_tfm)) {
                        peer_integrity_tfm = NULL;
                        drbd_err(connection, "peer data-integrity-alg %s not supported\n",

diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c
index bb3096bf2cc6b5bb79f074278e7b4825f4d3bece..d4ad0bfee2519aeef4a3f4e7c4baf100fa38bb16 100644 (file)
--- a/drivers/md/dm-integrity.c
+++ b/drivers/md/dm-integrity.c
@@ -2804,7 +2804,7 @@ static int get_mac(struct crypto_shash **hash, struct alg_spec *a, char **error,
        int r;
 
        if (a->alg_string) {
-               *hash = crypto_alloc_shash(a->alg_string, 0, CRYPTO_ALG_ASYNC);
+               *hash = crypto_alloc_shash(a->alg_string, 0, 0);
                if (IS_ERR(*hash)) {
                        *error = error_alg;
                        r = PTR_ERR(*hash);

diff --git a/drivers/net/wireless/intersil/orinoco/mic.c b/drivers/net/wireless/intersil/orinoco/mic.c
index 08bc7822f8209d0a9136357edb18683092c86c18..709d9ab3e7bcb694964cd60d9162059110faff4a 100644 (file)
--- a/drivers/net/wireless/intersil/orinoco/mic.c
+++ b/drivers/net/wireless/intersil/orinoco/mic.c
@@ -16,8 +16,7 @@
 /********************************************************************/
 int orinoco_mic_init(struct orinoco_private *priv)
 {
-       priv->tx_tfm_mic = crypto_alloc_shash("michael_mic", 0,
-                                             CRYPTO_ALG_ASYNC);
+       priv->tx_tfm_mic = crypto_alloc_shash("michael_mic", 0, 0);
        if (IS_ERR(priv->tx_tfm_mic)) {
                printk(KERN_DEBUG "orinoco_mic_init: could not allocate "
                       "crypto API michael_mic\n");
@@ -25,8 +24,7 @@ int orinoco_mic_init(struct orinoco_private *priv)
                return -ENOMEM;
        }
 
-       priv->rx_tfm_mic = crypto_alloc_shash("michael_mic", 0,
-                                             CRYPTO_ALG_ASYNC);
+       priv->rx_tfm_mic = crypto_alloc_shash("michael_mic", 0, 0);
        if (IS_ERR(priv->rx_tfm_mic)) {
                printk(KERN_DEBUG "orinoco_mic_init: could not allocate "
                       "crypto API michael_mic\n");

diff --git a/fs/ubifs/auth.c b/fs/ubifs/auth.c
index 124e965a28b30d985f5406e039431588d96e9f53..5bf5fd08879e6b2dd0570d179c3743b646184c5b 100644 (file)
--- a/fs/ubifs/auth.c
+++ b/fs/ubifs/auth.c
@@ -269,8 +269,7 @@ int ubifs_init_authentication(struct ubifs_info *c)
                goto out;
        }
 
-       c->hash_tfm = crypto_alloc_shash(c->auth_hash_name, 0,
-                                        CRYPTO_ALG_ASYNC);
+       c->hash_tfm = crypto_alloc_shash(c->auth_hash_name, 0, 0);
        if (IS_ERR(c->hash_tfm)) {
                err = PTR_ERR(c->hash_tfm);
                ubifs_err(c, "Can not allocate %s: %d",
@@ -286,7 +285,7 @@ int ubifs_init_authentication(struct ubifs_info *c)
                goto out_free_hash;
        }
 
-       c->hmac_tfm = crypto_alloc_shash(hmac_name, 0, CRYPTO_ALG_ASYNC);
+       c->hmac_tfm = crypto_alloc_shash(hmac_name, 0, 0);
        if (IS_ERR(c->hmac_tfm)) {
                err = PTR_ERR(c->hmac_tfm);
                ubifs_err(c, "Can not allocate %s: %d", hmac_name, err);

diff --git a/net/bluetooth/smp.c b/net/bluetooth/smp.c
index 1f94a25beef69b9bdd48a7688d2e372e9408fd73..621146d04c0380de424c8b5ef866e2a8056a88d5 100644 (file)
--- a/net/bluetooth/smp.c
+++ b/net/bluetooth/smp.c
@@ -3912,7 +3912,7 @@ int __init bt_selftest_smp(void)
                return PTR_ERR(tfm_aes);
        }
 
-       tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, CRYPTO_ALG_ASYNC);
+       tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
        if (IS_ERR(tfm_cmac)) {
                BT_ERR("Unable to create CMAC crypto context");
                crypto_free_cipher(tfm_aes);

diff --git a/security/apparmor/crypto.c b/security/apparmor/crypto.c
index 136f2a04783670d5ea8ad0c93d063d5a866fc297..af03d98c75520f4906e07fae3200d948d115289f 100644 (file)
--- a/security/apparmor/crypto.c
+++ b/security/apparmor/crypto.c
@@ -112,7 +112,7 @@ static int __init init_profile_hash(void)
        if (!apparmor_initialized)
                return 0;
 
-       tfm = crypto_alloc_shash("sha1", 0, CRYPTO_ALG_ASYNC);
+       tfm = crypto_alloc_shash("sha1", 0, 0);
        if (IS_ERR(tfm)) {
                int error = PTR_ERR(tfm);
                AA_ERROR("failed to setup profile sha1 hashing: %d\n", error);

diff --git a/security/integrity/evm/evm_crypto.c b/security/integrity/evm/evm_crypto.c
index 8c25f949ebdb6082053c4cb8d9e89ec8d8c49e6a..1820099dc74bf41efd6302b3aaca2d2a92ba1a8e 100644 (file)
--- a/security/integrity/evm/evm_crypto.c
+++ b/security/integrity/evm/evm_crypto.c
@@ -97,8 +97,7 @@ static struct shash_desc *init_desc(char type, uint8_t hash_algo)
                mutex_lock(&mutex);
                if (*tfm)
                        goto out;
-               *tfm = crypto_alloc_shash(algo, 0,
-                                         CRYPTO_ALG_ASYNC | CRYPTO_NOLOAD);
+               *tfm = crypto_alloc_shash(algo, 0, CRYPTO_NOLOAD);
                if (IS_ERR(*tfm)) {
                        rc = PTR_ERR(*tfm);
                        pr_err("Can not allocate %s (reason: %ld)\n", algo, rc);

diff --git a/security/keys/encrypted-keys/encrypted.c b/security/keys/encrypted-keys/encrypted.c
index d92cbf9687c33f090865f6d0caa99d9936f49e3a..a3891ae9fa0fcb24e79161d2592ed16644cdad1a 100644 (file)
--- a/security/keys/encrypted-keys/encrypted.c
+++ b/security/keys/encrypted-keys/encrypted.c
@@ -342,7 +342,7 @@ static int calc_hmac(u8 *digest, const u8 *key, unsigned int keylen,
        struct crypto_shash *tfm;
        int err;
 
-       tfm = crypto_alloc_shash(hmac_alg, 0, CRYPTO_ALG_ASYNC);
+       tfm = crypto_alloc_shash(hmac_alg, 0, 0);
        if (IS_ERR(tfm)) {
                pr_err("encrypted_key: can't alloc %s transform: %ld\n",
                       hmac_alg, PTR_ERR(tfm));
@@ -984,7 +984,7 @@ static int __init init_encrypted(void)
 {
        int ret;
 
-       hash_tfm = crypto_alloc_shash(hash_alg, 0, CRYPTO_ALG_ASYNC);
+       hash_tfm = crypto_alloc_shash(hash_alg, 0, 0);
        if (IS_ERR(hash_tfm)) {
                pr_err("encrypted_key: can't allocate %s transform: %ld\n",
                       hash_alg, PTR_ERR(hash_tfm));

diff --git a/security/keys/trusted.c b/security/keys/trusted.c
index ff6789365a12fb15ed91e160ba2936262ec5c29c..2d4f16b2a7c553472700160b26bd55716e03cacc 100644 (file)
--- a/security/keys/trusted.c
+++ b/security/keys/trusted.c
@@ -1199,14 +1199,14 @@ static int __init trusted_shash_alloc(void)
 {
        int ret;
 
-       hmacalg = crypto_alloc_shash(hmac_alg, 0, CRYPTO_ALG_ASYNC);
+       hmacalg = crypto_alloc_shash(hmac_alg, 0, 0);
        if (IS_ERR(hmacalg)) {
                pr_info("trusted_key: could not allocate crypto %s\n",
                        hmac_alg);
                return PTR_ERR(hmacalg);
        }
 
-       hashalg = crypto_alloc_shash(hash_alg, 0, CRYPTO_ALG_ASYNC);
+       hashalg = crypto_alloc_shash(hash_alg, 0, 0);
        if (IS_ERR(hashalg)) {
                pr_info("trusted_key: could not allocate crypto %s\n",
                        hash_alg);