Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux

13 files changed, 148 insertions, 139 deletions

diff --git a/net/sctp/associola.c b/net/sctp/associola.c
index 2bf8ec92dde4..a19b3e607703 100644
--- a/net/sctp/associola.c
+++ b/net/sctp/associola.c
@@ -1263,7 +1263,7 @@ static struct sctp_transport *sctp_trans_elect_best(struct sctp_transport *curr,
         if (score_curr > score_best)
                 return curr;
         else if (score_curr == score_best)
-                return sctp_trans_elect_tie(curr, best);
+                return sctp_trans_elect_tie(best, curr);
         else
                 return best;
 }
@@ -1493,7 +1493,7 @@ void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned int len)
 
                 asoc->peer.sack_needed = 0;
 
-                sctp_outq_tail(&asoc->outqueue, sack);
+                sctp_outq_tail(&asoc->outqueue, sack, GFP_ATOMIC);
 
                 /* Stop the SACK timer.  */
                 timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
diff --git a/net/sctp/auth.c b/net/sctp/auth.c
index 1543e39f47c3..912eb1685a5d 100644
--- a/net/sctp/auth.c
+++ b/net/sctp/auth.c
@@ -27,9 +27,9 @@
  *   Vlad Yasevich     <vladislav.yasevich@hp.com>
  */
 
+#include <crypto/hash.h>
 #include <linux/slab.h>
 #include <linux/types.h>
-#include <linux/crypto.h>
 #include <linux/scatterlist.h>
 #include <net/sctp/sctp.h>
 #include <net/sctp/auth.h>
