Merge with temp tree to get David's gdb inferior calls patch

9 files changed, 76 insertions, 73 deletions

diff --git a/net/core/datagram.c b/net/core/datagram.c
index d1bfd279cc1a..fcee054b6f75 100644
--- a/net/core/datagram.c
+++ b/net/core/datagram.c
@@ -115,10 +115,10 @@ out_noerr:
 
 /**
  *      skb_recv_datagram - Receive a datagram skbuff
- *      @sk - socket
- *      @flags - MSG_ flags
- *      @noblock - blocking operation?
- *      @err - error code returned
+ *      @sk: socket
+ *      @flags: MSG_ flags
+ *      @noblock: blocking operation?
+ *      @err: error code returned
  *
  *      Get a datagram skbuff, understands the peeking, nonblocking wakeups
  *      and possible races. This replaces identical code in packet, raw and
@@ -201,10 +201,10 @@ void skb_free_datagram(struct sock *sk, struct sk_buff *skb)
 
 /**
  *      skb_copy_datagram_iovec - Copy a datagram to an iovec.
- *      @skb - buffer to copy
- *      @offset - offset in the buffer to start copying from
- *      @iovec - io vector to copy to
- *      @len - amount of data to copy from buffer to iovec
+ *      @skb: buffer to copy
+ *      @offset: offset in the buffer to start copying from
+ *      @to: io vector to copy to
+ *      @len: amount of data to copy from buffer to iovec
  *
  *      Note: the iovec is modified during the copy.
  */
@@ -377,9 +377,9 @@ fault:
 
 /**
  *      skb_copy_and_csum_datagram_iovec - Copy and checkum skb to user iovec.
- *      @skb - skbuff
- *      @hlen - hardware length
- *      @iovec - io vector
+ *      @skb: skbuff
+ *      @hlen: hardware length
+ *      @iov: io vector
  * 
  *      Caller _must_ check that skb will fit to this iovec.
  *
@@ -425,9 +425,9 @@ fault:
 
 /**
  *      datagram_poll - generic datagram poll
- *      @file - file struct
- *      @sock - socket
- *      @wait - poll table
+ *      @file: file struct
+ *      @sock: socket
+ *      @wait: poll table
  *
  *      Datagram poll: Again totally generic. This also handles
  *      sequenced packet sockets providing the socket receive queue
diff --git a/net/core/dev.c b/net/core/dev.c
index 7bd4cd4502c4..f5f005846fe1 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -3091,7 +3091,7 @@ void free_netdev(struct net_device *dev)
 void synchronize_net(void) 
 {
         might_sleep();
-        synchronize_kernel();
+        synchronize_rcu();
 }
 
 /**
diff --git a/net/core/iovec.c b/net/core/iovec.c
index d57ace949ab8..65e4b56fbc77 100644
--- a/net/core/iovec.c
+++ b/net/core/iovec.c
@@ -33,7 +33,7 @@
  *      Verify iovec. The caller must ensure that the iovec is big enough
  *      to hold the message iovec.
  *
- *      Save time not doing verify_area. copy_*_user will make this work
+ *      Save time not doing access_ok. copy_*_user will make this work
  *      in any case.
  */
 
diff --git a/net/core/link_watch.c b/net/core/link_watch.c
index 4859b7446c6f..d43d1201275c 100644
--- a/net/core/link_watch.c
+++ b/net/core/link_watch.c
@@ -16,6 +16,7 @@
 #include <linux/netdevice.h>
 #include <linux/if.h>
 #include <net/sock.h>
+#include <net/pkt_sched.h>
 #include <linux/rtnetlink.h>
 #include <linux/jiffies.h>
 #include <linux/spinlock.h>
@@ -74,6 +75,12 @@ void linkwatch_run_queue(void)
                 clear_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state);
 
                 if (dev->flags & IFF_UP) {
+                        if (netif_carrier_ok(dev)) {
+                                WARN_ON(dev->qdisc_sleeping == &noop_qdisc);
+                                dev_activate(dev);
+                        } else
+                                dev_deactivate(dev);
+
                         netdev_state_change(dev);
                 }
 
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 0a2f67bbef2e..43bdc521e20d 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -1953,7 +1953,7 @@ static int neigh_stat_seq_show(struct seq_file *seq, void *v)
         struct neigh_statistics *st = v;
 
         if (v == SEQ_START_TOKEN) {
-                seq_printf(seq, "entries  allocs destroys hash_grows  lookups hits  res_failed  rcv_probes_mcast rcv_probes_ucast  periodic_gc_runs forced_gc_runs forced_gc_goal_miss\n");
+                seq_printf(seq, "entries  allocs destroys hash_grows  lookups hits  res_failed  rcv_probes_mcast rcv_probes_ucast  periodic_gc_runs forced_gc_runs\n");
                 return 0;
         }
 
