8 files changed, 70 insertions, 29 deletions

diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index 0e74398bc8e6..c7629a209f9d 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -957,8 +957,8 @@ static void nl_fib_input(struct sk_buff *skb)
 
         net = sock_net(skb->sk);
         nlh = nlmsg_hdr(skb);
-        if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
-            nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
+        if (skb->len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len ||
+            nlmsg_len(nlh) < sizeof(*frn))
                 return;
 
         skb = skb_clone(skb, GFP_KERNEL);
@@ -966,7 +966,7 @@ static void nl_fib_input(struct sk_buff *skb)
                 return;
         nlh = nlmsg_hdr(skb);
 
-        frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
+        frn = (struct fib_result_nl *) nlmsg_data(nlh);
         tb = fib_get_table(net, frn->tb_id_in);
 
         nl_fib_lookup(frn, tb);
diff --git a/net/ipv4/inet_fragment.c b/net/ipv4/inet_fragment.c
index 1206ca64b0ea..e97d66a1fdde 100644
--- a/net/ipv4/inet_fragment.c
+++ b/net/ipv4/inet_fragment.c
@@ -52,20 +52,27 @@ static void inet_frag_secret_rebuild(unsigned long dummy)
         unsigned long now = jiffies;
         int i;
 
+        /* Per bucket lock NOT needed here, due to write lock protection */
         write_lock(&f->lock);
