Merge branch 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6

Pull crypto updates from Herbert Xu:
 "API:
   - Remove VLA usage
   - Add cryptostat user-space interface
   - Add notifier for new crypto algorithms

  Algorithms:
   - Add OFB mode
   - Remove speck

  Drivers:
   - Remove x86/sha*-mb as they are buggy
   - Remove pcbc(aes) from x86/aesni
   - Improve performance of arm/ghash-ce by up to 85%
   - Implement CTS-CBC in arm64/aes-blk, faster by up to 50%
   - Remove PMULL based arm64/crc32 driver
   - Use PMULL in arm64/crct10dif
   - Add aes-ctr support in s5p-sss
   - Add caam/qi2 driver

  Others:
   - Pick better transform if one becomes available in crc-t10dif"

* 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6: (124 commits)
  crypto: chelsio - Update ntx queue received from cxgb4
  crypto: ccree - avoid implicit enum conversion
  crypto: caam - add SPDX license identifier to all files
  crypto: caam/qi - simplify CGR allocation, freeing
  crypto: mxs-dcp - make symbols 'sha1_null_hash' and 'sha256_null_hash' static
  crypto: arm64/aes-blk - ensure XTS mask is always loaded
  crypto: testmgr - fix sizeof() on COMP_BUF_SIZE
  crypto: chtls - remove set but not used variable 'csk'
  crypto: axis - fix platform_no_drv_owner.cocci warnings
  crypto: x86/aes-ni - fix build error following fpu template removal
  crypto: arm64/aes - fix handling sub-block CTS-CBC inputs
  crypto: caam/qi2 - avoid double export
  crypto: mxs-dcp - Fix AES issues
  crypto: mxs-dcp - Fix SHA null hashes and output length
  crypto: mxs-dcp - Implement sha import/export
  crypto: aegis/generic - fix for big endian systems
  crypto: morus/generic - fix for big endian systems
  crypto: lrw - fix rebase error after out of bounds fix
  crypto: cavium/nitrox - use pci_alloc_irq_vectors() while enabling MSI-X.
  crypto: cavium/nitrox - NITROX command queue changes.
  ...

11 files changed, 132 insertions, 133 deletions

diff --git a/net/ceph/crypto.c b/net/ceph/crypto.c
index 02172c408ff2..5d6724cee38f 100644
--- a/net/ceph/crypto.c
+++ b/net/ceph/crypto.c
@@ -46,9 +46,9 @@ static int set_secret(struct ceph_crypto_key *key, void *buf)
                 goto fail;
         }
 
-        /* crypto_alloc_skcipher() allocates with GFP_KERNEL */
+        /* crypto_alloc_sync_skcipher() allocates with GFP_KERNEL */
         noio_flag = memalloc_noio_save();
-        key->tfm = crypto_alloc_skcipher("cbc(aes)", 0, CRYPTO_ALG_ASYNC);
+        key->tfm = crypto_alloc_sync_skcipher("cbc(aes)", 0, 0);
         memalloc_noio_restore(noio_flag);
         if (IS_ERR(key->tfm)) {
                 ret = PTR_ERR(key->tfm);
@@ -56,7 +56,7 @@ static int set_secret(struct ceph_crypto_key *key, void *buf)
                 goto fail;
         }
 
-        ret = crypto_skcipher_setkey(key->tfm, key->key, key->len);
+        ret = crypto_sync_skcipher_setkey(key->tfm, key->key, key->len);
         if (ret)
                 goto fail;
 
@@ -136,7 +136,7 @@ void ceph_crypto_key_destroy(struct ceph_crypto_key *key)
         if (key) {
                 kfree(key->key);
                 key->key = NULL;
-                crypto_free_skcipher(key->tfm);
+                crypto_free_sync_skcipher(key->tfm);
                 key->tfm = NULL;
         }
 }
@@ -216,7 +216,7 @@ static void teardown_sgtable(struct sg_table *sgt)
 static int ceph_aes_crypt(const struct ceph_crypto_key *key, bool encrypt,
                           void *buf, int buf_len, int in_len, int *pout_len)
 {
-        SKCIPHER_REQUEST_ON_STACK(req, key->tfm);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm);
         struct sg_table sgt;
         struct scatterlist prealloc_sg;
         char iv[AES_BLOCK_SIZE] __aligned(8);
@@ -232,7 +232,7 @@ static int ceph_aes_crypt(const struct ceph_crypto_key *key, bool encrypt,
                 return ret;
 
         memcpy(iv, aes_iv, AES_BLOCK_SIZE);
-        skcipher_request_set_tfm(req, key->tfm);
+        skcipher_request_set_sync_tfm(req, key->tfm);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, sgt.sgl, sgt.sgl, crypt_len, iv);
 
diff --git a/net/ceph/crypto.h b/net/ceph/crypto.h
index bb45c7d43739..96ef4d860bc9 100644
--- a/net/ceph/crypto.h
+++ b/net/ceph/crypto.h
@@ -13,7 +13,7 @@ struct ceph_crypto_key {
         struct ceph_timespec created;
         int len;
         void *key;
-        struct crypto_skcipher *tfm;
+        struct crypto_sync_skcipher *tfm;
 };
 
 int ceph_crypto_key_clone(struct ceph_crypto_key *dst,
diff --git a/net/mac802154/llsec.c b/net/mac802154/llsec.c
index 2fb703d70803..7e29f88dbf6a 100644
--- a/net/mac802154/llsec.c
+++ b/net/mac802154/llsec.c
@@ -146,18 +146,18 @@ llsec_key_alloc(const struct ieee802154_llsec_key *template)
                         goto err_tfm;
         }
 
-        key->tfm0 = crypto_alloc_skcipher("ctr(aes)", 0, CRYPTO_ALG_ASYNC);
+        key->tfm0 = crypto_alloc_sync_skcipher("ctr(aes)", 0, 0);
         if (IS_ERR(key->tfm0))
                 goto err_tfm;
 