diff --git a/net/core/netfilter.c b/net/core/netfilter.c
index e51cfa46950c..22a8f127c4aa 100644
--- a/net/core/netfilter.c
+++ b/net/core/netfilter.c
@@ -217,21 +217,10 @@ void nf_debug_ip_local_deliver(struct sk_buff *skb)
          * NF_IP_RAW_INPUT and NF_IP_PRE_ROUTING.  */
         if (!skb->dev) {
                 printk("ip_local_deliver: skb->dev is NULL.\n");
-        }
-        else if (strcmp(skb->dev->name, "lo") == 0) {
-                if (skb->nf_debug != ((1 << NF_IP_LOCAL_OUT)
-                                      | (1 << NF_IP_POST_ROUTING)
-                                      | (1 << NF_IP_PRE_ROUTING)
-                                      | (1 << NF_IP_LOCAL_IN))) {
-                        printk("ip_local_deliver: bad loopback skb: ");
-                        debug_print_hooks_ip(skb->nf_debug);
-                        nf_dump_skb(PF_INET, skb);
-                }
-        }
-        else {
+        } else {
                 if (skb->nf_debug != ((1<<NF_IP_PRE_ROUTING)
                                       | (1<<NF_IP_LOCAL_IN))) {
-                        printk("ip_local_deliver: bad non-lo skb: ");
+                        printk("ip_local_deliver: bad skb: ");
                         debug_print_hooks_ip(skb->nf_debug);
                         nf_dump_skb(PF_INET, skb);
                 }
@@ -247,8 +236,6 @@ void nf_debug_ip_loopback_xmit(struct sk_buff *newskb)
                 debug_print_hooks_ip(newskb->nf_debug);
                 nf_dump_skb(PF_INET, newskb);
         }
-        /* Clear to avoid confusing input check */
-        newskb->nf_debug = 0;
 }
 
 void nf_debug_ip_finish_output2(struct sk_buff *skb)
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index d8c198e42f90..00caf4b318b2 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -86,30 +86,33 @@ struct sock *rtnl;
 
 struct rtnetlink_link * rtnetlink_links[NPROTO];
 