@@ -448,7 +448,7 @@ struct sctp_shared_key *sctp_auth_get_shkey(
  */
 int sctp_auth_init_hmacs(struct sctp_endpoint *ep, gfp_t gfp)
 {
-        struct crypto_hash *tfm = NULL;
+        struct crypto_shash *tfm = NULL;
         __u16   id;
 
         /* If AUTH extension is disabled, we are done */
@@ -462,9 +462,8 @@ int sctp_auth_init_hmacs(struct sctp_endpoint *ep, gfp_t gfp)
                 return 0;
 
         /* Allocated the array of pointers to transorms */
-        ep->auth_hmacs = kzalloc(
-                            sizeof(struct crypto_hash *) * SCTP_AUTH_NUM_HMACS,
-                            gfp);
+        ep->auth_hmacs = kzalloc(sizeof(struct crypto_shash *) *
+                                 SCTP_AUTH_NUM_HMACS, gfp);
         if (!ep->auth_hmacs)
                 return -ENOMEM;
 
@@ -483,8 +482,7 @@ int sctp_auth_init_hmacs(struct sctp_endpoint *ep, gfp_t gfp)
                         continue;
 
                 /* Allocate the ID */
-                tfm = crypto_alloc_hash(sctp_hmac_list[id].hmac_name, 0,
-                                        CRYPTO_ALG_ASYNC);
+                tfm = crypto_alloc_shash(sctp_hmac_list[id].hmac_name, 0, 0);
                 if (IS_ERR(tfm))
                         goto out_err;
 
@@ -500,7 +498,7 @@ out_err:
 }
 
 /* Destroy the hmac tfm array */
-void sctp_auth_destroy_hmacs(struct crypto_hash *auth_hmacs[])
+void sctp_auth_destroy_hmacs(struct crypto_shash *auth_hmacs[])
 {
         int i;
 
@@ -508,8 +506,7 @@ void sctp_auth_destroy_hmacs(struct crypto_hash *auth_hmacs[])
                 return;
 
         for (i = 0; i < SCTP_AUTH_NUM_HMACS; i++) {
-                if (auth_hmacs[i])
-                        crypto_free_hash(auth_hmacs[i]);
+                crypto_free_shash(auth_hmacs[i]);
         }
         kfree(auth_hmacs);
 }
@@ -709,8 +706,7 @@ void sctp_auth_calculate_hmac(const struct sctp_association *asoc,
                               struct sctp_auth_chunk *auth,
                               gfp_t gfp)
 {
-        struct scatterlist sg;
-        struct hash_desc desc;
+        struct crypto_shash *tfm;
         struct sctp_auth_bytes *asoc_key;
         __u16 key_id, hmac_id;
         __u8 *digest;
@@ -742,16 +738,22 @@ void sctp_auth_calculate_hmac(const struct sctp_association *asoc,
 
         /* set up scatter list */
         end = skb_tail_pointer(skb);
-        sg_init_one(&sg, auth, end - (unsigned char *)auth);
 
-        desc.tfm = asoc->ep->auth_hmacs[hmac_id];
-        desc.flags = 0;
+        tfm = asoc->ep->auth_hmacs[hmac_id];
 
         digest = auth->auth_hdr.hmac;
-        if (crypto_hash_setkey(desc.tfm, &asoc_key->data[0], asoc_key->len))
+        if (crypto_shash_setkey(tfm, &asoc_key->data[0], asoc_key->len))
                 goto free;
 
-        crypto_hash_digest(&desc, &sg, sg.length, digest);
+        {
+                SHASH_DESC_ON_STACK(desc, tfm);
+
+                desc->tfm = tfm;
+                desc->flags = 0;
+                crypto_shash_digest(desc, (u8 *)auth,
+                                    end - (unsigned char *)auth, digest);
+                shash_desc_zero(desc);
+        }
 
 free:
         if (free_key)
diff --git a/net/sctp/chunk.c b/net/sctp/chunk.c
index a3380917f197..958ef5f33f4b 100644
--- a/net/sctp/chunk.c
+++ b/net/sctp/chunk.c
@@ -70,19 +70,6 @@ static struct sctp_datamsg *sctp_datamsg_new(gfp_t gfp)
         return msg;
 }
 
-void sctp_datamsg_free(struct sctp_datamsg *msg)
-{
-        struct sctp_chunk *chunk;
-
-        /* This doesn't have to be a _safe vairant because
-         * sctp_chunk_free() only drops the refs.
-         */
-        list_for_each_entry(chunk, &msg->chunks, frag_list)
-                sctp_chunk_free(chunk);
-
-        sctp_datamsg_put(msg);
-}
-
 /* Final destructruction of datamsg memory. */
 static void sctp_datamsg_destroy(struct sctp_datamsg *msg)
 {
@@ -273,7 +260,8 @@ struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc,
                                 frag |= SCTP_DATA_SACK_IMM;
                 }
 
-                chunk = sctp_make_datafrag_empty(asoc, sinfo, len, frag, 0);
+                chunk = sctp_make_datafrag_empty(asoc, sinfo, len, frag,
+                                                 0, GFP_KERNEL);
 
                 if (!chunk) {
                         err = -ENOMEM;
@@ -309,7 +297,8 @@ struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc,
                     (sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY))
                         frag |= SCTP_DATA_SACK_IMM;
 
-                chunk = sctp_make_datafrag_empty(asoc, sinfo, over, frag, 0);
+                chunk = sctp_make_datafrag_empty(asoc, sinfo, over, frag,
+                                                 0, GFP_KERNEL);
 
                 if (!chunk) {
                         err = -ENOMEM;
diff --git a/net/sctp/endpointola.c b/net/sctp/endpointola.c
index 2522a6175291..9d494e35e7f9 100644
--- a/net/sctp/endpointola.c
+++ b/net/sctp/endpointola.c
@@ -42,7 +42,6 @@
 #include <linux/slab.h>
 #include <linux/in.h>
 #include <linux/random.h>       /* get_random_bytes() */
-#include <linux/crypto.h>
 #include <net/sock.h>
 #include <net/ipv6.h>
 #include <net/sctp/sctp.h>
diff --git a/net/sctp/input.c b/net/sctp/input.c
index 49d2cc751386..db76f1ab4ac2 100644
--- a/net/sctp/input.c
+++ b/net/sctp/input.c
@@ -221,7 +221,7 @@ int sctp_rcv(struct sk_buff *skb)
                 goto discard_release;
 
         /* Create an SCTP packet structure. */
-        chunk = sctp_chunkify(skb, asoc, sk);
+        chunk = sctp_chunkify(skb, asoc, sk, GFP_ATOMIC);
         if (!chunk)
                 goto discard_release;
         SCTP_INPUT_CB(skb)->chunk = chunk;
@@ -937,7 +937,6 @@ static struct sctp_association *__sctp_lookup_association(
         struct sctp_transport *t;
         struct sctp_association *asoc = NULL;
 
-        rcu_read_lock();
         t = sctp_addrs_lookup_transport(net, local, peer);
         if (!t || !sctp_transport_hold(t))
                 goto out;
@@ -949,7 +948,6 @@ static struct sctp_association *__sctp_lookup_association(
         sctp_transport_put(t);
 
 out:
-        rcu_read_unlock();
         return asoc;
 }
 
@@ -962,7 +960,9 @@ struct sctp_association *sctp_lookup_association(struct net *net,
 {
         struct sctp_association *asoc;
 
+        rcu_read_lock();
         asoc = __sctp_lookup_association(net, laddr, paddr, transportp);
+        rcu_read_unlock();
 
         return asoc;
 }
diff --git a/net/sctp/output.c b/net/sctp/output.c
index 9d610eddd19e..736c004abfbc 100644
--- a/net/sctp/output.c
+++ b/net/sctp/output.c
@@ -153,7 +153,7 @@ void sctp_packet_free(struct sctp_packet *packet)
  */
 sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *packet,
                                        struct sctp_chunk *chunk,
-                                       int one_packet)
+                                       int one_packet, gfp_t gfp)
 {
         sctp_xmit_t retval;
         int error = 0;
@@ -163,7 +163,7 @@ sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *packet,
         switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) {
         case SCTP_XMIT_PMTU_FULL:
                 if (!packet->has_cookie_echo) {
-                        error = sctp_packet_transmit(packet);
+                        error = sctp_packet_transmit(packet, gfp);
                         if (error < 0)
                                 chunk->skb->sk->sk_err = -error;
 
@@ -376,7 +376,7 @@ static void sctp_packet_set_owner_w(struct sk_buff *skb, struct sock *sk)
  *
  * The return value is a normal kernel error return value.
  */
-int sctp_packet_transmit(struct sctp_packet *packet)
+int sctp_packet_transmit(struct sctp_packet *packet, gfp_t gfp)
 {
         struct sctp_transport *tp = packet->transport;
         struct sctp_association *asoc = tp->asoc;
diff --git a/net/sctp/outqueue.c b/net/sctp/outqueue.c
index c0380cfb16ae..f03541d0f12d 100644
--- a/net/sctp/outqueue.c
+++ b/net/sctp/outqueue.c
@@ -68,7 +68,7 @@ static void sctp_mark_missing(struct sctp_outq *q,
 
 static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 sack_ctsn);
 
-static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout);
+static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp);
 
 /* Add data to the front of the queue. */
 static inline void sctp_outq_head_data(struct sctp_outq *q,
@@ -285,7 +285,7 @@ void sctp_outq_free(struct sctp_outq *q)
 }
 
 /* Put a new chunk in an sctp_outq.  */
-int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk)
+int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk, gfp_t gfp)
 {
         struct net *net = sock_net(q->asoc->base.sk);
         int error = 0;
@@ -341,7 +341,7 @@ int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk)
                 return error;
 
         if (!q->cork)
-                error = sctp_outq_flush(q, 0);
+                error = sctp_outq_flush(q, 0, gfp);
 
         return error;
 }
@@ -510,7 +510,7 @@ void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
          * will be flushed at the end.
          */
         if (reason != SCTP_RTXR_FAST_RTX)
-                error = sctp_outq_flush(q, /* rtx_timeout */ 1);
+                error = sctp_outq_flush(q, /* rtx_timeout */ 1, GFP_ATOMIC);
 
         if (error)
                 q->asoc->base.sk->sk_err = -error;
@@ -601,12 +601,12 @@ redo:
                                  * control chunks are already freed so there
                                  * is nothing we can do.
                                  */
-                                sctp_packet_transmit(pkt);
+                                sctp_packet_transmit(pkt, GFP_ATOMIC);
                                 goto redo;
                         }
 
                         /* Send this packet.  */