-        if (crypto_skcipher_setkey(key->tfm0, template->key,
+        if (crypto_sync_skcipher_setkey(key->tfm0, template->key,
                                    IEEE802154_LLSEC_KEY_SIZE))
                 goto err_tfm0;
 
         return key;
 
 err_tfm0:
-        crypto_free_skcipher(key->tfm0);
+        crypto_free_sync_skcipher(key->tfm0);
 err_tfm:
         for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
                 if (key->tfm[i])
@@ -177,7 +177,7 @@ static void llsec_key_release(struct kref *ref)
         for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
                 crypto_free_aead(key->tfm[i]);
 
-        crypto_free_skcipher(key->tfm0);
+        crypto_free_sync_skcipher(key->tfm0);
         kzfree(key);
 }
 
@@ -622,7 +622,7 @@ llsec_do_encrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
 {
         u8 iv[16];
         struct scatterlist src;
-        SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
         int err, datalen;
         unsigned char *data;
 
@@ -632,7 +632,7 @@ llsec_do_encrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
         datalen = skb_tail_pointer(skb) - data;
         sg_init_one(&src, data, datalen);
 
-        skcipher_request_set_tfm(req, key->tfm0);
+        skcipher_request_set_sync_tfm(req, key->tfm0);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, &src, &src, datalen, iv);
         err = crypto_skcipher_encrypt(req);
@@ -840,7 +840,7 @@ llsec_do_decrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
         unsigned char *data;
         int datalen;
         struct scatterlist src;
-        SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
         int err;
 
         llsec_geniv(iv, dev_addr, &hdr->sec);
@@ -849,7 +849,7 @@ llsec_do_decrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
 
         sg_init_one(&src, data, datalen);
 
-        skcipher_request_set_tfm(req, key->tfm0);
+        skcipher_request_set_sync_tfm(req, key->tfm0);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, &src, &src, datalen, iv);
 
diff --git a/net/mac802154/llsec.h b/net/mac802154/llsec.h
index 6f3b658e3279..8be46d74dc39 100644
--- a/net/mac802154/llsec.h
+++ b/net/mac802154/llsec.h
@@ -29,7 +29,7 @@ struct mac802154_llsec_key {
 
         /* one tfm for each authsize (4/8/16) */
         struct crypto_aead *tfm[3];
-        struct crypto_skcipher *tfm0;
+        struct crypto_sync_skcipher *tfm0;
 
         struct kref ref;
 };
