Merge branch 'linux-2.6'

9 files changed, 85 insertions, 55 deletions

diff --git a/net/ipv4/inet_diag.c b/net/ipv4/inet_diag.c
index b0170732b5e9..e468e7a7aac4 100644
--- a/net/ipv4/inet_diag.c
+++ b/net/ipv4/inet_diag.c
@@ -51,6 +51,29 @@ static struct sock *idiagnl;
 #define INET_DIAG_PUT(skb, attrtype, attrlen) \
         RTA_DATA(__RTA_PUT(skb, attrtype, attrlen))
 
+static DEFINE_MUTEX(inet_diag_table_mutex);
+
+static const struct inet_diag_handler *inet_diag_lock_handler(int type)
+{
+#ifdef CONFIG_KMOD
+        if (!inet_diag_table[type])
+                request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
+                               NETLINK_INET_DIAG, type);
+#endif
+
+        mutex_lock(&inet_diag_table_mutex);
+        if (!inet_diag_table[type])
+                return ERR_PTR(-ENOENT);
+
+        return inet_diag_table[type];
+}
+
+static inline void inet_diag_unlock_handler(
+        const struct inet_diag_handler *handler)
+{
+        mutex_unlock(&inet_diag_table_mutex);
+}
+
 static int inet_csk_diag_fill(struct sock *sk,
                               struct sk_buff *skb,
                               int ext, u32 pid, u32 seq, u16 nlmsg_flags,
@@ -235,9 +258,12 @@ static int inet_diag_get_exact(struct sk_buff *in_skb,
         struct inet_hashinfo *hashinfo;
         const struct inet_diag_handler *handler;
 
-        handler = inet_diag_table[nlh->nlmsg_type];
-        BUG_ON(handler == NULL);
+        handler = inet_diag_lock_handler(nlh->nlmsg_type);
+        if (!handler)
+                return -ENOENT;
+
         hashinfo = handler->idiag_hashinfo;
+        err = -EINVAL;
 
         if (req->idiag_family == AF_INET) {
                 sk = inet_lookup(hashinfo, req->id.idiag_dst[0],
@@ -255,11 +281,12 @@ static int inet_diag_get_exact(struct sk_buff *in_skb,
         }
 #endif
         else {
-                return -EINVAL;
+                goto unlock;
         }
 
+        err = -ENOENT;
         if (sk == NULL)
-                return -ENOENT;
+                goto unlock;
 
         err = -ESTALE;
         if ((req->id.idiag_cookie[0] != INET_DIAG_NOCOOKIE ||
@@ -296,6 +323,8 @@ out:
                 else
                         sock_put(sk);
         }
+unlock:
+        inet_diag_unlock_handler(handler);
         return err;
 }
 
@@ -678,8 +707,10 @@ static int inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
         const struct inet_diag_handler *handler;
         struct inet_hashinfo *hashinfo;
 
-        handler = inet_diag_table[cb->nlh->nlmsg_type];
-        BUG_ON(handler == NULL);
+        handler = inet_diag_lock_handler(cb->nlh->nlmsg_type);
+        if (!handler)
+                goto no_handler;
+
         hashinfo = handler->idiag_hashinfo;
 
         s_i = cb->args[1];
@@ -743,7 +774,7 @@ skip_listen_ht:
         }
 
         if (!(r->idiag_states & ~(TCPF_LISTEN | TCPF_SYN_RECV)))
-                return skb->len;
+                goto unlock;
 
         for (i = s_i; i < hashinfo->ehash_size; i++) {
                 struct inet_ehash_bucket *head = &hashinfo->ehash[i];
@@ -805,6 +836,9 @@ next_dying:
 done:
         cb->args[1] = i;
         cb->args[2] = num;
+unlock:
+        inet_diag_unlock_handler(handler);
+no_handler:
         return skb->len;
 }
 
@@ -816,15 +850,6 @@ static int inet_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
             nlmsg_len(nlh) < hdrlen)
                 return -EINVAL;
 
-#ifdef CONFIG_KMOD
-        if (inet_diag_table[nlh->nlmsg_type] == NULL)
-                request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
-                               NETLINK_INET_DIAG, nlh->nlmsg_type);
-#endif
-
-        if (inet_diag_table[nlh->nlmsg_type] == NULL)
-                return -ENOENT;
-
         if (nlh->nlmsg_flags & NLM_F_DUMP) {
                 if (nlmsg_attrlen(nlh, hdrlen)) {
                         struct nlattr *attr;
@@ -853,8 +878,6 @@ static void inet_diag_rcv(struct sk_buff *skb)
         mutex_unlock(&inet_diag_mutex);
 }
 
-static DEFINE_SPINLOCK(inet_diag_register_lock);
-
 int inet_diag_register(const struct inet_diag_handler *h)
 {
         const __u16 type = h->idiag_type;
@@ -863,13 +886,13 @@ int inet_diag_register(const struct inet_diag_handler *h)
         if (type >= INET_DIAG_GETSOCK_MAX)
                 goto out;
 
-        spin_lock(&inet_diag_register_lock);
+        mutex_lock(&inet_diag_table_mutex);
         err = -EEXIST;
         if (inet_diag_table[type] == NULL) {
                 inet_diag_table[type] = h;
                 err = 0;
         }
-        spin_unlock(&inet_diag_register_lock);
+        mutex_unlock(&inet_diag_table_mutex);
 out:
         return err;
 }
@@ -882,11 +905,9 @@ void inet_diag_unregister(const struct inet_diag_handler *h)
         if (type >= INET_DIAG_GETSOCK_MAX)
                 return;
 
-        spin_lock(&inet_diag_register_lock);
+        mutex_lock(&inet_diag_table_mutex);
         inet_diag_table[type] = NULL;
-        spin_unlock(&inet_diag_register_lock);
-
-        synchronize_rcu();
+        mutex_unlock(&inet_diag_table_mutex);
 }
 EXPORT_SYMBOL_GPL(inet_diag_unregister);
 
diff --git a/net/ipv4/inet_lro.c b/net/ipv4/inet_lro.c
index ac3b1d3dba2e..9a96c277393d 100644
--- a/net/ipv4/inet_lro.c
+++ b/net/ipv4/inet_lro.c
@@ -401,10 +401,11 @@ static struct sk_buff *lro_gen_skb(struct net_lro_mgr *lro_mgr,
         int data_len = len;
         int hdr_len = min(len, hlen);
 
-        skb = netdev_alloc_skb(lro_mgr->dev, hlen);
+        skb = netdev_alloc_skb(lro_mgr->dev, hlen + lro_mgr->frag_align_pad);
         if (!skb)
                 return NULL;
 
+        skb_reserve(skb, lro_mgr->frag_align_pad);
         skb->len = len;
         skb->data_len = len - hdr_len;
         skb->truesize += true_size;
diff --git a/net/ipv4/ipvs/ip_vs_lblc.c b/net/ipv4/ipvs/ip_vs_lblc.c
index b843a11d7cf7..ad89644ef5d2 100644
--- a/net/ipv4/ipvs/ip_vs_lblc.c
+++ b/net/ipv4/ipvs/ip_vs_lblc.c
@@ -580,9 +580,14 @@ static struct ip_vs_scheduler ip_vs_lblc_scheduler =
 
 static int __init ip_vs_lblc_init(void)
 {
+        int ret;
+
         INIT_LIST_HEAD(&ip_vs_lblc_scheduler.n_list);
         sysctl_header = register_sysctl_table(lblc_root_table);
-        return register_ip_vs_scheduler(&ip_vs_lblc_scheduler);
+        ret = register_ip_vs_scheduler(&ip_vs_lblc_scheduler);
+        if (ret)
+                unregister_sysctl_table(sysctl_header);
+        return ret;
 }
 
 
diff --git a/net/ipv4/ipvs/ip_vs_lblcr.c b/net/ipv4/ipvs/ip_vs_lblcr.c
index e5b323a6b2f7..2a5ed85a3352 100644
--- a/net/ipv4/ipvs/ip_vs_lblcr.c
+++ b/net/ipv4/ipvs/ip_vs_lblcr.c
@@ -769,9 +769,14 @@ static struct ip_vs_scheduler ip_vs_lblcr_scheduler =
 
 static int __init ip_vs_lblcr_init(void)
 {
+        int ret;
+
         INIT_LIST_HEAD(&ip_vs_lblcr_scheduler.n_list);
         sysctl_header = register_sysctl_table(lblcr_root_table);
-        return register_ip_vs_scheduler(&ip_vs_lblcr_scheduler);
+        ret = register_ip_vs_scheduler(&ip_vs_lblcr_scheduler);
+        if (ret)
+                unregister_sysctl_table(sysctl_header);
+        return ret;
 }
 
 
diff --git a/net/ipv4/ipvs/ip_vs_sched.c b/net/ipv4/ipvs/ip_vs_sched.c
index 1602304abbf9..432235861908 100644
--- a/net/ipv4/ipvs/ip_vs_sched.c
+++ b/net/ipv4/ipvs/ip_vs_sched.c
@@ -183,19 +183,6 @@ int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler)
         /* increase the module use count */
         ip_vs_use_count_inc();
 
-        /*
-         *  Make sure that the scheduler with this name doesn't exist
-         *  in the scheduler list.
-         */
-        sched = ip_vs_sched_getbyname(scheduler->name);
-        if (sched) {
-                ip_vs_scheduler_put(sched);
-                ip_vs_use_count_dec();
-                IP_VS_ERR("register_ip_vs_scheduler(): [%s] scheduler "
-                          "already existed in the system\n", scheduler->name);
-                return -EINVAL;
-        }
-
         write_lock_bh(&__ip_vs_sched_lock);
 
         if (scheduler->n_list.next != &scheduler->n_list) {
@@ -207,6 +194,20 @@ int register_ip_vs_scheduler(struct ip_vs_scheduler *scheduler)
         }
 
         /*
+         *  Make sure that the scheduler with this name doesn't exist
+         *  in the scheduler list.
+         */
+        list_for_each_entry(sched, &ip_vs_schedulers, n_list) {
+                if (strcmp(scheduler->name, sched->name) == 0) {
+                        write_unlock_bh(&__ip_vs_sched_lock);
+                        ip_vs_use_count_dec();
+                        IP_VS_ERR("register_ip_vs_scheduler(): [%s] scheduler "
+                                        "already existed in the system\n",
+                                        scheduler->name);
+                        return -EINVAL;
+                }
+        }
+        /*
          *      Add it into the d-linked scheduler list
          */
         list_add(&scheduler->n_list, &ip_vs_schedulers);
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index c426dec6d579..d2bc6148a737 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -1161,7 +1161,7 @@ static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
                         unsigned hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src,
                                                 rt->fl.oif);
 #if RT_CACHE_DEBUG >= 1