-                        error = sctp_packet_transmit(pkt);
+                        error = sctp_packet_transmit(pkt, GFP_ATOMIC);
 
                         /* If we are retransmitting, we should only
                          * send a single packet.
@@ -622,7 +622,7 @@ redo:
 
                 case SCTP_XMIT_RWND_FULL:
                         /* Send this packet. */
-                        error = sctp_packet_transmit(pkt);
+                        error = sctp_packet_transmit(pkt, GFP_ATOMIC);
 
                         /* Stop sending DATA as there is no more room
                          * at the receiver.
@@ -632,7 +632,7 @@ redo:
 
                 case SCTP_XMIT_DELAY:
                         /* Send this packet. */
-                        error = sctp_packet_transmit(pkt);
+                        error = sctp_packet_transmit(pkt, GFP_ATOMIC);
 
                         /* Stop sending DATA because of nagle delay. */
                         done = 1;
@@ -685,12 +685,12 @@ redo:
 }
 
 /* Cork the outqueue so queued chunks are really queued. */
-int sctp_outq_uncork(struct sctp_outq *q)
+int sctp_outq_uncork(struct sctp_outq *q, gfp_t gfp)
 {
         if (q->cork)
                 q->cork = 0;
 
-        return sctp_outq_flush(q, 0);
+        return sctp_outq_flush(q, 0, gfp);
 }
 
 
@@ -703,7 +703,7 @@ int sctp_outq_uncork(struct sctp_outq *q)
  * locking concerns must be made.  Today we use the sock lock to protect
  * this function.
  */
-static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
+static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp)
 {
         struct sctp_packet *packet;
         struct sctp_packet singleton;
@@ -825,7 +825,7 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                         sctp_packet_init(&singleton, transport, sport, dport);
                         sctp_packet_config(&singleton, vtag, 0);
                         sctp_packet_append_chunk(&singleton, chunk);
-                        error = sctp_packet_transmit(&singleton);
+                        error = sctp_packet_transmit(&singleton, gfp);
                         if (error < 0)
                                 return error;
                         break;
@@ -856,7 +856,7 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                 case SCTP_CID_ASCONF:
                 case SCTP_CID_FWD_TSN:
                         status = sctp_packet_transmit_chunk(packet, chunk,
-                                                            one_packet);
+                                                            one_packet, gfp);
                         if (status  != SCTP_XMIT_OK) {
                                 /* put the chunk back */
                                 list_add(&chunk->list, &q->control_chunk_list);
@@ -1011,7 +1011,7 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                                  atomic_read(&chunk->skb->users) : -1);
 
                         /* Add the chunk to the packet.  */
-                        status = sctp_packet_transmit_chunk(packet, chunk, 0);
+                        status = sctp_packet_transmit_chunk(packet, chunk, 0, gfp);
 
                         switch (status) {
                         case SCTP_XMIT_PMTU_FULL:
@@ -1088,7 +1088,7 @@ sctp_flush_out:
                                                       send_ready);
                 packet = &t->packet;
                 if (!sctp_packet_empty(packet))
-                        error = sctp_packet_transmit(packet);
+                        error = sctp_packet_transmit(packet, gfp);
 
                 /* Clear the burst limited state, if any */
                 sctp_transport_burst_reset(t);
diff --git a/net/sctp/probe.c b/net/sctp/probe.c
index 5e68b94ee640..6cc2152e0740 100644
--- a/net/sctp/probe.c
+++ b/net/sctp/probe.c
@@ -65,7 +65,7 @@ static struct {
         struct kfifo      fifo;
         spinlock_t        lock;
         wait_queue_head_t wait;
-        struct timespec   tstart;
+        struct timespec64 tstart;
 } sctpw;
 
 static __printf(1, 2) void printl(const char *fmt, ...)