-static const int rtm_min[(RTM_MAX+1-RTM_BASE)/4] =
+static const int rtm_min[RTM_NR_FAMILIES] =
 {
-        NLMSG_LENGTH(sizeof(struct ifinfomsg)),
-        NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
-        NLMSG_LENGTH(sizeof(struct rtmsg)),
-        NLMSG_LENGTH(sizeof(struct ndmsg)),
-        NLMSG_LENGTH(sizeof(struct rtmsg)),
-        NLMSG_LENGTH(sizeof(struct tcmsg)),
-        NLMSG_LENGTH(sizeof(struct tcmsg)),
-        NLMSG_LENGTH(sizeof(struct tcmsg)),
-        NLMSG_LENGTH(sizeof(struct tcamsg))
+        [RTM_FAM(RTM_NEWLINK)]      = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+        [RTM_FAM(RTM_NEWADDR)]      = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
+        [RTM_FAM(RTM_NEWROUTE)]     = NLMSG_LENGTH(sizeof(struct rtmsg)),
+        [RTM_FAM(RTM_NEWNEIGH)]     = NLMSG_LENGTH(sizeof(struct ndmsg)),
+        [RTM_FAM(RTM_NEWRULE)]      = NLMSG_LENGTH(sizeof(struct rtmsg)),
+        [RTM_FAM(RTM_NEWQDISC)]     = NLMSG_LENGTH(sizeof(struct tcmsg)),
+        [RTM_FAM(RTM_NEWTCLASS)]    = NLMSG_LENGTH(sizeof(struct tcmsg)),
+        [RTM_FAM(RTM_NEWTFILTER)]   = NLMSG_LENGTH(sizeof(struct tcmsg)),
+        [RTM_FAM(RTM_NEWACTION)]    = NLMSG_LENGTH(sizeof(struct tcamsg)),
+        [RTM_FAM(RTM_NEWPREFIX)]    = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
+        [RTM_FAM(RTM_GETMULTICAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
+        [RTM_FAM(RTM_GETANYCAST)]   = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
 };
 
-static const int rta_max[(RTM_MAX+1-RTM_BASE)/4] =
+static const int rta_max[RTM_NR_FAMILIES] =
 {
-        IFLA_MAX,
-        IFA_MAX,
-        RTA_MAX,
-        NDA_MAX,
-        RTA_MAX,
-        TCA_MAX,
-        TCA_MAX,
-        TCA_MAX,
-        TCAA_MAX
+        [RTM_FAM(RTM_NEWLINK)]      = IFLA_MAX,
+        [RTM_FAM(RTM_NEWADDR)]      = IFA_MAX,
+        [RTM_FAM(RTM_NEWROUTE)]     = RTA_MAX,
+        [RTM_FAM(RTM_NEWNEIGH)]     = NDA_MAX,
+        [RTM_FAM(RTM_NEWRULE)]      = RTA_MAX,
+        [RTM_FAM(RTM_NEWQDISC)]     = TCA_MAX,
+        [RTM_FAM(RTM_NEWTCLASS)]    = TCA_MAX,
+        [RTM_FAM(RTM_NEWTFILTER)]   = TCA_MAX,
+        [RTM_FAM(RTM_NEWACTION)]    = TCAA_MAX,
 };
 
 void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
@@ -606,27 +609,33 @@ static inline int rtnetlink_rcv_skb(struct sk_buff *skb)
 
 /*
  *  rtnetlink input queue processing routine:
- *      - try to acquire shared lock. If it is failed, defer processing.
+ *      - process as much as there was in the queue upon entry.
  *      - feed skbs to rtnetlink_rcv_skb, until it refuse a message,
- *        that will occur, when a dump started and/or acquisition of
- *        exclusive lock failed.
+ *        that will occur, when a dump started.
  */
 
 static void rtnetlink_rcv(struct sock *sk, int len)
 {
+        unsigned int qlen = skb_queue_len(&sk->sk_receive_queue);
+
         do {
                 struct sk_buff *skb;
 
-                if (rtnl_shlock_nowait())
-                        return;
+                rtnl_lock();
+
+                if (qlen > skb_queue_len(&sk->sk_receive_queue))
+                        qlen = skb_queue_len(&sk->sk_receive_queue);
 
-                while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
+                for (; qlen; qlen--) {
+                        skb = skb_dequeue(&sk->sk_receive_queue);
                         if (rtnetlink_rcv_skb(skb)) {
                                 if (skb->len)
                                         skb_queue_head(&sk->sk_receive_queue,
                                                        skb);
-                                else
+                                else {
                                         kfree_skb(skb);
+                                        qlen--;
+                                }
                                 break;
                         }
                         kfree_skb(skb);
@@ -635,10 +644,10 @@ static void rtnetlink_rcv(struct sock *sk, int len)
                 up(&rtnl_sem);
 
                 netdev_run_todo();
-        } while (rtnl && rtnl->sk_receive_queue.qlen);
+        } while (qlen);
 }
 
-static struct rtnetlink_link link_rtnetlink_table[RTM_MAX-RTM_BASE+1] =
+static struct rtnetlink_link link_rtnetlink_table[RTM_NR_MSGTYPES] =
 {
         [RTM_GETLINK  - RTM_BASE] = { .dumpit = rtnetlink_dump_ifinfo },
         [RTM_SETLINK  - RTM_BASE] = { .doit   = do_setlink            },
diff --git a/net/core/sock.c b/net/core/sock.c
index 5c2f72fa1013..98171ddd7e7d 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -616,10 +616,10 @@ lenout:
 
 /**
  *      sk_alloc - All socket objects are allocated here
- *      @family - protocol family
- *      @priority - for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
- *      @prot - struct proto associated with this new sock instance
- *      @zero_it - if we should zero the newly allocated sock
+ *      @family: protocol family
+ *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
+ *      @prot: struct proto associated with this new sock instance
+ *      @zero_it: if we should zero the newly allocated sock
  */
 struct sock *sk_alloc(int family, int priority, struct proto *prot, int zero_it)
 {
@@ -970,8 +970,8 @@ static void __release_sock(struct sock *sk)
 
 /**
  * sk_wait_data - wait for data to arrive at sk_receive_queue
- * sk - sock to wait on
- * timeo - for how long
+ * @sk:    sock to wait on
+ * @timeo: for how long
  *
  * Now socket state including sk->sk_err is changed only under lock,
  * hence we may omit checks after joining wait queue.
diff --git a/net/core/stream.c b/net/core/stream.c
index 1e27a57b5a97..ac9edfdf8742 100644
--- a/net/core/stream.c
+++ b/net/core/stream.c
@@ -21,7 +21,7 @@
 
 /**
  * sk_stream_write_space - stream socket write_space callback.
- * sk - socket
+ * @sk: socket
  *
  * FIXME: write proper description
  */
@@ -43,8 +43,8 @@ EXPORT_SYMBOL(sk_stream_write_space);
 
 /**
  * sk_stream_wait_connect - Wait for a socket to get into the connected state
- * @sk - sock to wait on
- * @timeo_p - for how long to wait
+ * @sk: sock to wait on
+ * @timeo_p: for how long to wait
  *
  * Must be called with the socket locked.
  */
@@ -79,7 +79,7 @@ EXPORT_SYMBOL(sk_stream_wait_connect);
 
 /**
  * sk_stream_closing - Return 1 if we still have things to send in our buffers.
- * @sk - socket to verify
+ * @sk: socket to verify
  */
 static inline int sk_stream_closing(struct sock *sk)
 {
@@ -107,8 +107,8 @@ EXPORT_SYMBOL(sk_stream_wait_close);
 
 /**
  * sk_stream_wait_memory - Wait for more memory for a socket
- * @sk - socket to wait for memory
- * @timeo_p - for how long
+ * @sk: socket to wait for memory
+ * @timeo_p: for how long
  */
 int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
 {