4 files changed, 52 insertions, 15 deletions

diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
index ec529121f38a..ce46f1c7f133 100644
--- a/net/sctp/ipv6.c
+++ b/net/sctp/ipv6.c
@@ -526,6 +526,8 @@ static int sctp_v6_cmp_addr(const union sctp_addr *addr1,
                 }
                 return 0;
         }
+        if (addr1->v6.sin6_port != addr2->v6.sin6_port)
+                return 0;
         if (!ipv6_addr_equal(&addr1->v6.sin6_addr, &addr2->v6.sin6_addr))
                 return 0;
         /* If this is a linklocal address, compare the scope_id. */
diff --git a/net/sctp/proc.c b/net/sctp/proc.c
index ded7d931a6a5..963dffcc2618 100644
--- a/net/sctp/proc.c
+++ b/net/sctp/proc.c
@@ -482,7 +482,7 @@ static void sctp_remaddr_seq_stop(struct seq_file *seq, void *v)
 static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
 {
         struct sctp_association *assoc;
-        struct sctp_transport *tsp;
+        struct sctp_transport *transport, *tsp;
 
         if (v == SEQ_START_TOKEN) {
                 seq_printf(seq, "ADDR ASSOC_ID HB_ACT RTO MAX_PATH_RTX "
@@ -490,10 +490,10 @@ static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
                 return 0;
         }
 
-        tsp = (struct sctp_transport *)v;
-        if (!sctp_transport_hold(tsp))
+        transport = (struct sctp_transport *)v;
+        if (!sctp_transport_hold(transport))
                 return 0;
-        assoc = tsp->asoc;
+        assoc = transport->asoc;
 
         list_for_each_entry_rcu(tsp, &assoc->peer.transport_addr_list,
                                 transports) {
@@ -546,7 +546,7 @@ static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
                 seq_printf(seq, "\n");
         }
 
-        sctp_transport_put(tsp);
+        sctp_transport_put(transport);
 
         return 0;
 }
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index ab0d538a74ed..1099e99a53c4 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -60,6 +60,8 @@
 #include <net/inet_common.h>
 #include <net/inet_ecn.h>
 
+#define MAX_SCTP_PORT_HASH_ENTRIES (64 * 1024)
+
 /* Global data structures. */
 struct sctp_globals sctp_globals __read_mostly;
 
@@ -1355,6 +1357,8 @@ static __init int sctp_init(void)
         unsigned long limit;
         int max_share;
         int order;
+        int num_entries;
+        int max_entry_order;
 
         sock_skb_cb_check_size(sizeof(struct sctp_ulpevent));
 
@@ -1407,14 +1411,24 @@ static __init int sctp_init(void)
 
         /* Size and allocate the association hash table.
          * The methodology is similar to that of the tcp hash tables.
+         * Though not identical.  Start by getting a goal size
          */
         if (totalram_pages >= (128 * 1024))
                 goal = totalram_pages >> (22 - PAGE_SHIFT);
         else
                 goal = totalram_pages >> (24 - PAGE_SHIFT);
 
-        for (order = 0; (1UL << order) < goal; order++)
-                ;
+        /* Then compute the page order for said goal */
+        order = get_order(goal);
+
+        /* Now compute the required page order for the maximum sized table we
+         * want to create
+         */
+        max_entry_order = get_order(MAX_SCTP_PORT_HASH_ENTRIES *
+                                    sizeof(struct sctp_bind_hashbucket));
+
+        /* Limit the page order by that maximum hash table size */
+        order = min(order, max_entry_order);
 
         /* Allocate and initialize the endpoint hash table.  */
         sctp_ep_hashsize = 64;
@@ -1430,20 +1444,35 @@ static __init int sctp_init(void)
                 INIT_HLIST_HEAD(&sctp_ep_hashtable[i].chain);
         }
 
-        /* Allocate and initialize the SCTP port hash table.  */
+        /* Allocate and initialize the SCTP port hash table.
+         * Note that order is initalized to start at the max sized
+         * table we want to support.  If we can't get that many pages
+         * reduce the order and try again
+         */
         do {
-                sctp_port_hashsize = (1UL << order) * PAGE_SIZE /
-                                        sizeof(struct sctp_bind_hashbucket);
-                if ((sctp_port_hashsize > (64 * 1024)) && order > 0)
-                        continue;
                 sctp_port_hashtable = (struct sctp_bind_hashbucket *)
                         __get_free_pages(GFP_KERNEL | __GFP_NOWARN, order);
         } while (!sctp_port_hashtable && --order > 0);
+
         if (!sctp_port_hashtable) {
                 pr_err("Failed bind hash alloc\n");
                 status = -ENOMEM;
                 goto err_bhash_alloc;
         }
+
+        /* Now compute the number of entries that will fit in the
+         * port hash space we allocated
+         */
+        num_entries = (1UL << order) * PAGE_SIZE /
+                      sizeof(struct sctp_bind_hashbucket);
+
+        /* And finish by rounding it down to the nearest power of two
+         * this wastes some memory of course, but its needed because
+         * the hash function operates based on the assumption that
+         * that the number of entries is a power of two
+         */
+        sctp_port_hashsize = rounddown_pow_of_two(num_entries);
+
         for (i = 0; i < sctp_port_hashsize; i++) {
                 spin_lock_init(&sctp_port_hashtable[i].lock);
                 INIT_HLIST_HEAD(&sctp_port_hashtable[i].chain);
@@ -1452,7 +1481,8 @@ static __init int sctp_init(void)
         if (sctp_transport_hashtable_init())
                 goto err_thash_alloc;
 
-        pr_info("Hash tables configured (bind %d)\n", sctp_port_hashsize);
+        pr_info("Hash tables configured (bind %d/%d)\n", sctp_port_hashsize,
+                num_entries);
 
         sctp_sysctl_register();
 
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index 5ca2ebfe0be8..e878da0949db 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -5538,6 +5538,7 @@ static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
         struct sctp_hmac_algo_param *hmacs;
         __u16 data_len = 0;
         u32 num_idents;
+        int i;
 
         if (!ep->auth_enable)
                 return -EACCES;
@@ -5555,8 +5556,12 @@ static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
                 return -EFAULT;
         if (put_user(num_idents, &p->shmac_num_idents))
                 return -EFAULT;
-        if (copy_to_user(p->shmac_idents, hmacs->hmac_ids, data_len))
-                return -EFAULT;
+        for (i = 0; i < num_idents; i++) {
+                __u16 hmacid = ntohs(hmacs->hmac_ids[i]);
+
+                if (copy_to_user(&p->shmac_idents[i], &hmacid, sizeof(__u16)))
+                        return -EFAULT;
+        }
         return 0;
 }