@@ -85,7 +85,7 @@ static __printf(1, 2) void printl(const char *fmt, ...)
 static int sctpprobe_open(struct inode *inode, struct file *file)
 {
         kfifo_reset(&sctpw.fifo);
-        getnstimeofday(&sctpw.tstart);
+        ktime_get_ts64(&sctpw.tstart);
 
         return 0;
 }
@@ -138,7 +138,7 @@ static sctp_disposition_t jsctp_sf_eat_sack(struct net *net,
         struct sk_buff *skb = chunk->skb;
         struct sctp_transport *sp;
         static __u32 lcwnd = 0;
-        struct timespec now;
+        struct timespec64 now;
 
         sp = asoc->peer.primary_path;
 
@@ -149,8 +149,8 @@ static sctp_disposition_t jsctp_sf_eat_sack(struct net *net,
             (full || sp->cwnd != lcwnd)) {
                 lcwnd = sp->cwnd;
 
-                getnstimeofday(&now);
-                now = timespec_sub(now, sctpw.tstart);
+                ktime_get_ts64(&now);
+                now = timespec64_sub(now, sctpw.tstart);
 
                 printl("%lu.%06lu ", (unsigned long) now.tv_sec,
                        (unsigned long) now.tv_nsec / NSEC_PER_USEC);
diff --git a/net/sctp/proc.c b/net/sctp/proc.c
index 963dffcc2618..5cfac8d5d3b3 100644
--- a/net/sctp/proc.c
+++ b/net/sctp/proc.c
@@ -161,7 +161,6 @@ static void sctp_seq_dump_remote_addrs(struct seq_file *seq, struct sctp_associa
         struct sctp_af *af;
 
         primary = &assoc->peer.primary_addr;
-        rcu_read_lock();
         list_for_each_entry_rcu(transport, &assoc->peer.transport_addr_list,
                         transports) {
                 addr = &transport->ipaddr;
@@ -172,7 +171,6 @@ static void sctp_seq_dump_remote_addrs(struct seq_file *seq, struct sctp_associa
                 }
                 af->seq_dump_addr(seq, addr);
         }
-        rcu_read_unlock();
 }
 
 static void *sctp_eps_seq_start(struct seq_file *seq, loff_t *pos)
diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c
index 7fe971e30ad6..7f0bf798205b 100644
--- a/net/sctp/sm_make_chunk.c
+++ b/net/sctp/sm_make_chunk.c
@@ -45,6 +45,7 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
+#include <crypto/hash.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/ip.h>
@@ -52,7 +53,6 @@
 #include <linux/net.h>
 #include <linux/inet.h>
 #include <linux/scatterlist.h>
-#include <linux/crypto.h>
 #include <linux/slab.h>
 #include <net/sock.h>
 
@@ -62,11 +62,13 @@
 #include <net/sctp/sm.h>
 
 static struct sctp_chunk *sctp_make_control(const struct sctp_association *asoc,
-                                            __u8 type, __u8 flags, int paylen);
+                                            __u8 type, __u8 flags, int paylen,
+                                            gfp_t gfp);
 static struct sctp_chunk *sctp_make_data(const struct sctp_association *asoc,
-                                         __u8 flags, int paylen);
+                                         __u8 flags, int paylen, gfp_t gfp);
 static struct sctp_chunk *_sctp_make_chunk(const struct sctp_association *asoc,
-                                           __u8 type, __u8 flags, int paylen);
+                                           __u8 type, __u8 flags, int paylen,
+                                           gfp_t gfp);
 static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
                                         const struct sctp_association *asoc,
                                         const struct sctp_chunk *init_chunk,
@@ -318,7 +320,7 @@ struct sctp_chunk *sctp_make_init(const struct sctp_association *asoc,
          * PLEASE DO NOT FIXME [This version does not support Host Name.]
          */
 
-        retval = sctp_make_control(asoc, SCTP_CID_INIT, 0, chunksize);
+        retval = sctp_make_control(asoc, SCTP_CID_INIT, 0, chunksize, gfp);
         if (!retval)
                 goto nodata;
 
@@ -465,7 +467,7 @@ struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *asoc,
                                         num_ext);
 
         /* Now allocate and fill out the chunk.  */
-        retval = sctp_make_control(asoc, SCTP_CID_INIT_ACK, 0, chunksize);
+        retval = sctp_make_control(asoc, SCTP_CID_INIT_ACK, 0, chunksize, gfp);
         if (!retval)
                 goto nomem_chunk;
 