diff --git a/net/rxrpc/ar-internal.h b/net/rxrpc/ar-internal.h
index 0a7c49e8e053..382196e57a26 100644
--- a/net/rxrpc/ar-internal.h
+++ b/net/rxrpc/ar-internal.h
@@ -435,7 +435,7 @@ struct rxrpc_connection {
         struct sk_buff_head     rx_queue;       /* received conn-level packets */
         const struct rxrpc_security *security;  /* applied security module */
         struct key              *server_key;    /* security for this service */
-        struct crypto_skcipher  *cipher;        /* encryption handle */
+        struct crypto_sync_skcipher *cipher;    /* encryption handle */
         struct rxrpc_crypt      csum_iv;        /* packet checksum base */
         unsigned long           flags;
         unsigned long           events;
diff --git a/net/rxrpc/rxkad.c b/net/rxrpc/rxkad.c
index cea16838d588..cbef9ea43dec 100644
--- a/net/rxrpc/rxkad.c
+++ b/net/rxrpc/rxkad.c
@@ -46,7 +46,7 @@ struct rxkad_level2_hdr {
  * alloc routine, but since we have it to hand, we use it to decrypt RESPONSE
  * packets
  */
-static struct crypto_skcipher *rxkad_ci;
+static struct crypto_sync_skcipher *rxkad_ci;
 static DEFINE_MUTEX(rxkad_ci_mutex);
 
 /*
@@ -54,7 +54,7 @@ static DEFINE_MUTEX(rxkad_ci_mutex);
  */
 static int rxkad_init_connection_security(struct rxrpc_connection *conn)
 {
-        struct crypto_skcipher *ci;
+        struct crypto_sync_skcipher *ci;
         struct rxrpc_key_token *token;
         int ret;
 
@@ -63,14 +63,14 @@ static int rxkad_init_connection_security(struct rxrpc_connection *conn)
         token = conn->params.key->payload.data[0];
         conn->security_ix = token->security_index;
 
-        ci = crypto_alloc_skcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC);
+        ci = crypto_alloc_sync_skcipher("pcbc(fcrypt)", 0, 0);
         if (IS_ERR(ci)) {
                 _debug("no cipher");
                 ret = PTR_ERR(ci);
                 goto error;
         }
 
-        if (crypto_skcipher_setkey(ci, token->kad->session_key,
+        if (crypto_sync_skcipher_setkey(ci, token->kad->session_key,
                                    sizeof(token->kad->session_key)) < 0)
                 BUG();
 
@@ -104,7 +104,7 @@ error:
 static int rxkad_prime_packet_security(struct rxrpc_connection *conn)
 {
         struct rxrpc_key_token *token;
-        SKCIPHER_REQUEST_ON_STACK(req, conn->cipher);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, conn->cipher);
         struct scatterlist sg;
         struct rxrpc_crypt iv;
         __be32 *tmpbuf;
@@ -128,7 +128,7 @@ static int rxkad_prime_packet_security(struct rxrpc_connection *conn)
         tmpbuf[3] = htonl(conn->security_ix);
 
         sg_init_one(&sg, tmpbuf, tmpsize);
-        skcipher_request_set_tfm(req, conn->cipher);
+        skcipher_request_set_sync_tfm(req, conn->cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, &sg, &sg, tmpsize, iv.x);
         crypto_skcipher_encrypt(req);
@@ -167,7 +167,7 @@ static int rxkad_secure_packet_auth(const struct rxrpc_call *call,
         memset(&iv, 0, sizeof(iv));
 
         sg_init_one(&sg, sechdr, 8);
-        skcipher_request_set_tfm(req, call->conn->cipher);
+        skcipher_request_set_sync_tfm(req, call->conn->cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, &sg, &sg, 8, iv.x);
         crypto_skcipher_encrypt(req);
@@ -212,7 +212,7 @@ static int rxkad_secure_packet_encrypt(const struct rxrpc_call *call,
         memcpy(&iv, token->kad->session_key, sizeof(iv));
 
         sg_init_one(&sg[0], sechdr, sizeof(rxkhdr));
-        skcipher_request_set_tfm(req, call->conn->cipher);
+        skcipher_request_set_sync_tfm(req, call->conn->cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, &sg[0], &sg[0], sizeof(rxkhdr), iv.x);
         crypto_skcipher_encrypt(req);
@@ -250,7 +250,7 @@ static int rxkad_secure_packet(struct rxrpc_call *call,
                                void *sechdr)
 {
         struct rxrpc_skb_priv *sp;
-        SKCIPHER_REQUEST_ON_STACK(req, call->conn->cipher);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, call->conn->cipher);
         struct rxrpc_crypt iv;
         struct scatterlist sg;
         u32 x, y;
@@ -279,7 +279,7 @@ static int rxkad_secure_packet(struct rxrpc_call *call,
         call->crypto_buf[1] = htonl(x);
 
         sg_init_one(&sg, call->crypto_buf, 8);
-        skcipher_request_set_tfm(req, call->conn->cipher);
+        skcipher_request_set_sync_tfm(req, call->conn->cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, &sg, &sg, 8, iv.x);
         crypto_skcipher_encrypt(req);
@@ -352,7 +352,7 @@ static int rxkad_verify_packet_1(struct rxrpc_call *call, struct sk_buff *skb,
         /* start the decryption afresh */
         memset(&iv, 0, sizeof(iv));
 
-        skcipher_request_set_tfm(req, call->conn->cipher);
+        skcipher_request_set_sync_tfm(req, call->conn->cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, sg, sg, 8, iv.x);
         crypto_skcipher_decrypt(req);
@@ -450,7 +450,7 @@ static int rxkad_verify_packet_2(struct rxrpc_call *call, struct sk_buff *skb,
         token = call->conn->params.key->payload.data[0];
         memcpy(&iv, token->kad->session_key, sizeof(iv));
 
-        skcipher_request_set_tfm(req, call->conn->cipher);
+        skcipher_request_set_sync_tfm(req, call->conn->cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, sg, sg, len, iv.x);
         crypto_skcipher_decrypt(req);
@@ -506,7 +506,7 @@ static int rxkad_verify_packet(struct rxrpc_call *call, struct sk_buff *skb,
                                unsigned int offset, unsigned int len,
                                rxrpc_seq_t seq, u16 expected_cksum)
 {
-        SKCIPHER_REQUEST_ON_STACK(req, call->conn->cipher);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, call->conn->cipher);
         struct rxrpc_crypt iv;
         struct scatterlist sg;
         bool aborted;
@@ -529,7 +529,7 @@ static int rxkad_verify_packet(struct rxrpc_call *call, struct sk_buff *skb,
         call->crypto_buf[1] = htonl(x);
 
         sg_init_one(&sg, call->crypto_buf, 8);
-        skcipher_request_set_tfm(req, call->conn->cipher);
+        skcipher_request_set_sync_tfm(req, call->conn->cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, &sg, &sg, 8, iv.x);
         crypto_skcipher_encrypt(req);
@@ -755,7 +755,7 @@ static void rxkad_encrypt_response(struct rxrpc_connection *conn,
                                    struct rxkad_response *resp,
                                    const struct rxkad_key *s2)
 {
-        SKCIPHER_REQUEST_ON_STACK(req, conn->cipher);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, conn->cipher);
         struct rxrpc_crypt iv;
         struct scatterlist sg[1];
 
@@ -764,7 +764,7 @@ static void rxkad_encrypt_response(struct rxrpc_connection *conn,
 
         sg_init_table(sg, 1);
         sg_set_buf(sg, &resp->encrypted, sizeof(resp->encrypted));
-        skcipher_request_set_tfm(req, conn->cipher);
+        skcipher_request_set_sync_tfm(req, conn->cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, sg, sg, sizeof(resp->encrypted), iv.x);
         crypto_skcipher_encrypt(req);
@@ -1021,7 +1021,7 @@ static void rxkad_decrypt_response(struct rxrpc_connection *conn,
                                    struct rxkad_response *resp,
                                    const struct rxrpc_crypt *session_key)
 {
-        SKCIPHER_REQUEST_ON_STACK(req, rxkad_ci);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, rxkad_ci);
         struct scatterlist sg[1];
         struct rxrpc_crypt iv;
 
@@ -1031,7 +1031,7 @@ static void rxkad_decrypt_response(struct rxrpc_connection *conn,
         ASSERT(rxkad_ci != NULL);
 
         mutex_lock(&rxkad_ci_mutex);
-        if (crypto_skcipher_setkey(rxkad_ci, session_key->x,
+        if (crypto_sync_skcipher_setkey(rxkad_ci, session_key->x,
                                    sizeof(*session_key)) < 0)
                 BUG();
 
@@ -1039,7 +1039,7 @@ static void rxkad_decrypt_response(struct rxrpc_connection *conn,
 
         sg_init_table(sg, 1);
         sg_set_buf(sg, &resp->encrypted, sizeof(resp->encrypted));
-        skcipher_request_set_tfm(req, rxkad_ci);
+        skcipher_request_set_sync_tfm(req, rxkad_ci);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, sg, sg, sizeof(resp->encrypted), iv.x);
         crypto_skcipher_decrypt(req);
@@ -1218,7 +1218,7 @@ static void rxkad_clear(struct rxrpc_connection *conn)
         _enter("");
 
         if (conn->cipher)
-                crypto_free_skcipher(conn->cipher);
+                crypto_free_sync_skcipher(conn->cipher);
 }
 
 /*
@@ -1228,7 +1228,7 @@ static int rxkad_init(void)
 {
         /* pin the cipher we need so that the crypto layer doesn't invoke
          * keventd to go get it */
-        rxkad_ci = crypto_alloc_skcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC);
+        rxkad_ci = crypto_alloc_sync_skcipher("pcbc(fcrypt)", 0, 0);
         return PTR_ERR_OR_ZERO(rxkad_ci);
 }
 
@@ -1238,7 +1238,7 @@ static int rxkad_init(void)
 static void rxkad_exit(void)
 {
         if (rxkad_ci)
-                crypto_free_skcipher(rxkad_ci);
+                crypto_free_sync_skcipher(rxkad_ci);
 }
 
 /*
diff --git a/net/sunrpc/auth_gss/gss_krb5_crypto.c b/net/sunrpc/auth_gss/gss_krb5_crypto.c
index 0220e1ca5280..4f43383971ba 100644
--- a/net/sunrpc/auth_gss/gss_krb5_crypto.c
+++ b/net/sunrpc/auth_gss/gss_krb5_crypto.c
@@ -53,7 +53,7 @@
 
 u32
 krb5_encrypt(
-        struct crypto_skcipher *tfm,
+        struct crypto_sync_skcipher *tfm,
         void * iv,
         void * in,
         void * out,
@@ -62,24 +62,24 @@ krb5_encrypt(
         u32 ret = -EINVAL;
         struct scatterlist sg[1];
         u8 local_iv[GSS_KRB5_MAX_BLOCKSIZE] = {0};
-        SKCIPHER_REQUEST_ON_STACK(req, tfm);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, tfm);
 
-        if (length % crypto_skcipher_blocksize(tfm) != 0)
+        if (length % crypto_sync_skcipher_blocksize(tfm) != 0)
                 goto out;
 
-        if (crypto_skcipher_ivsize(tfm) > GSS_KRB5_MAX_BLOCKSIZE) {
+        if (crypto_sync_skcipher_ivsize(tfm) > GSS_KRB5_MAX_BLOCKSIZE) {
                 dprintk("RPC:       gss_k5encrypt: tfm iv size too large %d\n",
-                        crypto_skcipher_ivsize(tfm));
+                        crypto_sync_skcipher_ivsize(tfm));
                 goto out;
         }
 
         if (iv)
-                memcpy(local_iv, iv, crypto_skcipher_ivsize(tfm));
+                memcpy(local_iv, iv, crypto_sync_skcipher_ivsize(tfm));
 
         memcpy(out, in, length);
         sg_init_one(sg, out, length);
 
-        skcipher_request_set_tfm(req, tfm);
+        skcipher_request_set_sync_tfm(req, tfm);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, sg, sg, length, local_iv);
 
@@ -92,7 +92,7 @@ out:
 
 u32
 krb5_decrypt(
-     struct crypto_skcipher *tfm,
+     struct crypto_sync_skcipher *tfm,
      void * iv,
      void * in,
      void * out,
@@ -101,23 +101,23 @@ krb5_decrypt(
         u32 ret = -EINVAL;
         struct scatterlist sg[1];
         u8 local_iv[GSS_KRB5_MAX_BLOCKSIZE] = {0};
-        SKCIPHER_REQUEST_ON_STACK(req, tfm);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, tfm);
 
-        if (length % crypto_skcipher_blocksize(tfm) != 0)
+        if (length % crypto_sync_skcipher_blocksize(tfm) != 0)
                 goto out;
 
-        if (crypto_skcipher_ivsize(tfm) > GSS_KRB5_MAX_BLOCKSIZE) {
+        if (crypto_sync_skcipher_ivsize(tfm) > GSS_KRB5_MAX_BLOCKSIZE) {
                 dprintk("RPC:       gss_k5decrypt: tfm iv size too large %d\n",
-                        crypto_skcipher_ivsize(tfm));
+                        crypto_sync_skcipher_ivsize(tfm));
                 goto out;
         }
         if (iv)
-                memcpy(local_iv,iv, crypto_skcipher_ivsize(tfm));
+                memcpy(local_iv, iv, crypto_sync_skcipher_ivsize(tfm));
 
         memcpy(out, in, length);
         sg_init_one(sg, out, length);
 
-        skcipher_request_set_tfm(req, tfm);
+        skcipher_request_set_sync_tfm(req, tfm);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, sg, sg, length, local_iv);
 
@@ -466,7 +466,8 @@ encryptor(struct scatterlist *sg, void *data)
 {
         struct encryptor_desc *desc = data;
         struct xdr_buf *outbuf = desc->outbuf;
-        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(desc->req);
+        struct crypto_sync_skcipher *tfm =
+                crypto_sync_skcipher_reqtfm(desc->req);
         struct page *in_page;
         int thislen = desc->fraglen + sg->length;
         int fraglen, ret;
@@ -492,7 +493,7 @@ encryptor(struct scatterlist *sg, void *data)
         desc->fraglen += sg->length;
         desc->pos += sg->length;
 
-        fraglen = thislen & (crypto_skcipher_blocksize(tfm) - 1);
+        fraglen = thislen & (crypto_sync_skcipher_blocksize(tfm) - 1);
         thislen -= fraglen;
 
         if (thislen == 0)
@@ -526,16 +527,16 @@ encryptor(struct scatterlist *sg, void *data)
 }
 
 int
-gss_encrypt_xdr_buf(struct crypto_skcipher *tfm, struct xdr_buf *buf,
+gss_encrypt_xdr_buf(struct crypto_sync_skcipher *tfm, struct xdr_buf *buf,
                     int offset, struct page **pages)
 {
         int ret;
         struct encryptor_desc desc;
-        SKCIPHER_REQUEST_ON_STACK(req, tfm);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, tfm);
 
-        BUG_ON((buf->len - offset) % crypto_skcipher_blocksize(tfm) != 0);
+        BUG_ON((buf->len - offset) % crypto_sync_skcipher_blocksize(tfm) != 0);
 
-        skcipher_request_set_tfm(req, tfm);
+        skcipher_request_set_sync_tfm(req, tfm);
         skcipher_request_set_callback(req, 0, NULL, NULL);
 
         memset(desc.iv, 0, sizeof(desc.iv));
@@ -567,7 +568,8 @@ decryptor(struct scatterlist *sg, void *data)
 {
         struct decryptor_desc *desc = data;
         int thislen = desc->fraglen + sg->length;
-        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(desc->req);
+        struct crypto_sync_skcipher *tfm =
+                crypto_sync_skcipher_reqtfm(desc->req);
         int fraglen, ret;
 
         /* Worst case is 4 fragments: head, end of page 1, start
@@ -578,7 +580,7 @@ decryptor(struct scatterlist *sg, void *data)
         desc->fragno++;
         desc->fraglen += sg->length;
 
-        fraglen = thislen & (crypto_skcipher_blocksize(tfm) - 1);
+        fraglen = thislen & (crypto_sync_skcipher_blocksize(tfm) - 1);
         thislen -= fraglen;
 
         if (thislen == 0)
@@ -608,17 +610,17 @@ decryptor(struct scatterlist *sg, void *data)
 }
 
 int
-gss_decrypt_xdr_buf(struct crypto_skcipher *tfm, struct xdr_buf *buf,
+gss_decrypt_xdr_buf(struct crypto_sync_skcipher *tfm, struct xdr_buf *buf,
                     int offset)
 {
         int ret;
         struct decryptor_desc desc;
-        SKCIPHER_REQUEST_ON_STACK(req, tfm);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, tfm);
 
         /* XXXJBF: */
-        BUG_ON((buf->len - offset) % crypto_skcipher_blocksize(tfm) != 0);
+        BUG_ON((buf->len - offset) % crypto_sync_skcipher_blocksize(tfm) != 0);
 
-        skcipher_request_set_tfm(req, tfm);
+        skcipher_request_set_sync_tfm(req, tfm);
         skcipher_request_set_callback(req, 0, NULL, NULL);
 
         memset(desc.iv, 0, sizeof(desc.iv));
@@ -672,12 +674,12 @@ xdr_extend_head(struct xdr_buf *buf, unsigned int base, unsigned int shiftlen)
 }
 
 static u32
-gss_krb5_cts_crypt(struct crypto_skcipher *cipher, struct xdr_buf *buf,
+gss_krb5_cts_crypt(struct crypto_sync_skcipher *cipher, struct xdr_buf *buf,
                    u32 offset, u8 *iv, struct page **pages, int encrypt)
 {
         u32 ret;
         struct scatterlist sg[1];
-        SKCIPHER_REQUEST_ON_STACK(req, cipher);
+        SYNC_SKCIPHER_REQUEST_ON_STACK(req, cipher);
         u8 *data;
         struct page **save_pages;
         u32 len = buf->len - offset;
@@ -706,7 +708,7 @@ gss_krb5_cts_crypt(struct crypto_skcipher *cipher, struct xdr_buf *buf,
 
         sg_init_one(sg, data, len);
 
-        skcipher_request_set_tfm(req, cipher);
+        skcipher_request_set_sync_tfm(req, cipher);
         skcipher_request_set_callback(req, 0, NULL, NULL);
         skcipher_request_set_crypt(req, sg, sg, len, iv);
 
@@ -735,7 +737,7 @@ gss_krb5_aes_encrypt(struct krb5_ctx *kctx, u32 offset,
         struct xdr_netobj hmac;
         u8 *cksumkey;
         u8 *ecptr;
-        struct crypto_skcipher *cipher, *aux_cipher;
+        struct crypto_sync_skcipher *cipher, *aux_cipher;
         int blocksize;
         struct page **save_pages;
         int nblocks, nbytes;
@@ -754,7 +756,7 @@ gss_krb5_aes_encrypt(struct krb5_ctx *kctx, u32 offset,
                 cksumkey = kctx->acceptor_integ;
                 usage = KG_USAGE_ACCEPTOR_SEAL;
         }
-        blocksize = crypto_skcipher_blocksize(cipher);
+        blocksize = crypto_sync_skcipher_blocksize(cipher);
 
         /* hide the gss token header and insert the confounder */
         offset += GSS_KRB5_TOK_HDR_LEN;
@@ -807,7 +809,7 @@ gss_krb5_aes_encrypt(struct krb5_ctx *kctx, u32 offset,
         memset(desc.iv, 0, sizeof(desc.iv));
 
         if (cbcbytes) {
-                SKCIPHER_REQUEST_ON_STACK(req, aux_cipher);
+                SYNC_SKCIPHER_REQUEST_ON_STACK(req, aux_cipher);
 
                 desc.pos = offset + GSS_KRB5_TOK_HDR_LEN;
                 desc.fragno = 0;
@@ -816,7 +818,7 @@ gss_krb5_aes_encrypt(struct krb5_ctx *kctx, u32 offset,
                 desc.outbuf = buf;
                 desc.req = req;
 
-                skcipher_request_set_tfm(req, aux_cipher);
+                skcipher_request_set_sync_tfm(req, aux_cipher);
                 skcipher_request_set_callback(req, 0, NULL, NULL);
 
                 sg_init_table(desc.infrags, 4);
@@ -855,7 +857,7 @@ gss_krb5_aes_decrypt(struct krb5_ctx *kctx, u32 offset, struct xdr_buf *buf,
         struct xdr_buf subbuf;
         u32 ret = 0;
         u8 *cksum_key;
-        struct crypto_skcipher *cipher, *aux_cipher;
+        struct crypto_sync_skcipher *cipher, *aux_cipher;
         struct xdr_netobj our_hmac_obj;
         u8 our_hmac[GSS_KRB5_MAX_CKSUM_LEN];
         u8 pkt_hmac[GSS_KRB5_MAX_CKSUM_LEN];
@@ -874,7 +876,7 @@ gss_krb5_aes_decrypt(struct krb5_ctx *kctx, u32 offset, struct xdr_buf *buf,
                 cksum_key = kctx->initiator_integ;
                 usage = KG_USAGE_INITIATOR_SEAL;
         }
-        blocksize = crypto_skcipher_blocksize(cipher);
+        blocksize = crypto_sync_skcipher_blocksize(cipher);
 
 
         /* create a segment skipping the header and leaving out the checksum */
@@ -891,13 +893,13 @@ gss_krb5_aes_decrypt(struct krb5_ctx *kctx, u32 offset, struct xdr_buf *buf,
         memset(desc.iv, 0, sizeof(desc.iv));
 
         if (cbcbytes) {
-                SKCIPHER_REQUEST_ON_STACK(req, aux_cipher);
+                SYNC_SKCIPHER_REQUEST_ON_STACK(req, aux_cipher);
 
                 desc.fragno = 0;
                 desc.fraglen = 0;
                 desc.req = req;
 
-                skcipher_request_set_tfm(req, aux_cipher);
+                skcipher_request_set_sync_tfm(req, aux_cipher);
                 skcipher_request_set_callback(req, 0, NULL, NULL);
 
                 sg_init_table(desc.frags, 4);
@@ -946,7 +948,8 @@ out_err:
  * Set the key of the given cipher.
  */
 int
-krb5_rc4_setup_seq_key(struct krb5_ctx *kctx, struct crypto_skcipher *cipher,
+krb5_rc4_setup_seq_key(struct krb5_ctx *kctx,
+                       struct crypto_sync_skcipher *cipher,
                        unsigned char *cksum)
 {
         struct crypto_shash *hmac;
@@ -994,7 +997,7 @@ krb5_rc4_setup_seq_key(struct krb5_ctx *kctx, struct crypto_skcipher *cipher,
         if (err)
                 goto out_err;
 
-        err = crypto_skcipher_setkey(cipher, Kseq, kctx->gk5e->keylength);
+        err = crypto_sync_skcipher_setkey(cipher, Kseq, kctx->gk5e->keylength);
         if (err)
                 goto out_err;
 
@@ -1012,7 +1015,8 @@ out_err:
  * Set the key of cipher kctx->enc.
  */
 int
-krb5_rc4_setup_enc_key(struct krb5_ctx *kctx, struct crypto_skcipher *cipher,
+krb5_rc4_setup_enc_key(struct krb5_ctx *kctx,
+                       struct crypto_sync_skcipher *cipher,
                        s32 seqnum)
 {
         struct crypto_shash *hmac;
@@ -1069,7 +1073,8 @@ krb5_rc4_setup_enc_key(struct krb5_ctx *kctx, struct crypto_skcipher *cipher,
         if (err)
                 goto out_err;
 
-        err = crypto_skcipher_setkey(cipher, Kcrypt, kctx->gk5e->keylength);
+        err = crypto_sync_skcipher_setkey(cipher, Kcrypt,
+                                          kctx->gk5e->keylength);
         if (err)
                 goto out_err;
 
diff --git a/net/sunrpc/auth_gss/gss_krb5_keys.c b/net/sunrpc/auth_gss/gss_krb5_keys.c
index f7fe2d2b851f..550fdf18d3b3 100644
--- a/net/sunrpc/auth_gss/gss_krb5_keys.c
+++ b/net/sunrpc/auth_gss/gss_krb5_keys.c
@@ -147,7 +147,7 @@ u32 krb5_derive_key(const struct gss_krb5_enctype *gk5e,
         size_t blocksize, keybytes, keylength, n;
         unsigned char *inblockdata, *outblockdata, *rawkey;
         struct xdr_netobj inblock, outblock;
-        struct crypto_skcipher *cipher;
+        struct crypto_sync_skcipher *cipher;
         u32 ret = EINVAL;
 
         blocksize = gk5e->blocksize;
@@ -157,11 +157,10 @@ u32 krb5_derive_key(const struct gss_krb5_enctype *gk5e,
         if ((inkey->len != keylength) || (outkey->len != keylength))
                 goto err_return;
 
-        cipher = crypto_alloc_skcipher(gk5e->encrypt_name, 0,
-                                       CRYPTO_ALG_ASYNC);
+        cipher = crypto_alloc_sync_skcipher(gk5e->encrypt_name, 0, 0);
         if (IS_ERR(cipher))
                 goto err_return;
-        if (crypto_skcipher_setkey(cipher, inkey->data, inkey->len))
+        if (crypto_sync_skcipher_setkey(cipher, inkey->data, inkey->len))
                 goto err_return;
 
         /* allocate and set up buffers */
@@ -238,7 +237,7 @@ err_free_in:
         memset(inblockdata, 0, blocksize);
         kfree(inblockdata);
 err_free_cipher:
-        crypto_free_skcipher(cipher);
+        crypto_free_sync_skcipher(cipher);
 err_return:
         return ret;
 }
diff --git a/net/sunrpc/auth_gss/gss_krb5_mech.c b/net/sunrpc/auth_gss/gss_krb5_mech.c
index 7bb2514aadd9..7f0424dfa8f6 100644
--- a/net/sunrpc/auth_gss/gss_krb5_mech.c
+++ b/net/sunrpc/auth_gss/gss_krb5_mech.c
@@ -218,7 +218,7 @@ simple_get_netobj(const void *p, const void *end, struct xdr_netobj *res)
 
 static inline const void *
 get_key(const void *p, const void *end,
-        struct krb5_ctx *ctx, struct crypto_skcipher **res)
+        struct krb5_ctx *ctx, struct crypto_sync_skcipher **res)
 {
         struct xdr_netobj       key;
         int                     alg;
@@ -246,15 +246,14 @@ get_key(const void *p, const void *end,
         if (IS_ERR(p))
                 goto out_err;
 
-        *res = crypto_alloc_skcipher(ctx->gk5e->encrypt_name, 0,
-                                                        CRYPTO_ALG_ASYNC);
+        *res = crypto_alloc_sync_skcipher(ctx->gk5e->encrypt_name, 0, 0);
         if (IS_ERR(*res)) {
                 printk(KERN_WARNING "gss_kerberos_mech: unable to initialize "
                         "crypto algorithm %s\n", ctx->gk5e->encrypt_name);
                 *res = NULL;
                 goto out_err_free_key;
         }
-        if (crypto_skcipher_setkey(*res, key.data, key.len)) {
+        if (crypto_sync_skcipher_setkey(*res, key.data, key.len)) {
                 printk(KERN_WARNING "gss_kerberos_mech: error setting key for "
                         "crypto algorithm %s\n", ctx->gk5e->encrypt_name);
                 goto out_err_free_tfm;
@@ -264,7 +263,7 @@ get_key(const void *p, const void *end,
         return p;
 
 out_err_free_tfm:
-        crypto_free_skcipher(*res);
+        crypto_free_sync_skcipher(*res);
 out_err_free_key:
         kfree(key.data);
         p = ERR_PTR(-EINVAL);
@@ -336,30 +335,30 @@ gss_import_v1_context(const void *p, const void *end, struct krb5_ctx *ctx)
         return 0;
 
 out_err_free_key2:
-        crypto_free_skcipher(ctx->seq);
+        crypto_free_sync_skcipher(ctx->seq);
 out_err_free_key1:
-        crypto_free_skcipher(ctx->enc);
+        crypto_free_sync_skcipher(ctx->enc);
 out_err_free_mech:
         kfree(ctx->mech_used.data);
 out_err:
         return PTR_ERR(p);
 }
 
-static struct crypto_skcipher *
+static struct crypto_sync_skcipher *
 context_v2_alloc_cipher(struct krb5_ctx *ctx, const char *cname, u8 *key)
 {
-        struct crypto_skcipher *cp;
+        struct crypto_sync_skcipher *cp;
 
-        cp = crypto_alloc_skcipher(cname, 0, CRYPTO_ALG_ASYNC);
+        cp = crypto_alloc_sync_skcipher(cname, 0, 0);
         if (IS_ERR(cp)) {
                 dprintk("gss_kerberos_mech: unable to initialize "
                         "crypto algorithm %s\n", cname);
                 return NULL;
         }
-        if (crypto_skcipher_setkey(cp, key, ctx->gk5e->keylength)) {
+        if (crypto_sync_skcipher_setkey(cp, key, ctx->gk5e->keylength)) {
                 dprintk("gss_kerberos_mech: error setting key for "
                         "crypto algorithm %s\n", cname);
-                crypto_free_skcipher(cp);
+                crypto_free_sync_skcipher(cp);
                 return NULL;
         }
         return cp;
@@ -413,9 +412,9 @@ context_derive_keys_des3(struct krb5_ctx *ctx, gfp_t gfp_mask)
         return 0;
 
 out_free_enc:
-        crypto_free_skcipher(ctx->enc);
+        crypto_free_sync_skcipher(ctx->enc);
 out_free_seq:
-        crypto_free_skcipher(ctx->seq);
+        crypto_free_sync_skcipher(ctx->seq);
 out_err:
         return -EINVAL;
 }
@@ -469,17 +468,15 @@ context_derive_keys_rc4(struct krb5_ctx *ctx)
         /*
          * allocate hash, and skciphers for data and seqnum encryption
          */
-        ctx->enc = crypto_alloc_skcipher(ctx->gk5e->encrypt_name, 0,
-                                         CRYPTO_ALG_ASYNC);
+        ctx->enc = crypto_alloc_sync_skcipher(ctx->gk5e->encrypt_name, 0, 0);
         if (IS_ERR(ctx->enc)) {
                 err = PTR_ERR(ctx->enc);
                 goto out_err_free_hmac;
         }
 
-        ctx->seq = crypto_alloc_skcipher(ctx->gk5e->encrypt_name, 0,
-                                         CRYPTO_ALG_ASYNC);
+        ctx->seq = crypto_alloc_sync_skcipher(ctx->gk5e->encrypt_name, 0, 0);
         if (IS_ERR(ctx->seq)) {
-                crypto_free_skcipher(ctx->enc);
+                crypto_free_sync_skcipher(ctx->enc);
                 err = PTR_ERR(ctx->seq);
                 goto out_err_free_hmac;
         }
@@ -591,7 +588,7 @@ context_derive_keys_new(struct krb5_ctx *ctx, gfp_t gfp_mask)
                         context_v2_alloc_cipher(ctx, "cbc(aes)",
                                                 ctx->acceptor_seal);
                 if (ctx->acceptor_enc_aux == NULL) {
-                        crypto_free_skcipher(ctx->initiator_enc_aux);
+                        crypto_free_sync_skcipher(ctx->initiator_enc_aux);
                         goto out_free_acceptor_enc;
                 }
         }
@@ -599,9 +596,9 @@ context_derive_keys_new(struct krb5_ctx *ctx, gfp_t gfp_mask)
         return 0;
 
 out_free_acceptor_enc:
-        crypto_free_skcipher(ctx->acceptor_enc);
+        crypto_free_sync_skcipher(ctx->acceptor_enc);
 out_free_initiator_enc:
-        crypto_free_skcipher(ctx->initiator_enc);
+        crypto_free_sync_skcipher(ctx->initiator_enc);
 out_err:
         return -EINVAL;
 }
@@ -713,12 +710,12 @@ static void
 gss_delete_sec_context_kerberos(void *internal_ctx) {
         struct krb5_ctx *kctx = internal_ctx;
 
-        crypto_free_skcipher(kctx->seq);
-        crypto_free_skcipher(kctx->enc);
-        crypto_free_skcipher(kctx->acceptor_enc);
-        crypto_free_skcipher(kctx->initiator_enc);
-        crypto_free_skcipher(kctx->acceptor_enc_aux);
-        crypto_free_skcipher(kctx->initiator_enc_aux);
+        crypto_free_sync_skcipher(kctx->seq);
+        crypto_free_sync_skcipher(kctx->enc);
+        crypto_free_sync_skcipher(kctx->acceptor_enc);
+        crypto_free_sync_skcipher(kctx->initiator_enc);
+        crypto_free_sync_skcipher(kctx->acceptor_enc_aux);
+        crypto_free_sync_skcipher(kctx->initiator_enc_aux);
         kfree(kctx->mech_used.data);
         kfree(kctx);
 }
diff --git a/net/sunrpc/auth_gss/gss_krb5_seqnum.c b/net/sunrpc/auth_gss/gss_krb5_seqnum.c
index c8b9082f4a9d..fb6656295204 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seqnum.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seqnum.c
@@ -43,13 +43,12 @@ static s32
 krb5_make_rc4_seq_num(struct krb5_ctx *kctx, int direction, s32 seqnum,
                       unsigned char *cksum, unsigned char *buf)
 {
-        struct crypto_skcipher *cipher;
+        struct crypto_sync_skcipher *cipher;
         unsigned char plain[8];
         s32 code;
 
         dprintk("RPC:       %s:\n", __func__);
-        cipher = crypto_alloc_skcipher(kctx->gk5e->encrypt_name, 0,
-                                       CRYPTO_ALG_ASYNC);
+        cipher = crypto_alloc_sync_skcipher(kctx->gk5e->encrypt_name, 0, 0);
         if (IS_ERR(cipher))
                 return PTR_ERR(cipher);
 
@@ -68,12 +67,12 @@ krb5_make_rc4_seq_num(struct krb5_ctx *kctx, int direction, s32 seqnum,
 
         code = krb5_encrypt(cipher, cksum, plain, buf, 8);
 out:
-        crypto_free_skcipher(cipher);
+        crypto_free_sync_skcipher(cipher);
         return code;
 }
 s32
 krb5_make_seq_num(struct krb5_ctx *kctx,
-                struct crypto_skcipher *key,
+                struct crypto_sync_skcipher *key,
                 int direction,
                 u32 seqnum,
                 unsigned char *cksum, unsigned char *buf)
@@ -101,13 +100,12 @@ static s32
 krb5_get_rc4_seq_num(struct krb5_ctx *kctx, unsigned char *cksum,
                      unsigned char *buf, int *direction, s32 *seqnum)
 {
-        struct crypto_skcipher *cipher;
+        struct crypto_sync_skcipher *cipher;
         unsigned char plain[8];
         s32 code;
 
         dprintk("RPC:       %s:\n", __func__);
-        cipher = crypto_alloc_skcipher(kctx->gk5e->encrypt_name, 0,
-                                       CRYPTO_ALG_ASYNC);
+        cipher = crypto_alloc_sync_skcipher(kctx->gk5e->encrypt_name, 0, 0);
         if (IS_ERR(cipher))
                 return PTR_ERR(cipher);
 
@@ -130,7 +128,7 @@ krb5_get_rc4_seq_num(struct krb5_ctx *kctx, unsigned char *cksum,
         *seqnum = ((plain[0] << 24) | (plain[1] << 16) |
                                         (plain[2] << 8) | (plain[3]));
 out:
-        crypto_free_skcipher(cipher);
+        crypto_free_sync_skcipher(cipher);
         return code;
 }
 
@@ -142,7 +140,7 @@ krb5_get_seq_num(struct krb5_ctx *kctx,
 {
         s32 code;
         unsigned char plain[8];
-        struct crypto_skcipher *key = kctx->seq;
+        struct crypto_sync_skcipher *key = kctx->seq;
 
         dprintk("RPC:       krb5_get_seq_num:\n");
 
diff --git a/net/sunrpc/auth_gss/gss_krb5_wrap.c b/net/sunrpc/auth_gss/gss_krb5_wrap.c
index 39a2e672900b..3d975a4013d2 100644
--- a/net/sunrpc/auth_gss/gss_krb5_wrap.c
+++ b/net/sunrpc/auth_gss/gss_krb5_wrap.c
@@ -174,7 +174,7 @@ gss_wrap_kerberos_v1(struct krb5_ctx *kctx, int offset,
 
         now = get_seconds();
 
-        blocksize = crypto_skcipher_blocksize(kctx->enc);
+        blocksize = crypto_sync_skcipher_blocksize(kctx->enc);
         gss_krb5_add_padding(buf, offset, blocksize);
         BUG_ON((buf->len - offset) % blocksize);
         plainlen = conflen + buf->len - offset;
@@ -239,10 +239,10 @@ gss_wrap_kerberos_v1(struct krb5_ctx *kctx, int offset,
                 return GSS_S_FAILURE;
 
         if (kctx->enctype == ENCTYPE_ARCFOUR_HMAC) {
-                struct crypto_skcipher *cipher;
+                struct crypto_sync_skcipher *cipher;
                 int err;
-                cipher = crypto_alloc_skcipher(kctx->gk5e->encrypt_name, 0,
-                                               CRYPTO_ALG_ASYNC);
+                cipher = crypto_alloc_sync_skcipher(kctx->gk5e->encrypt_name,
+                                                    0, 0);
                 if (IS_ERR(cipher))
                         return GSS_S_FAILURE;
 
@@ -250,7 +250,7 @@ gss_wrap_kerberos_v1(struct krb5_ctx *kctx, int offset,
 
                 err = gss_encrypt_xdr_buf(cipher, buf,
                                           offset + headlen - conflen, pages);
-                crypto_free_skcipher(cipher);
+                crypto_free_sync_skcipher(cipher);
                 if (err)
                         return GSS_S_FAILURE;
         } else {
@@ -327,18 +327,18 @@ gss_unwrap_kerberos_v1(struct krb5_ctx *kctx, int offset, struct xdr_buf *buf)
                 return GSS_S_BAD_SIG;
 
         if (kctx->enctype == ENCTYPE_ARCFOUR_HMAC) {
-                struct crypto_skcipher *cipher;
+                struct crypto_sync_skcipher *cipher;
                 int err;
 
-                cipher = crypto_alloc_skcipher(kctx->gk5e->encrypt_name, 0,
-                                               CRYPTO_ALG_ASYNC);
+                cipher = crypto_alloc_sync_skcipher(kctx->gk5e->encrypt_name,
+                                                    0, 0);
                 if (IS_ERR(cipher))
                         return GSS_S_FAILURE;
 
                 krb5_rc4_setup_enc_key(kctx, cipher, seqnum);
 
                 err = gss_decrypt_xdr_buf(cipher, buf, crypt_offset);
-                crypto_free_skcipher(cipher);
+                crypto_free_sync_skcipher(cipher);
                 if (err)
                         return GSS_S_DEFECTIVE_TOKEN;
         } else {
@@ -371,7 +371,7 @@ gss_unwrap_kerberos_v1(struct krb5_ctx *kctx, int offset, struct xdr_buf *buf)
         /* Copy the data back to the right position.  XXX: Would probably be
          * better to copy and encrypt at the same time. */
 
-        blocksize = crypto_skcipher_blocksize(kctx->enc);
+        blocksize = crypto_sync_skcipher_blocksize(kctx->enc);
         data_start = ptr + (GSS_KRB5_TOK_HDR_LEN + kctx->gk5e->cksumlength) +
                                         conflen;
         orig_start = buf->head[0].iov_base + offset;