+
         get_random_bytes(&f->rnd, sizeof(u32));
         for (i = 0; i < INETFRAGS_HASHSZ; i++) {
+                struct inet_frag_bucket *hb;
                 struct inet_frag_queue *q;
                 struct hlist_node *n;
 
-                hlist_for_each_entry_safe(q, n, &f->hash[i], list) {
+                hb = &f->hash[i];
+                hlist_for_each_entry_safe(q, n, &hb->chain, list) {
                         unsigned int hval = f->hashfn(q);
 
                         if (hval != i) {
+                                struct inet_frag_bucket *hb_dest;
+
                                 hlist_del(&q->list);
 
                                 /* Relink to new hash chain. */
-                                hlist_add_head(&q->list, &f->hash[hval]);
+                                hb_dest = &f->hash[hval];
+                                hlist_add_head(&q->list, &hb_dest->chain);
                         }
                 }
         }
@@ -78,9 +85,12 @@ void inet_frags_init(struct inet_frags *f)
 {
         int i;
 
-        for (i = 0; i < INETFRAGS_HASHSZ; i++)
-                INIT_HLIST_HEAD(&f->hash[i]);
+        for (i = 0; i < INETFRAGS_HASHSZ; i++) {
+                struct inet_frag_bucket *hb = &f->hash[i];
 
+                spin_lock_init(&hb->chain_lock);
+                INIT_HLIST_HEAD(&hb->chain);
+        }
         rwlock_init(&f->lock);
 
         f->rnd = (u32) ((num_physpages ^ (num_physpages>>7)) ^
@@ -122,9 +132,18 @@ EXPORT_SYMBOL(inet_frags_exit_net);
 
 static inline void fq_unlink(struct inet_frag_queue *fq, struct inet_frags *f)
 {
-        write_lock(&f->lock);
+        struct inet_frag_bucket *hb;
+        unsigned int hash;
+
+        read_lock(&f->lock);
+        hash = f->hashfn(fq);
+        hb = &f->hash[hash];
+
+        spin_lock(&hb->chain_lock);
         hlist_del(&fq->list);
-        write_unlock(&f->lock);
+        spin_unlock(&hb->chain_lock);
+
+        read_unlock(&f->lock);
         inet_frag_lru_del(fq);
 }
 
@@ -226,27 +245,32 @@ static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf,
                 struct inet_frag_queue *qp_in, struct inet_frags *f,
                 void *arg)
 {
+        struct inet_frag_bucket *hb;
         struct inet_frag_queue *qp;
 #ifdef CONFIG_SMP
 #endif
         unsigned int hash;
 
-        write_lock(&f->lock);
+        read_lock(&f->lock); /* Protects against hash rebuild */
         /*
          * While we stayed w/o the lock other CPU could update
          * the rnd seed, so we need to re-calculate the hash
          * chain. Fortunatelly the qp_in can be used to get one.
          */
         hash = f->hashfn(qp_in);
+        hb = &f->hash[hash];
+        spin_lock(&hb->chain_lock);
+
 #ifdef CONFIG_SMP
         /* With SMP race we have to recheck hash table, because
          * such entry could be created on other cpu, while we
-         * promoted read lock to write lock.
+         * released the hash bucket lock.
          */
-        hlist_for_each_entry(qp, &f->hash[hash], list) {
+        hlist_for_each_entry(qp, &hb->chain, list) {
                 if (qp->net == nf && f->match(qp, arg)) {
                         atomic_inc(&qp->refcnt);
-                        write_unlock(&f->lock);
+                        spin_unlock(&hb->chain_lock);
+                        read_unlock(&f->lock);
                         qp_in->last_in |= INET_FRAG_COMPLETE;
                         inet_frag_put(qp_in, f);
                         return qp;
@@ -258,8 +282,9 @@ static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf,
                 atomic_inc(&qp->refcnt);
 
         atomic_inc(&qp->refcnt);
-        hlist_add_head(&qp->list, &f->hash[hash]);
-        write_unlock(&f->lock);
+        hlist_add_head(&qp->list, &hb->chain);
+        spin_unlock(&hb->chain_lock);
+        read_unlock(&f->lock);
         inet_frag_lru_add(nf, qp);
         return qp;
 }
@@ -300,17 +325,23 @@ struct inet_frag_queue *inet_frag_find(struct netns_frags *nf,
                 struct inet_frags *f, void *key, unsigned int hash)
         __releases(&f->lock)
 {
+        struct inet_frag_bucket *hb;
         struct inet_frag_queue *q;
         int depth = 0;
 
-        hlist_for_each_entry(q, &f->hash[hash], list) {
+        hb = &f->hash[hash];
+
+        spin_lock(&hb->chain_lock);
+        hlist_for_each_entry(q, &hb->chain, list) {
                 if (q->net == nf && f->match(q, key)) {
                         atomic_inc(&q->refcnt);
+                        spin_unlock(&hb->chain_lock);
                         read_unlock(&f->lock);
                         return q;
                 }
                 depth++;
         }
+        spin_unlock(&hb->chain_lock);
         read_unlock(&f->lock);
 
         if (depth <= INETFRAGS_MAXDEPTH)
diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c
index ad662e906f7e..e5dfd2843f28 100644
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@ -660,7 +660,6 @@ static void __gre_tunnel_init(struct net_device *dev)
 
         dev->needed_headroom    = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
-        dev->iflink             = 0;
 
         dev->features           |= NETIF_F_NETNS_LOCAL | GRE_FEATURES;
         dev->hw_features        |= GRE_FEATURES;
diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c
index 9d96b6853f21..e4147ec1665a 100644
--- a/net/ipv4/ip_tunnel.c
+++ b/net/ipv4/ip_tunnel.c
@@ -284,7 +284,7 @@ static struct net_device *__ip_tunnel_create(struct net *net,
         if (parms->name[0])
                 strlcpy(name, parms->name, IFNAMSIZ);
         else {
-                if (strlen(ops->kind) + 3 >= IFNAMSIZ) {
+                if (strlen(ops->kind) > (IFNAMSIZ - 3)) {
                         err = -E2BIG;
                         goto failed;
                 }
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index bf6c5cf31aed..efa1138fa523 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -206,7 +206,7 @@ static int __init ic_open_devs(void)
         struct ic_device *d, **last;
         struct net_device *dev;
         unsigned short oflags;
-        unsigned long start;
+        unsigned long start, next_msg;
 
         last = &ic_first_dev;
         rtnl_lock();
@@ -263,12 +263,23 @@ static int __init ic_open_devs(void)
 
         /* wait for a carrier on at least one device */
         start = jiffies;
+        next_msg = start + msecs_to_jiffies(CONF_CARRIER_TIMEOUT/12);
         while (jiffies - start < msecs_to_jiffies(CONF_CARRIER_TIMEOUT)) {
+                int wait, elapsed;
+
                 for_each_netdev(&init_net, dev)
                         if (ic_is_init_dev(dev) && netif_carrier_ok(dev))
                                 goto have_carrier;
 
                 msleep(1);
+
+                if time_before(jiffies, next_msg)
+                        continue;
+
+                elapsed = jiffies_to_msecs(jiffies - start);
+                wait = (CONF_CARRIER_TIMEOUT - elapsed + 500)/1000;
+                pr_info("Waiting up to %d more seconds for network.\n", wait);
+                next_msg = jiffies + msecs_to_jiffies(CONF_CARRIER_TIMEOUT/12);
         }
 have_carrier:
         rtnl_unlock();
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index fd61fe16679f..9d9610ae7855 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -626,9 +626,9 @@ static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
                 if (ip_hdr(skb)->version == 0) {
                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
                         nlh->nlmsg_type = NLMSG_ERROR;
-                        nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
+                        nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
                         skb_trim(skb, nlh->nlmsg_len);
-                        e = NLMSG_DATA(nlh);
+                        e = nlmsg_data(nlh);
                         e->error = -ETIMEDOUT;
                         memset(&e->msg, 0, sizeof(e->msg));
 
@@ -910,14 +910,14 @@ static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
                 if (ip_hdr(skb)->version == 0) {
                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
 
-                        if (__ipmr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
+                        if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
                                 nlh->nlmsg_len = skb_tail_pointer(skb) -
                                                  (u8 *)nlh;
                         } else {
                                 nlh->nlmsg_type = NLMSG_ERROR;
-                                nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
+                                nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
                                 skb_trim(skb, nlh->nlmsg_len);
-                                e = NLMSG_DATA(nlh);
+                                e = nlmsg_data(nlh);
                                 e->error = -EMSGSIZE;
                                 memset(&e->msg, 0, sizeof(e->msg));
                         }
diff --git a/net/ipv4/netfilter/ipt_ULOG.c b/net/ipv4/netfilter/ipt_ULOG.c
index 642ecfb711bc..8799c836ccaa 100644
--- a/net/ipv4/netfilter/ipt_ULOG.c
+++ b/net/ipv4/netfilter/ipt_ULOG.c
@@ -37,7 +37,7 @@
 #include <linux/skbuff.h>
 #include <linux/kernel.h>
 #include <linux/timer.h>
-#include <linux/netlink.h>
+#include <net/netlink.h>
 #include <linux/netdevice.h>
 #include <linux/mm.h>
 #include <linux/moduleparam.h>
@@ -187,7 +187,7 @@ static void ipt_ulog_packet(unsigned int hooknum,
         else
                 copy_len = loginfo->copy_range;
 
-        size = NLMSG_SPACE(sizeof(*pm) + copy_len);
+        size = nlmsg_total_size(sizeof(*pm) + copy_len);
 
         ub = &ulog->ulog_buffers[groupnum];
 
diff --git a/net/ipv4/udp_diag.c b/net/ipv4/udp_diag.c
index 505b30ad9182..369a781851ad 100644
--- a/net/ipv4/udp_diag.c
+++ b/net/ipv4/udp_diag.c
@@ -64,9 +64,9 @@ static int udp_dump_one(struct udp_table *tbl, struct sk_buff *in_skb,
                 goto out;
 
         err = -ENOMEM;
-        rep = alloc_skb(NLMSG_SPACE((sizeof(struct inet_diag_msg) +
-                                     sizeof(struct inet_diag_meminfo) +
-                                     64)), GFP_KERNEL);
+        rep = nlmsg_new(sizeof(struct inet_diag_msg) +
+                        sizeof(struct inet_diag_meminfo) + 64,
+                        GFP_KERNEL);
         if (!rep)
                 goto out;