@@ -570,7 +572,8 @@ struct sctp_chunk *sctp_make_cookie_echo(const struct sctp_association *asoc,
         cookie_len = asoc->peer.cookie_len;
 
         /* Build a cookie echo chunk.  */
-        retval = sctp_make_control(asoc, SCTP_CID_COOKIE_ECHO, 0, cookie_len);
+        retval = sctp_make_control(asoc, SCTP_CID_COOKIE_ECHO, 0,
+                                   cookie_len, GFP_ATOMIC);
         if (!retval)
                 goto nodata;
         retval->subh.cookie_hdr =
@@ -615,7 +618,7 @@ struct sctp_chunk *sctp_make_cookie_ack(const struct sctp_association *asoc,
 {
         struct sctp_chunk *retval;
 
-        retval = sctp_make_control(asoc, SCTP_CID_COOKIE_ACK, 0, 0);
+        retval = sctp_make_control(asoc, SCTP_CID_COOKIE_ACK, 0, 0, GFP_ATOMIC);
 
         /* RFC 2960 6.4 Multi-homed SCTP Endpoints
          *
@@ -664,7 +667,7 @@ struct sctp_chunk *sctp_make_cwr(const struct sctp_association *asoc,
 
         cwr.lowest_tsn = htonl(lowest_tsn);
         retval = sctp_make_control(asoc, SCTP_CID_ECN_CWR, 0,
-                                   sizeof(sctp_cwrhdr_t));
+                                   sizeof(sctp_cwrhdr_t), GFP_ATOMIC);
 
         if (!retval)
                 goto nodata;
@@ -698,7 +701,7 @@ struct sctp_chunk *sctp_make_ecne(const struct sctp_association *asoc,
 
         ecne.lowest_tsn = htonl(lowest_tsn);
         retval = sctp_make_control(asoc, SCTP_CID_ECN_ECNE, 0,
-                                   sizeof(sctp_ecnehdr_t));
+                                   sizeof(sctp_ecnehdr_t), GFP_ATOMIC);
         if (!retval)
                 goto nodata;
         retval->subh.ecne_hdr =
@@ -713,7 +716,8 @@ nodata:
  */
 struct sctp_chunk *sctp_make_datafrag_empty(struct sctp_association *asoc,
                                        const struct sctp_sndrcvinfo *sinfo,
-                                       int data_len, __u8 flags, __u16 ssn)
+                                       int data_len, __u8 flags, __u16 ssn,
+                                       gfp_t gfp)
 {
         struct sctp_chunk *retval;
         struct sctp_datahdr dp;
@@ -734,7 +738,7 @@ struct sctp_chunk *sctp_make_datafrag_empty(struct sctp_association *asoc,
                 dp.ssn = htons(ssn);
 
         chunk_len = sizeof(dp) + data_len;
-        retval = sctp_make_data(asoc, flags, chunk_len);
+        retval = sctp_make_data(asoc, flags, chunk_len, gfp);
         if (!retval)
                 goto nodata;
 
@@ -781,7 +785,7 @@ struct sctp_chunk *sctp_make_sack(const struct sctp_association *asoc)
                 + sizeof(__u32) * num_dup_tsns;
 
         /* Create the chunk.  */
-        retval = sctp_make_control(asoc, SCTP_CID_SACK, 0, len);
+        retval = sctp_make_control(asoc, SCTP_CID_SACK, 0, len, GFP_ATOMIC);
         if (!retval)
                 goto nodata;
 
@@ -861,7 +865,7 @@ struct sctp_chunk *sctp_make_shutdown(const struct sctp_association *asoc,
         shut.cum_tsn_ack = htonl(ctsn);
 
         retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN, 0,
-                                   sizeof(sctp_shutdownhdr_t));
+                                   sizeof(sctp_shutdownhdr_t), GFP_ATOMIC);
         if (!retval)
                 goto nodata;
 
@@ -879,7 +883,8 @@ struct sctp_chunk *sctp_make_shutdown_ack(const struct sctp_association *asoc,
 {
         struct sctp_chunk *retval;
 
-        retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN_ACK, 0, 0);
+        retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN_ACK, 0, 0,
+                                   GFP_ATOMIC);
 
         /* RFC 2960 6.4 Multi-homed SCTP Endpoints
          *
@@ -908,7 +913,8 @@ struct sctp_chunk *sctp_make_shutdown_complete(
          */
         flags |= asoc ? 0 : SCTP_CHUNK_FLAG_T;
 
-        retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN_COMPLETE, flags, 0);
+        retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN_COMPLETE, flags,
+                                   0, GFP_ATOMIC);
 
         /* RFC 2960 6.4 Multi-homed SCTP Endpoints
          *
@@ -947,7 +953,8 @@ struct sctp_chunk *sctp_make_abort(const struct sctp_association *asoc,
                         flags = SCTP_CHUNK_FLAG_T;
         }
 
-        retval = sctp_make_control(asoc, SCTP_CID_ABORT, flags, hint);
+        retval = sctp_make_control(asoc, SCTP_CID_ABORT, flags, hint,
+                                   GFP_ATOMIC);
 
         /* RFC 2960 6.4 Multi-homed SCTP Endpoints
          *
@@ -1139,7 +1146,8 @@ struct sctp_chunk *sctp_make_heartbeat(const struct sctp_association *asoc,
         struct sctp_chunk *retval;
         sctp_sender_hb_info_t hbinfo;
 
-        retval = sctp_make_control(asoc, SCTP_CID_HEARTBEAT, 0, sizeof(hbinfo));
+        retval = sctp_make_control(asoc, SCTP_CID_HEARTBEAT, 0,
+                                   sizeof(hbinfo), GFP_ATOMIC);
 
         if (!retval)
                 goto nodata;
@@ -1167,7 +1175,8 @@ struct sctp_chunk *sctp_make_heartbeat_ack(const struct sctp_association *asoc,
 {
         struct sctp_chunk *retval;
 
-        retval  = sctp_make_control(asoc, SCTP_CID_HEARTBEAT_ACK, 0, paylen);
+        retval  = sctp_make_control(asoc, SCTP_CID_HEARTBEAT_ACK, 0, paylen,
+                                    GFP_ATOMIC);
         if (!retval)
                 goto nodata;
 
@@ -1200,7 +1209,7 @@ static struct sctp_chunk *sctp_make_op_error_space(
         struct sctp_chunk *retval;
 
         retval = sctp_make_control(asoc, SCTP_CID_ERROR, 0,
-                                   sizeof(sctp_errhdr_t) + size);
+                                   sizeof(sctp_errhdr_t) + size, GFP_ATOMIC);
         if (!retval)
                 goto nodata;
 
@@ -1271,7 +1280,8 @@ struct sctp_chunk *sctp_make_auth(const struct sctp_association *asoc)
                 return NULL;
 
         retval = sctp_make_control(asoc, SCTP_CID_AUTH, 0,
-                        hmac_desc->hmac_len + sizeof(sctp_authhdr_t));
+                        hmac_desc->hmac_len + sizeof(sctp_authhdr_t),
+                        GFP_ATOMIC);
         if (!retval)
                 return NULL;
 
@@ -1309,11 +1319,11 @@ struct sctp_chunk *sctp_make_auth(const struct sctp_association *asoc)
  */
 struct sctp_chunk *sctp_chunkify(struct sk_buff *skb,
                             const struct sctp_association *asoc,
-                            struct sock *sk)
+                            struct sock *sk, gfp_t gfp)
 {
         struct sctp_chunk *retval;
 
-        retval = kmem_cache_zalloc(sctp_chunk_cachep, GFP_ATOMIC);
+        retval = kmem_cache_zalloc(sctp_chunk_cachep, gfp);
 
         if (!retval)
                 goto nodata;
@@ -1361,7 +1371,8 @@ const union sctp_addr *sctp_source(const struct sctp_chunk *chunk)
  * arguments, reserving enough space for a 'paylen' byte payload.
  */
 static struct sctp_chunk *_sctp_make_chunk(const struct sctp_association *asoc,
-                                            __u8 type, __u8 flags, int paylen)
+                                            __u8 type, __u8 flags, int paylen,
+                                            gfp_t gfp)
 {
         struct sctp_chunk *retval;
         sctp_chunkhdr_t *chunk_hdr;
@@ -1369,8 +1380,7 @@ static struct sctp_chunk *_sctp_make_chunk(const struct sctp_association *asoc,
         struct sock *sk;
 
         /* No need to allocate LL here, as this is only a chunk. */
-        skb = alloc_skb(WORD_ROUND(sizeof(sctp_chunkhdr_t) + paylen),
-                        GFP_ATOMIC);
+        skb = alloc_skb(WORD_ROUND(sizeof(sctp_chunkhdr_t) + paylen), gfp);
         if (!skb)
                 goto nodata;
 
@@ -1381,7 +1391,7 @@ static struct sctp_chunk *_sctp_make_chunk(const struct sctp_association *asoc,
         chunk_hdr->length = htons(sizeof(sctp_chunkhdr_t));
 
         sk = asoc ? asoc->base.sk : NULL;
-        retval = sctp_chunkify(skb, asoc, sk);
+        retval = sctp_chunkify(skb, asoc, sk, gfp);
         if (!retval) {
                 kfree_skb(skb);
                 goto nodata;
@@ -1400,16 +1410,18 @@ nodata:
 }
 
 static struct sctp_chunk *sctp_make_data(const struct sctp_association *asoc,
-                                         __u8 flags, int paylen)
+                                         __u8 flags, int paylen, gfp_t gfp)
 {
-        return _sctp_make_chunk(asoc, SCTP_CID_DATA, flags, paylen);
+        return _sctp_make_chunk(asoc, SCTP_CID_DATA, flags, paylen, gfp);
 }
 
 static struct sctp_chunk *sctp_make_control(const struct sctp_association *asoc,
-                                            __u8 type, __u8 flags, int paylen)
+                                            __u8 type, __u8 flags, int paylen,
+                                            gfp_t gfp)
 {
-        struct sctp_chunk *chunk = _sctp_make_chunk(asoc, type, flags, paylen);
+        struct sctp_chunk *chunk;
 
+        chunk = _sctp_make_chunk(asoc, type, flags, paylen, gfp);
         if (chunk)
                 sctp_control_set_owner_w(chunk);
 
@@ -1606,7 +1618,6 @@ static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
 {
         sctp_cookie_param_t *retval;
         struct sctp_signed_cookie *cookie;
-        struct scatterlist sg;
         int headersize, bodysize;
 
         /* Header size is static data prior to the actual cookie, including
@@ -1663,16 +1674,19 @@ static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
                ntohs(init_chunk->chunk_hdr->length), raw_addrs, addrs_len);
 
         if (sctp_sk(ep->base.sk)->hmac) {
-                struct hash_desc desc;
+                SHASH_DESC_ON_STACK(desc, sctp_sk(ep->base.sk)->hmac);
+                int err;
 
                 /* Sign the message.  */
-                sg_init_one(&sg, &cookie->c, bodysize);
-                desc.tfm = sctp_sk(ep->base.sk)->hmac;
-                desc.flags = 0;
-
-                if (crypto_hash_setkey(desc.tfm, ep->secret_key,
-                                       sizeof(ep->secret_key)) ||
-                    crypto_hash_digest(&desc, &sg, bodysize, cookie->signature))
+                desc->tfm = sctp_sk(ep->base.sk)->hmac;
+                desc->flags = 0;
+
+                err = crypto_shash_setkey(desc->tfm, ep->secret_key,
+                                          sizeof(ep->secret_key)) ?:
+                      crypto_shash_digest(desc, (u8 *)&cookie->c, bodysize,
+                                          cookie->signature);
+                shash_desc_zero(desc);
+                if (err)
                         goto free_cookie;
         }
 
@@ -1697,12 +1711,10 @@ struct sctp_association *sctp_unpack_cookie(
         struct sctp_cookie *bear_cookie;
         int headersize, bodysize, fixed_size;
         __u8 *digest = ep->digest;
-        struct scatterlist sg;
         unsigned int len;
         sctp_scope_t scope;
         struct sk_buff *skb = chunk->skb;
         ktime_t kt;
-        struct hash_desc desc;
 
         /* Header size is static data prior to the actual cookie, including
          * any padding.
@@ -1733,16 +1745,23 @@ struct sctp_association *sctp_unpack_cookie(
                 goto no_hmac;
 
         /* Check the signature.  */
-        sg_init_one(&sg, bear_cookie, bodysize);
-        desc.tfm = sctp_sk(ep->base.sk)->hmac;
-        desc.flags = 0;
-
-        memset(digest, 0x00, SCTP_SIGNATURE_SIZE);
-        if (crypto_hash_setkey(desc.tfm, ep->secret_key,
-                               sizeof(ep->secret_key)) ||
-            crypto_hash_digest(&desc, &sg, bodysize, digest)) {
-                *error = -SCTP_IERROR_NOMEM;
-                goto fail;
+        {
+                SHASH_DESC_ON_STACK(desc, sctp_sk(ep->base.sk)->hmac);
+                int err;
+
+                desc->tfm = sctp_sk(ep->base.sk)->hmac;
+                desc->flags = 0;
+
+                err = crypto_shash_setkey(desc->tfm, ep->secret_key,
+                                          sizeof(ep->secret_key)) ?:
+                      crypto_shash_digest(desc, (u8 *)bear_cookie, bodysize,
+                                          digest);
+                shash_desc_zero(desc);
+
+                if (err) {
+                        *error = -SCTP_IERROR_NOMEM;
+                        goto fail;
+                }
         }
 
         if (memcmp(digest, cookie->signature, SCTP_SIGNATURE_SIZE)) {
@@ -2757,7 +2776,8 @@ static struct sctp_chunk *sctp_make_asconf(struct sctp_association *asoc,
         length += addrlen;
 
         /* Create the chunk.  */
-        retval = sctp_make_control(asoc, SCTP_CID_ASCONF, 0, length);
+        retval = sctp_make_control(asoc, SCTP_CID_ASCONF, 0, length,
+                                   GFP_ATOMIC);
         if (!retval)
                 return NULL;
 
@@ -2941,7 +2961,8 @@ static struct sctp_chunk *sctp_make_asconf_ack(const struct sctp_association *as
         int                     length = sizeof(asconf) + vparam_len;
 
         /* Create the chunk.  */
-        retval = sctp_make_control(asoc, SCTP_CID_ASCONF_ACK, 0, length);
+        retval = sctp_make_control(asoc, SCTP_CID_ASCONF_ACK, 0, length,
+                                   GFP_ATOMIC);
         if (!retval)
                 return NULL;
 
@@ -3501,7 +3522,7 @@ struct sctp_chunk *sctp_make_fwdtsn(const struct sctp_association *asoc,
 
         hint = (nstreams + 1) * sizeof(__u32);
 
-        retval = sctp_make_control(asoc, SCTP_CID_FWD_TSN, 0, hint);
+        retval = sctp_make_control(asoc, SCTP_CID_FWD_TSN, 0, hint, GFP_ATOMIC);
 
         if (!retval)
                 return NULL;
diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c
index b5327bb77458..3c22c41a2bc2 100644
--- a/net/sctp/sm_sideeffect.c
+++ b/net/sctp/sm_sideeffect.c
@@ -1019,13 +1019,13 @@ static void sctp_cmd_t1_timer_update(struct sctp_association *asoc,
  * encouraged for small fragments.
  */
 static int sctp_cmd_send_msg(struct sctp_association *asoc,
-                                struct sctp_datamsg *msg)
+                                struct sctp_datamsg *msg, gfp_t gfp)
 {
         struct sctp_chunk *chunk;
         int error = 0;
 
         list_for_each_entry(chunk, &msg->chunks, frag_list) {
-                error = sctp_outq_tail(&asoc->outqueue, chunk);
+                error = sctp_outq_tail(&asoc->outqueue, chunk, gfp);
                 if (error)
                         break;
         }
@@ -1249,7 +1249,7 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
                 case SCTP_CMD_NEW_ASOC:
                         /* Register a new association.  */
                         if (local_cork) {
-                                sctp_outq_uncork(&asoc->outqueue);
+                                sctp_outq_uncork(&asoc->outqueue, gfp);
                                 local_cork = 0;
                         }
 
@@ -1269,7 +1269,7 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
 
                 case SCTP_CMD_DELETE_TCB:
                         if (local_cork) {
-                                sctp_outq_uncork(&asoc->outqueue);
+                                sctp_outq_uncork(&asoc->outqueue, gfp);
                                 local_cork = 0;
                         }
                         /* Delete the current association.  */
@@ -1423,13 +1423,14 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
                                 local_cork = 1;
                         }
                         /* Send a chunk to our peer.  */
-                        error = sctp_outq_tail(&asoc->outqueue, cmd->obj.chunk);
+                        error = sctp_outq_tail(&asoc->outqueue, cmd->obj.chunk,
+                                               gfp);
                         break;
 
                 case SCTP_CMD_SEND_PKT:
                         /* Send a full packet to our peer.  */
                         packet = cmd->obj.packet;
-                        sctp_packet_transmit(packet);
+                        sctp_packet_transmit(packet, gfp);
                         sctp_ootb_pkt_free(packet);
                         break;
 
@@ -1639,7 +1640,7 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
                          */
                         chunk->pdiscard = 1;
                         if (asoc) {
-                                sctp_outq_uncork(&asoc->outqueue);
+                                sctp_outq_uncork(&asoc->outqueue, gfp);
                                 local_cork = 0;
                         }
                         break;
@@ -1677,7 +1678,7 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
                 case SCTP_CMD_FORCE_PRIM_RETRAN:
                         t = asoc->peer.retran_path;
                         asoc->peer.retran_path = asoc->peer.primary_path;
-                        error = sctp_outq_uncork(&asoc->outqueue);
+                        error = sctp_outq_uncork(&asoc->outqueue, gfp);
                         local_cork = 0;
                         asoc->peer.retran_path = t;
                         break;
@@ -1704,7 +1705,7 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
                                 sctp_outq_cork(&asoc->outqueue);
                                 local_cork = 1;
                         }
-                        error = sctp_cmd_send_msg(asoc, cmd->obj.msg);
+                        error = sctp_cmd_send_msg(asoc, cmd->obj.msg, gfp);
                         break;
                 case SCTP_CMD_SEND_NEXT_ASCONF:
                         sctp_cmd_send_asconf(asoc);
@@ -1734,9 +1735,9 @@ out:
          */
         if (asoc && SCTP_EVENT_T_CHUNK == event_type && chunk) {
                 if (chunk->end_of_packet || chunk->singleton)
-                        error = sctp_outq_uncork(&asoc->outqueue);
+                        error = sctp_outq_uncork(&asoc->outqueue, gfp);
         } else if (local_cork)
-                error = sctp_outq_uncork(&asoc->outqueue);
+                error = sctp_outq_uncork(&asoc->outqueue, gfp);
         return error;
 nomem:
         error = -ENOMEM;
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index 0e3de0c71137..a44a97c93724 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -52,6 +52,7 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
+#include <crypto/hash.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/wait.h>
@@ -61,7 +62,6 @@
 #include <linux/fcntl.h>
 #include <linux/poll.h>
 #include <linux/init.h>
-#include <linux/crypto.h>
 #include <linux/slab.h>
 #include <linux/file.h>
 #include <linux/compat.h>
@@ -4162,7 +4162,7 @@ static void sctp_destruct_sock(struct sock *sk)
         struct sctp_sock *sp = sctp_sk(sk);
 
         /* Free up the HMAC transform. */
-        crypto_free_hash(sp->hmac);
+        crypto_free_shash(sp->hmac);
 
         inet_sock_destruct(sk);
 }
@@ -6108,9 +6108,10 @@ static int sctp_getsockopt(struct sock *sk, int level, int optname,
         return retval;
 }
 
-static void sctp_hash(struct sock *sk)
+static int sctp_hash(struct sock *sk)
 {
         /* STUB */
+        return 0;
 }
 
 static void sctp_unhash(struct sock *sk)
@@ -6306,13 +6307,13 @@ static int sctp_listen_start(struct sock *sk, int backlog)
 {
         struct sctp_sock *sp = sctp_sk(sk);
         struct sctp_endpoint *ep = sp->ep;
-        struct crypto_hash *tfm = NULL;
+        struct crypto_shash *tfm = NULL;
         char alg[32];
 
         /* Allocate HMAC for generating cookie. */
         if (!sp->hmac && sp->sctp_hmac_alg) {
                 sprintf(alg, "hmac(%s)", sp->sctp_hmac_alg);
-                tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC);
+                tfm = crypto_alloc_shash(alg, 0, 0);
                 if (IS_ERR(tfm)) {
                         net_info_ratelimited("failed to load transform for %s: %ld\n",
                                              sp->sctp_hmac_alg, PTR_ERR(tfm));
@@ -7255,14 +7256,12 @@ static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
         /* Hook this new socket in to the bind_hash list. */
         head = &sctp_port_hashtable[sctp_phashfn(sock_net(oldsk),
                                                  inet_sk(oldsk)->inet_num)];
-        local_bh_disable();
-        spin_lock(&head->lock);
+        spin_lock_bh(&head->lock);
         pp = sctp_sk(oldsk)->bind_hash;
         sk_add_bind_node(newsk, &pp->owner);
         sctp_sk(newsk)->bind_hash = pp;
         inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num;
-        spin_unlock(&head->lock);
-        local_bh_enable();
+        spin_unlock_bh(&head->lock);
 
         /* Copy the bind_addr list from the original endpoint to the new
          * endpoint so that we can handle restarts properly
diff --git a/net/sctp/transport.c b/net/sctp/transport.c
index a431c14044a4..d517153891a6 100644
--- a/net/sctp/transport.c
+++ b/net/sctp/transport.c
@@ -72,7 +72,7 @@ static struct sctp_transport *sctp_transport_init(struct net *net,
          */
         peer->rto = msecs_to_jiffies(net->sctp.rto_initial);
 
-        peer->last_time_heard = ktime_get();
+        peer->last_time_heard = ktime_set(0, 0);
         peer->last_time_ecne_reduced = jiffies;
 
         peer->param_flags = SPP_HB_DISABLE |