-                        printk(KERN_DEBUG "ip_rt_advice: redirect to "
+                        printk(KERN_DEBUG "ipv4_negative_advice: redirect to "
                                           "%u.%u.%u.%u/%02x dropped\n",
                                 NIPQUAD(rt->rt_dst), rt->fl.fl4_tos);
 #endif
@@ -1252,6 +1252,7 @@ static int ip_error(struct sk_buff *skb)
                         break;
                 case ENETUNREACH:
                         code = ICMP_NET_UNREACH;
+                        IP_INC_STATS_BH(IPSTATS_MIB_INNOROUTES);
                         break;
                 case EACCES:
                         code = ICMP_PKT_FILTERED;
@@ -1881,6 +1882,8 @@ no_route:
         RT_CACHE_STAT_INC(in_no_route);
         spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
         res.type = RTN_UNREACHABLE;
+        if (err == -ESRCH)
+                err = -ENETUNREACH;
         goto local_input;
 
         /*
diff --git a/net/ipv4/tcp_illinois.c b/net/ipv4/tcp_illinois.c
index 64f1cbaf96e8..5aa5f5496d6d 100644
--- a/net/ipv4/tcp_illinois.c
+++ b/net/ipv4/tcp_illinois.c
@@ -298,7 +298,7 @@ static u32 tcp_illinois_ssthresh(struct sock *sk)
         struct illinois *ca = inet_csk_ca(sk);
 
         /* Multiplicative decrease */
-        return max((tp->snd_cwnd * ca->beta) >> BETA_SHIFT, 2U);
+        return max(tp->snd_cwnd - ((tp->snd_cwnd * ca->beta) >> BETA_SHIFT), 2U);
 }
 
 
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 0f0c1c9829a1..b9e429d2d1de 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -3003,17 +3003,13 @@ static int tcp_process_frto(struct sock *sk, int flag)
         }
 
         if (tp->frto_counter == 1) {
-                /* Sending of the next skb must be allowed or no F-RTO */
-                if (!tcp_send_head(sk) ||
-                    after(TCP_SKB_CB(tcp_send_head(sk))->end_seq,
-                                     tp->snd_una + tp->snd_wnd)) {
-                        tcp_enter_frto_loss(sk, (tp->frto_counter == 1 ? 2 : 3),
-                                            flag);
-                        return 1;
-                }
-
+                /* tcp_may_send_now needs to see updated state */
                 tp->snd_cwnd = tcp_packets_in_flight(tp) + 2;
                 tp->frto_counter = 2;
+
+                if (!tcp_may_send_now(sk))
+                        tcp_enter_frto_loss(sk, 2, flag);
+
                 return 1;
         } else {
                 switch (sysctl_tcp_frto_response) {
@@ -3069,6 +3065,7 @@ static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
         }
 
         prior_fackets = tp->fackets_out;
+        prior_in_flight = tcp_packets_in_flight(tp);
 
         if (!(flag&FLAG_SLOWPATH) && after(ack, prior_snd_una)) {
                 /* Window is constant, pure forward advance.
@@ -3108,8 +3105,6 @@ static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
         if (!prior_packets)
                 goto no_queue;
 
-        prior_in_flight = tcp_packets_in_flight(tp);
-
         /* See if we can take anything off of the retransmit queue. */
         flag |= tcp_clean_rtx_queue(sk, &seq_rtt, prior_fackets);
 
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index e5130a7fe181..f4c1eef89af0 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1162,8 +1162,7 @@ int tcp_may_send_now(struct sock *sk)
         return (skb &&
                 tcp_snd_test(sk, skb, tcp_current_mss(sk, 1),
                              (tcp_skb_is_last(sk, skb) ?
-                              TCP_NAGLE_PUSH :
-                              tp->nonagle)));
+                              tp->nonagle : TCP_NAGLE_PUSH)));
 }
 
 /* Trim TSO SKB to LEN bytes, put the remaining data into a new packet