29 files changed, 443 insertions, 255 deletions

diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
index f42bc2b26b85..4bf014e51f8c 100644
--- a/net/8021q/vlan_dev.c
+++ b/net/8021q/vlan_dev.c
@@ -569,6 +569,7 @@ static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)
  * separate class since they always nest.
  */
 static struct lock_class_key vlan_netdev_xmit_lock_key;
+static struct lock_class_key vlan_netdev_addr_lock_key;
 
 static void vlan_dev_set_lockdep_one(struct net_device *dev,
                                      struct netdev_queue *txq,
@@ -581,6 +582,9 @@ static void vlan_dev_set_lockdep_one(struct net_device *dev,
 
 static void vlan_dev_set_lockdep_class(struct net_device *dev, int subclass)
 {
+        lockdep_set_class_and_subclass(&dev->addr_list_lock,
+                                       &vlan_netdev_addr_lock_key,
+                                       subclass);
         netdev_for_each_tx_queue(dev, vlan_dev_set_lockdep_one, &subclass);
 }
 
diff --git a/net/bluetooth/hci_sysfs.c b/net/bluetooth/hci_sysfs.c
index 844ca5f1b2d4..c85bf8f678dc 100644
--- a/net/bluetooth/hci_sysfs.c
+++ b/net/bluetooth/hci_sysfs.c
@@ -398,10 +398,6 @@ int hci_register_sysfs(struct hci_dev *hdev)
                 if (device_create_file(dev, bt_attrs[i]) < 0)
                         BT_ERR("Failed to create device attribute");
 
-        if (sysfs_create_link(&bt_class->subsys.kobj,
-                                &dev->kobj, kobject_name(&dev->kobj)) < 0)
-                BT_ERR("Failed to create class symlink");
-
         return 0;
 }
 
@@ -409,9 +405,6 @@ void hci_unregister_sysfs(struct hci_dev *hdev)
 {
         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
 
-        sysfs_remove_link(&bt_class->subsys.kobj,
-                                        kobject_name(&hdev->dev.kobj));
-
         device_del(&hdev->dev);
 }
 
diff --git a/net/core/dev.c b/net/core/dev.c
index 106d5e6d987c..7463a2150b09 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -124,6 +124,8 @@
 #include <linux/ip.h>
 #include <linux/ipv6.h>
 #include <linux/in.h>
+#include <linux/jhash.h>
+#include <linux/random.h>
 
 #include "net-sysfs.h"
 
@@ -259,7 +261,7 @@ static RAW_NOTIFIER_HEAD(netdev_chain);
 
 DEFINE_PER_CPU(struct softnet_data, softnet_data);
 
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
+#ifdef CONFIG_LOCKDEP
 /*
  * register_netdevice() inits txq->_xmit_lock and sets lockdep class
  * according to dev->type
@@ -299,6 +301,7 @@ static const char *netdev_lock_name[] =
          "_xmit_NONE"};
 
 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
+static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
 
 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
 {
@@ -311,8 +314,8 @@ static inline unsigned short netdev_lock_pos(unsigned short dev_type)
         return ARRAY_SIZE(netdev_lock_type) - 1;
 }
 
-static inline void netdev_set_lockdep_class(spinlock_t *lock,
-                                            unsigned short dev_type)
+static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
+                                                 unsigned short dev_type)
 {
         int i;
 
@@ -320,9 +323,22 @@ static inline void netdev_set_lockdep_class(spinlock_t *lock,
         lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
                                    netdev_lock_name[i]);
 }
+
+static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
+{
+        int i;
+
+        i = netdev_lock_pos(dev->type);
+        lockdep_set_class_and_name(&dev->addr_list_lock,
+                                   &netdev_addr_lock_key[i],
+                                   netdev_lock_name[i]);
+}
 #else
-static inline void netdev_set_lockdep_class(spinlock_t *lock,
-                                            unsigned short dev_type)
+static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
+                                                 unsigned short dev_type)
+{
+}
+static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
 {
 }
 #endif
@@ -1325,7 +1341,8 @@ static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
 
 void __netif_schedule(struct Qdisc *q)
 {
-        BUG_ON(q == &noop_qdisc);
+        if (WARN_ON_ONCE(q == &noop_qdisc))
+                return;
 
         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state)) {
                 struct softnet_data *sd;
@@ -1642,60 +1659,37 @@ out_kfree_skb:
         return 0;
 }
 
-/**
- *      dev_queue_xmit - transmit a buffer
- *      @skb: buffer to transmit
- *
- *      Queue a buffer for transmission to a network device. The caller must
- *      have set the device and priority and built the buffer before calling
- *      this function. The function can be called from an interrupt.
- *
- *      A negative errno code is returned on a failure. A success does not
- *      guarantee the frame will be transmitted as it may be dropped due
- *      to congestion or traffic shaping.
- *
- * -----------------------------------------------------------------------------------
- *      I notice this method can also return errors from the queue disciplines,
- *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
- *      be positive.
- *
- *      Regardless of the return value, the skb is consumed, so it is currently
- *      difficult to retry a send to this method.  (You can bump the ref count
- *      before sending to hold a reference for retry if you are careful.)
- *
- *      When calling this method, interrupts MUST be enabled.  This is because
- *      the BH enable code must have IRQs enabled so that it will not deadlock.
- *          --BLG
- */
+static u32 simple_tx_hashrnd;
+static int simple_tx_hashrnd_initialized = 0;
 
 static u16 simple_tx_hash(struct net_device *dev, struct sk_buff *skb)
 {
-        u32 *addr, *ports, hash, ihl;
+        u32 addr1, addr2, ports;
+        u32 hash, ihl;
         u8 ip_proto;
-        int alen;
+
+        if (unlikely(!simple_tx_hashrnd_initialized)) {
+                get_random_bytes(&simple_tx_hashrnd, 4);
+                simple_tx_hashrnd_initialized = 1;
+        }
 
         switch (skb->protocol) {
         case __constant_htons(ETH_P_IP):
                 ip_proto = ip_hdr(skb)->protocol;
-                addr = &ip_hdr(skb)->saddr;
+                addr1 = ip_hdr(skb)->saddr;
+                addr2 = ip_hdr(skb)->daddr;
                 ihl = ip_hdr(skb)->ihl;
-                alen = 2;
                 break;
         case __constant_htons(ETH_P_IPV6):
                 ip_proto = ipv6_hdr(skb)->nexthdr;
-                addr = &ipv6_hdr(skb)->saddr.s6_addr32[0];
+                addr1 = ipv6_hdr(skb)->saddr.s6_addr32[3];
+                addr2 = ipv6_hdr(skb)->daddr.s6_addr32[3];
                 ihl = (40 >> 2);
-                alen = 8;
                 break;
         default:
                 return 0;
         }
 
-        ports = (u32 *) (skb_network_header(skb) + (ihl * 4));
-
-        hash = 0;
-        while (alen--)
-                hash ^= *addr++;
 
         switch (ip_proto) {
         case IPPROTO_TCP:
@@ -1705,14 +1699,17 @@ static u16 simple_tx_hash(struct net_device *dev, struct sk_buff *skb)
         case IPPROTO_AH:
         case IPPROTO_SCTP:
         case IPPROTO_UDPLITE:
-                hash ^= *ports;
+                ports = *((u32 *) (skb_network_header(skb) + (ihl * 4)));
                 break;
 
         default:
+                ports = 0;
                 break;
         }
 
-        return hash % dev->real_num_tx_queues;
+        hash = jhash_3words(addr1, addr2, ports, simple_tx_hashrnd);
+
+        return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
 }
 
 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
@@ -1729,6 +1726,31 @@ static struct netdev_queue *dev_pick_tx(struct net_device *dev,
         return netdev_get_tx_queue(dev, queue_index);
 }
 
+/**
+ *      dev_queue_xmit - transmit a buffer
+ *      @skb: buffer to transmit
+ *
+ *      Queue a buffer for transmission to a network device. The caller must
+ *      have set the device and priority and built the buffer before calling
+ *      this function. The function can be called from an interrupt.
+ *
+ *      A negative errno code is returned on a failure. A success does not
+ *      guarantee the frame will be transmitted as it may be dropped due
+ *      to congestion or traffic shaping.
+ *
+ * -----------------------------------------------------------------------------------
+ *      I notice this method can also return errors from the queue disciplines,
+ *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
+ *      be positive.
+ *
+ *      Regardless of the return value, the skb is consumed, so it is currently
+ *      difficult to retry a send to this method.  (You can bump the ref count
+ *      before sending to hold a reference for retry if you are careful.)
+ *
+ *      When calling this method, interrupts MUST be enabled.  This is because
+ *      the BH enable code must have IRQs enabled so that it will not deadlock.
+ *          --BLG
+ */
 int dev_queue_xmit(struct sk_buff *skb)
 {
         struct net_device *dev = skb->dev;
@@ -3843,7 +3865,7 @@ static void __netdev_init_queue_locks_one(struct net_device *dev,
                                           void *_unused)
 {
         spin_lock_init(&dev_queue->_xmit_lock);
-        netdev_set_lockdep_class(&dev_queue->_xmit_lock, dev->type);
+        netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
         dev_queue->xmit_lock_owner = -1;
 }
 
@@ -3888,6 +3910,7 @@ int register_netdevice(struct net_device *dev)
         net = dev_net(dev);
 
         spin_lock_init(&dev->addr_list_lock);
+        netdev_set_addr_lockdep_class(dev);
         netdev_init_queue_locks(dev);
 
         dev->iflink = -1;
@@ -4198,7 +4221,7 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
 {
         struct netdev_queue *tx;
         struct net_device *dev;
-        int alloc_size;
+        size_t alloc_size;
         void *p;
 
         BUG_ON(strlen(name) >= sizeof(dev->name));
@@ -4218,7 +4241,7 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
                 return NULL;
         }
 
-        tx = kzalloc(sizeof(struct netdev_queue) * queue_count, GFP_KERNEL);
+        tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
         if (!tx) {
                 printk(KERN_ERR "alloc_netdev: Unable to allocate "
                        "tx qdiscs.\n");
@@ -4677,6 +4700,26 @@ err_name:
         return -ENOMEM;
 }
 
+char *netdev_drivername(struct net_device *dev, char *buffer, int len)
+{
+        struct device_driver *driver;
+        struct device *parent;
+
+        if (len <= 0 || !buffer)
+                return buffer;
+        buffer[0] = 0;
+
+        parent = dev->dev.parent;
+
+        if (!parent)
+                return buffer;
+
+        driver = parent->driver;
+        if (driver && driver->name)
+                strlcpy(buffer, driver->name, len);
+        return buffer;
+}
+
 static void __net_exit netdev_exit(struct net *net)
 {
         kfree(net->dev_name_head);
diff --git a/net/core/user_dma.c b/net/core/user_dma.c
index c77aff9c6eb3..8c6b706963ff 100644
--- a/net/core/user_dma.c
+++ b/net/core/user_dma.c
@@ -34,6 +34,7 @@
 #define NET_DMA_DEFAULT_COPYBREAK 4096
 
 int sysctl_tcp_dma_copybreak = NET_DMA_DEFAULT_COPYBREAK;
+EXPORT_SYMBOL(sysctl_tcp_dma_copybreak);
 
 /**
  *      dma_skb_copy_datagram_iovec - Copy a datagram to an iovec.
diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c
index 40a46d482490..3a020720e40b 100644
--- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c
+++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c
@@ -18,19 +18,7 @@
 #include <net/netfilter/nf_conntrack_l3proto.h>
 #include <net/netfilter/nf_conntrack_l4proto.h>
 #include <net/netfilter/nf_conntrack_expect.h>
-
-#ifdef CONFIG_NF_CT_ACCT
-static unsigned int
-seq_print_counters(struct seq_file *s,
-                   const struct ip_conntrack_counter *counter)
-{
-        return seq_printf(s, "packets=%llu bytes=%llu ",
-                          (unsigned long long)counter->packets,
-                          (unsigned long long)counter->bytes);
-}
-#else
-#define seq_print_counters(x, y)        0
-#endif
+#include <net/netfilter/nf_conntrack_acct.h>
 
 struct ct_iter_state {
         unsigned int bucket;
@@ -127,7 +115,7 @@ static int ct_seq_show(struct seq_file *s, void *v)
                         l3proto, l4proto))
                 return -ENOSPC;
 
-        if (seq_print_counters(s, &ct->counters[IP_CT_DIR_ORIGINAL]))
+        if (seq_print_acct(s, ct, IP_CT_DIR_ORIGINAL))
                 return -ENOSPC;
 
         if (!(test_bit(IPS_SEEN_REPLY_BIT, &ct->status)))
@@ -138,7 +126,7 @@ static int ct_seq_show(struct seq_file *s, void *v)
                         l3proto, l4proto))
                 return -ENOSPC;
 
-        if (seq_print_counters(s, &ct->counters[IP_CT_DIR_REPLY]))
+        if (seq_print_acct(s, ct, IP_CT_DIR_REPLY))
                 return -ENOSPC;
 
         if (test_bit(IPS_ASSURED_BIT, &ct->status))
diff --git a/net/ipv4/netfilter/nf_nat_core.c b/net/ipv4/netfilter/nf_nat_core.c
index d2a887fc8d9b..6c6a3cba8d50 100644
--- a/net/ipv4/netfilter/nf_nat_core.c
+++ b/net/ipv4/netfilter/nf_nat_core.c
@@ -240,12 +240,12 @@ get_unique_tuple(struct nf_conntrack_tuple *tuple,
            This is only required for source (ie. NAT/masq) mappings.
            So far, we don't do local source mappings, so multiple
            manips not an issue.  */
-        if (maniptype == IP_NAT_MANIP_SRC) {
+        if (maniptype == IP_NAT_MANIP_SRC &&
+            !(range->flags & IP_NAT_RANGE_PROTO_RANDOM)) {
                 if (find_appropriate_src(orig_tuple, tuple, range)) {
                         pr_debug("get_unique_tuple: Found current src map\n");
-                        if (!(range->flags & IP_NAT_RANGE_PROTO_RANDOM))
-                                if (!nf_nat_used_tuple(tuple, ct))
-                                        return;
+                        if (!nf_nat_used_tuple(tuple, ct))
+                                return;
                 }
         }
 
diff --git a/net/ipv4/netfilter/nf_nat_sip.c b/net/ipv4/netfilter/nf_nat_sip.c
index 4334d5cabc5b..14544320c545 100644
--- a/net/ipv4/netfilter/nf_nat_sip.c
+++ b/net/ipv4/netfilter/nf_nat_sip.c
@@ -318,11 +318,11 @@ static int mangle_content_len(struct sk_buff *skb,
                              buffer, buflen);
 }
 
-static unsigned mangle_sdp_packet(struct sk_buff *skb, const char **dptr,
-                                  unsigned int dataoff, unsigned int *datalen,
-                                  enum sdp_header_types type,
-                                  enum sdp_header_types term,
-                                  char *buffer, int buflen)
+static int mangle_sdp_packet(struct sk_buff *skb, const char **dptr,
+                             unsigned int dataoff, unsigned int *datalen,
+                             enum sdp_header_types type,
+                             enum sdp_header_types term,
+                             char *buffer, int buflen)
 {
         enum ip_conntrack_info ctinfo;
         struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
@@ -330,9 +330,9 @@ static unsigned mangle_sdp_packet(struct sk_buff *skb, const char **dptr,
 
         if (ct_sip_get_sdp_header(ct, *dptr, dataoff, *datalen, type, term,
                                   &matchoff, &matchlen) <= 0)
-                return 0;
+                return -ENOENT;
         return mangle_packet(skb, dptr, datalen, matchoff, matchlen,
-                             buffer, buflen);
+                             buffer, buflen) ? 0 : -EINVAL;
 }
 
 static unsigned int ip_nat_sdp_addr(struct sk_buff *skb, const char **dptr,
@@ -346,8 +346,8 @@ static unsigned int ip_nat_sdp_addr(struct sk_buff *skb, const char **dptr,
         unsigned int buflen;
 
         buflen = sprintf(buffer, NIPQUAD_FMT, NIPQUAD(addr->ip));
-        if (!mangle_sdp_packet(skb, dptr, dataoff, datalen, type, term,
-                               buffer, buflen))
+        if (mangle_sdp_packet(skb, dptr, dataoff, datalen, type, term,
+                              buffer, buflen))
                 return 0;
 
         return mangle_content_len(skb, dptr, datalen);
@@ -381,15 +381,27 @@ static unsigned int ip_nat_sdp_session(struct sk_buff *skb, const char **dptr,
 
         /* Mangle session description owner and contact addresses */
         buflen = sprintf(buffer, "%u.%u.%u.%u", NIPQUAD(addr->ip));
-        if (!mangle_sdp_packet(skb, dptr, dataoff, datalen,
+        if (mangle_sdp_packet(skb, dptr, dataoff, datalen,
                                SDP_HDR_OWNER_IP4, SDP_HDR_MEDIA,
                                buffer, buflen))
                 return 0;
 
-        if (!mangle_sdp_packet(skb, dptr, dataoff, datalen,
-                               SDP_HDR_CONNECTION_IP4, SDP_HDR_MEDIA,
-                               buffer, buflen))
+        switch (mangle_sdp_packet(skb, dptr, dataoff, datalen,
+                                  SDP_HDR_CONNECTION_IP4, SDP_HDR_MEDIA,
+                                  buffer, buflen)) {
+        case 0:
+        /*
+         * RFC 2327:
+         *
+         * Session description
+         *
+         * c=* (connection information - not required if included in all media)
+         */
+        case -ENOENT:
+                break;
+        default:
                 return 0;
+        }
 
         return mangle_content_len(skb, dptr, datalen);
 }
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 1fa683c0ba9b..a00532de2a8c 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -472,7 +472,7 @@ static unsigned tcp_syn_options(struct sock *sk, struct sk_buff *skb,
         }
         if (likely(sysctl_tcp_sack)) {
                 opts->options |= OPTION_SACK_ADVERTISE;
-                if (unlikely(!OPTION_TS & opts->options))
+                if (unlikely(!(OPTION_TS & opts->options)))
                         size += TCPOLEN_SACKPERM_ALIGNED;
         }
 
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index a751770947a3..383d17359d01 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -1325,6 +1325,8 @@ int udp_lib_setsockopt(struct sock *sk, int level, int optname,
                         return -ENOPROTOOPT;
                 if (val != 0 && val < 8) /* Illegal coverage: use default (8) */
                         val = 8;
+                else if (val > USHORT_MAX)
+                        val = USHORT_MAX;
                 up->pcslen = val;
                 up->pcflag |= UDPLITE_SEND_CC;
                 break;
@@ -1337,6 +1339,8 @@ int udp_lib_setsockopt(struct sock *sk, int level, int optname,
                         return -ENOPROTOOPT;
                 if (val != 0 && val < 8) /* Avoid silly minimal values.       */
                         val = 8;
+                else if (val > USHORT_MAX)
+                        val = USHORT_MAX;
                 up->pcrlen = val;
                 up->pcflag |= UDPLITE_RECV_CC;
                 break;
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 9f4fcce6379b..74d543d504a1 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -153,7 +153,7 @@ static int ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
 
 static ATOMIC_NOTIFIER_HEAD(inet6addr_chain);
 
-struct ipv6_devconf ipv6_devconf __read_mostly = {
+static struct ipv6_devconf ipv6_devconf __read_mostly = {
         .forwarding             = 0,
         .hop_limit              = IPV6_DEFAULT_HOPLIMIT,
         .mtu6                   = IPV6_MIN_MTU,
diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index 4de2b9efcacb..08ea2de28d63 100644
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -661,17 +661,17 @@ static int fib6_add_rt2node(struct fib6_node *fn, struct rt6_info *rt,
 
 static __inline__ void fib6_start_gc(struct net *net, struct rt6_info *rt)
 {
-        if (net->ipv6.ip6_fib_timer->expires == 0 &&
+        if (!timer_pending(&net->ipv6.ip6_fib_timer) &&
             (rt->rt6i_flags & (RTF_EXPIRES|RTF_CACHE)))
-                mod_timer(net->ipv6.ip6_fib_timer, jiffies +
-                          net->ipv6.sysctl.ip6_rt_gc_interval);
+                mod_timer(&net->ipv6.ip6_fib_timer,
+                          jiffies + net->ipv6.sysctl.ip6_rt_gc_interval);
 }
 
 void fib6_force_start_gc(struct net *net)
 {
-        if (net->ipv6.ip6_fib_timer->expires == 0)
-                mod_timer(net->ipv6.ip6_fib_timer, jiffies +
-                          net->ipv6.sysctl.ip6_rt_gc_interval);
+        if (!timer_pending(&net->ipv6.ip6_fib_timer))
+                mod_timer(&net->ipv6.ip6_fib_timer,
+                          jiffies + net->ipv6.sysctl.ip6_rt_gc_interval);
 }
 
 /*
@@ -1447,27 +1447,23 @@ void fib6_run_gc(unsigned long expires, struct net *net)
                 gc_args.timeout = expires ? (int)expires :
                         net->ipv6.sysctl.ip6_rt_gc_interval;
         } else {
-                local_bh_disable();
-                if (!spin_trylock(&fib6_gc_lock)) {
-                        mod_timer(net->ipv6.ip6_fib_timer, jiffies + HZ);
-                        local_bh_enable();
+                if (!spin_trylock_bh(&fib6_gc_lock)) {
+                        mod_timer(&net->ipv6.ip6_fib_timer, jiffies + HZ);
                         return;
                 }
                 gc_args.timeout = net->ipv6.sysctl.ip6_rt_gc_interval;
         }
-        gc_args.more = 0;
 
-        icmp6_dst_gc(&gc_args.more);
+        gc_args.more = icmp6_dst_gc();
 
         fib6_clean_all(net, fib6_age, 0, NULL);
 
         if (gc_args.more)
-                mod_timer(net->ipv6.ip6_fib_timer, jiffies +
-                          net->ipv6.sysctl.ip6_rt_gc_interval);
-        else {
-                del_timer(net->ipv6.ip6_fib_timer);
-                net->ipv6.ip6_fib_timer->expires = 0;
-        }
+                mod_timer(&net->ipv6.ip6_fib_timer,
+                          round_jiffies(jiffies
+                                        + net->ipv6.sysctl.ip6_rt_gc_interval));
+        else
+                del_timer(&net->ipv6.ip6_fib_timer);
         spin_unlock_bh(&fib6_gc_lock);
 }
 
@@ -1478,24 +1474,15 @@ static void fib6_gc_timer_cb(unsigned long arg)
 
 static int fib6_net_init(struct net *net)
 {
-        int ret;
-        struct timer_list *timer;
-
-        ret = -ENOMEM;
-        timer = kzalloc(sizeof(*timer), GFP_KERNEL);
-        if (!timer)
-                goto out;
-
-        setup_timer(timer, fib6_gc_timer_cb, (unsigned long)net);
-        net->ipv6.ip6_fib_timer = timer;
+        setup_timer(&net->ipv6.ip6_fib_timer, fib6_gc_timer_cb, (unsigned long)net);
 
         net->ipv6.rt6_stats = kzalloc(sizeof(*net->ipv6.rt6_stats), GFP_KERNEL);
         if (!net->ipv6.rt6_stats)
                 goto out_timer;
 
-        net->ipv6.fib_table_hash =
-                kzalloc(sizeof(*net->ipv6.fib_table_hash)*FIB_TABLE_HASHSZ,
-                        GFP_KERNEL);
+        net->ipv6.fib_table_hash = kcalloc(FIB_TABLE_HASHSZ,
+                                           sizeof(*net->ipv6.fib_table_hash),
+                                           GFP_KERNEL);
         if (!net->ipv6.fib_table_hash)
                 goto out_rt6_stats;
 
@@ -1521,9 +1508,7 @@ static int fib6_net_init(struct net *net)
 #endif
         fib6_tables_init(net);
 
-        ret = 0;
-out:
-        return ret;
+        return 0;
 
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 out_fib6_main_tbl:
@@ -1534,15 +1519,14 @@ out_fib_table_hash:
 out_rt6_stats:
         kfree(net->ipv6.rt6_stats);
 out_timer:
-        kfree(timer);
-        goto out;
+        return -ENOMEM;
  }
 
 static void fib6_net_exit(struct net *net)
 {
         rt6_ifdown(net, NULL);
-        del_timer_sync(net->ipv6.ip6_fib_timer);
-        kfree(net->ipv6.ip6_fib_timer);
+        del_timer_sync(&net->ipv6.ip6_fib_timer);
+
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
         kfree(net->ipv6.fib6_local_tbl);
 #endif
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 615b328de251..86540b24b27c 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -978,13 +978,12 @@ out:
         return &rt->u.dst;
 }
 
-int icmp6_dst_gc(int *more)
+int icmp6_dst_gc(void)
 {
         struct dst_entry *dst, *next, **pprev;
-        int freed;
+        int more = 0;
 
         next = NULL;
-        freed = 0;
 
         spin_lock_bh(&icmp6_dst_lock);
         pprev = &icmp6_dst_gc_list;
@@ -993,16 +992,15 @@ int icmp6_dst_gc(int *more)
                 if (!atomic_read(&dst->__refcnt)) {
                         *pprev = dst->next;
                         dst_free(dst);
-                        freed++;
                 } else {
                         pprev = &dst->next;
-                        (*more)++;
+                        ++more;
                 }
         }
 
         spin_unlock_bh(&icmp6_dst_lock);
 
-        return freed;
+        return more;
 }
 
 static int ip6_dst_gc(struct dst_ops *ops)
diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig
index 316c7af1d2b1..ee898e74808d 100644
--- a/net/netfilter/Kconfig
+++ b/net/netfilter/Kconfig
@@ -49,6 +49,15 @@ config NF_CT_ACCT
           Those counters can be used for flow-based accounting or the
           `connbytes' match.
 
+          Please note that currently this option only sets a default state.
+          You may change it at boot time with nf_conntrack.acct=0/1 kernel
+          paramater or by loading the nf_conntrack module with acct=0/1.
+
+          You may also disable/enable it on a running system with:
+           sysctl net.netfilter.nf_conntrack_acct=0/1
+
+          This option will be removed in 2.6.29.
+
           If unsure, say `N'.
 
 config NF_CONNTRACK_MARK
diff --git a/net/netfilter/Makefile b/net/netfilter/Makefile
index 5c4b183f6422..3bd2cc556aea 100644
--- a/net/netfilter/Makefile
+++ b/net/netfilter/Makefile
@@ -1,6 +1,6 @@
 netfilter-objs := core.o nf_log.o nf_queue.o nf_sockopt.o
 
-nf_conntrack-y  := nf_conntrack_core.o nf_conntrack_standalone.o nf_conntrack_expect.o nf_conntrack_helper.o nf_conntrack_proto.o nf_conntrack_l3proto_generic.o nf_conntrack_proto_generic.o nf_conntrack_proto_tcp.o nf_conntrack_proto_udp.o nf_conntrack_extend.o
+nf_conntrack-y  := nf_conntrack_core.o nf_conntrack_standalone.o nf_conntrack_expect.o nf_conntrack_helper.o nf_conntrack_proto.o nf_conntrack_l3proto_generic.o nf_conntrack_proto_generic.o nf_conntrack_proto_tcp.o nf_conntrack_proto_udp.o nf_conntrack_extend.o nf_conntrack_acct.o
 nf_conntrack-$(CONFIG_NF_CONNTRACK_EVENTS) += nf_conntrack_ecache.o
 
 obj-$(CONFIG_NETFILTER) = netfilter.o
diff --git a/net/netfilter/nf_conntrack_acct.c b/net/netfilter/nf_conntrack_acct.c
new file mode 100644
index 000000000000..59bd8b903a19
--- /dev/null
+++ b/net/netfilter/nf_conntrack_acct.c
@@ -0,0 +1,104 @@
+/* Accouting handling for netfilter. */
+
+/*
+ * (C) 2008 Krzysztof Piotr Oledzki <ole@ans.pl>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/netfilter.h>
+#include <linux/kernel.h>
+#include <linux/moduleparam.h>
+
+#include <net/netfilter/nf_conntrack.h>
+#include <net/netfilter/nf_conntrack_extend.h>
+#include <net/netfilter/nf_conntrack_acct.h>
+
+#ifdef CONFIG_NF_CT_ACCT
+#define NF_CT_ACCT_DEFAULT 1
+#else
+#define NF_CT_ACCT_DEFAULT 0
+#endif
+
+int nf_ct_acct __read_mostly = NF_CT_ACCT_DEFAULT;
+EXPORT_SYMBOL_GPL(nf_ct_acct);
+
+module_param_named(acct, nf_ct_acct, bool, 0644);
+MODULE_PARM_DESC(acct, "Enable connection tracking flow accounting.");
+
+#ifdef CONFIG_SYSCTL
+static struct ctl_table_header *acct_sysctl_header;
+static struct ctl_table acct_sysctl_table[] = {
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "nf_conntrack_acct",
+                .data           = &nf_ct_acct,
+                .maxlen         = sizeof(unsigned int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec,
+        },
+        {}
+};
+#endif /* CONFIG_SYSCTL */
+
+unsigned int
+seq_print_acct(struct seq_file *s, const struct nf_conn *ct, int dir)
+{
+        struct nf_conn_counter *acct;
+
+        acct = nf_conn_acct_find(ct);
+        if (!acct)
+                return 0;
+
+        return seq_printf(s, "packets=%llu bytes=%llu ",
+                          (unsigned long long)acct[dir].packets,
+                          (unsigned long long)acct[dir].bytes);
+};
+EXPORT_SYMBOL_GPL(seq_print_acct);
+
+static struct nf_ct_ext_type acct_extend __read_mostly = {
+        .len    = sizeof(struct nf_conn_counter[IP_CT_DIR_MAX]),
+        .align  = __alignof__(struct nf_conn_counter[IP_CT_DIR_MAX]),
+        .id     = NF_CT_EXT_ACCT,
+};
+
+int nf_conntrack_acct_init(void)
+{
+        int ret;
+
+#ifdef CONFIG_NF_CT_ACCT
+        printk(KERN_WARNING "CONFIG_NF_CT_ACCT is deprecated and will be removed soon. Plase use\n");
+        printk(KERN_WARNING "nf_conntrack.acct=1 kernel paramater, acct=1 nf_conntrack module option or\n");
+        printk(KERN_WARNING "sysctl net.netfilter.nf_conntrack_acct=1 to enable it.\n");
+#endif
+
+        ret = nf_ct_extend_register(&acct_extend);
+        if (ret < 0) {
+                printk(KERN_ERR "nf_conntrack_acct: Unable to register extension\n");
+                return ret;
+        }
+
+#ifdef CONFIG_SYSCTL
+        acct_sysctl_header = register_sysctl_paths(nf_net_netfilter_sysctl_path,
+                                acct_sysctl_table);
+
+        if (!acct_sysctl_header) {
+                nf_ct_extend_unregister(&acct_extend);
+
+                printk(KERN_ERR "nf_conntrack_acct: can't register to sysctl.\n");
+                return -ENOMEM;
+        }
+#endif
+
+        return 0;
+}
+
+void nf_conntrack_acct_fini(void)
+{
+#ifdef CONFIG_SYSCTL
+        unregister_sysctl_table(acct_sysctl_header);
+#endif
+        nf_ct_extend_unregister(&acct_extend);
+}
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 28d03e64200b..c519d090bdb9 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -37,6 +37,7 @@
 #include <net/netfilter/nf_conntrack_helper.h>
 #include <net/netfilter/nf_conntrack_core.h>
 #include <net/netfilter/nf_conntrack_extend.h>
+#include <net/netfilter/nf_conntrack_acct.h>
 
 #define NF_CONNTRACK_VERSION    "0.5.0"
 
@@ -555,6 +556,8 @@ init_conntrack(const struct nf_conntrack_tuple *tuple,
                 return NULL;
         }
 
+        nf_ct_acct_ext_add(ct, GFP_ATOMIC);
+
         spin_lock_bh(&nf_conntrack_lock);
         exp = nf_ct_find_expectation(tuple);
         if (exp) {
@@ -828,17 +831,16 @@ void __nf_ct_refresh_acct(struct nf_conn *ct,
         }
 
 acct:
-#ifdef CONFIG_NF_CT_ACCT
         if (do_acct) {
-                ct->counters[CTINFO2DIR(ctinfo)].packets++;
-                ct->counters[CTINFO2DIR(ctinfo)].bytes +=
-                        skb->len - skb_network_offset(skb);
+                struct nf_conn_counter *acct;
 
-                if ((ct->counters[CTINFO2DIR(ctinfo)].packets & 0x80000000)
-                    || (ct->counters[CTINFO2DIR(ctinfo)].bytes & 0x80000000))
-                        event |= IPCT_COUNTER_FILLING;
+                acct = nf_conn_acct_find(ct);
+                if (acct) {
+                        acct[CTINFO2DIR(ctinfo)].packets++;
+                        acct[CTINFO2DIR(ctinfo)].bytes +=
+                                skb->len - skb_network_offset(skb);
+                }
         }
-#endif
 
         spin_unlock_bh(&nf_conntrack_lock);
 
@@ -853,15 +855,19 @@ bool __nf_ct_kill_acct(struct nf_conn *ct,
                        const struct sk_buff *skb,
                        int do_acct)
 {
-#ifdef CONFIG_NF_CT_ACCT
         if (do_acct) {
+                struct nf_conn_counter *acct;
+
                 spin_lock_bh(&nf_conntrack_lock);
-                ct->counters[CTINFO2DIR(ctinfo)].packets++;
-                ct->counters[CTINFO2DIR(ctinfo)].bytes +=
-                        skb->len - skb_network_offset(skb);
+                acct = nf_conn_acct_find(ct);
+                if (acct) {
+                        acct[CTINFO2DIR(ctinfo)].packets++;
+                        acct[CTINFO2DIR(ctinfo)].bytes +=
+                                skb->len - skb_network_offset(skb);
+                }
                 spin_unlock_bh(&nf_conntrack_lock);
         }
-#endif
+
         if (del_timer(&ct->timeout)) {
                 ct->timeout.function((unsigned long)ct);
                 return true;
@@ -1029,6 +1035,7 @@ void nf_conntrack_cleanup(void)
         nf_conntrack_proto_fini();
         nf_conntrack_helper_fini();
         nf_conntrack_expect_fini();
+        nf_conntrack_acct_fini();
 }
 
 struct hlist_head *nf_ct_alloc_hashtable(unsigned int *sizep, int *vmalloced)
@@ -1168,6 +1175,10 @@ int __init nf_conntrack_init(void)
         if (ret < 0)
                 goto out_fini_expect;
 
+        ret = nf_conntrack_acct_init();
+        if (ret < 0)
+                goto out_fini_helper;
+
         /* For use by REJECT target */
         rcu_assign_pointer(ip_ct_attach, nf_conntrack_attach);
         rcu_assign_pointer(nf_ct_destroy, destroy_conntrack);
@@ -1180,6 +1191,8 @@ int __init nf_conntrack_init(void)
 
         return ret;
 
+out_fini_helper:
+        nf_conntrack_helper_fini();
 out_fini_expect:
         nf_conntrack_expect_fini();
 out_fini_proto:
diff --git a/net/netfilter/nf_conntrack_netlink.c b/net/netfilter/nf_conntrack_netlink.c
index 95a7967731f9..105a616c5c78 100644
--- a/net/netfilter/nf_conntrack_netlink.c
+++ b/net/netfilter/nf_conntrack_netlink.c
@@ -37,6 +37,7 @@
 #include <net/netfilter/nf_conntrack_l3proto.h>
 #include <net/netfilter/nf_conntrack_l4proto.h>
 #include <net/netfilter/nf_conntrack_tuple.h>
+#include <net/netfilter/nf_conntrack_acct.h>
 #ifdef CONFIG_NF_NAT_NEEDED
 #include <net/netfilter/nf_nat_core.h>
 #include <net/netfilter/nf_nat_protocol.h>
@@ -206,22 +207,26 @@ nla_put_failure:
         return -1;
 }
 
-#ifdef CONFIG_NF_CT_ACCT
 static int
 ctnetlink_dump_counters(struct sk_buff *skb, const struct nf_conn *ct,
                         enum ip_conntrack_dir dir)
 {
         enum ctattr_type type = dir ? CTA_COUNTERS_REPLY: CTA_COUNTERS_ORIG;
         struct nlattr *nest_count;
+        const struct nf_conn_counter *acct;
+
+        acct = nf_conn_acct_find(ct);
+        if (!acct)
+                return 0;
 
         nest_count = nla_nest_start(skb, type | NLA_F_NESTED);
         if (!nest_count)
                 goto nla_put_failure;
 
-        NLA_PUT_BE32(skb, CTA_COUNTERS32_PACKETS,
-                     htonl(ct->counters[dir].packets));
-        NLA_PUT_BE32(skb, CTA_COUNTERS32_BYTES,
-                     htonl(ct->counters[dir].bytes));
+        NLA_PUT_BE64(skb, CTA_COUNTERS_PACKETS,
+                     cpu_to_be64(acct[dir].packets));
+        NLA_PUT_BE64(skb, CTA_COUNTERS_BYTES,
+                     cpu_to_be64(acct[dir].bytes));
 
         nla_nest_end(skb, nest_count);
 
@@ -230,9 +235,6 @@ ctnetlink_dump_counters(struct sk_buff *skb, const struct nf_conn *ct,
 nla_put_failure:
         return -1;
 }
-#else
-#define ctnetlink_dump_counters(a, b, c) (0)
-#endif
 
 #ifdef CONFIG_NF_CONNTRACK_MARK
 static inline int
@@ -501,11 +503,6 @@ static int ctnetlink_conntrack_event(struct notifier_block *this,
                         goto nla_put_failure;
 #endif
 
-                if (events & IPCT_COUNTER_FILLING &&
-                    (ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 ||
-                     ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0))
-                        goto nla_put_failure;
-
                 if (events & IPCT_RELATED &&
                     ctnetlink_dump_master(skb, ct) < 0)
                         goto nla_put_failure;
@@ -576,11 +573,15 @@ restart:
                                 cb->args[1] = (unsigned long)ct;
                                 goto out;
                         }
-#ifdef CONFIG_NF_CT_ACCT
+
                         if (NFNL_MSG_TYPE(cb->nlh->nlmsg_type) ==
-                                                IPCTNL_MSG_CT_GET_CTRZERO)
-                                memset(&ct->counters, 0, sizeof(ct->counters));
-#endif
+                                                IPCTNL_MSG_CT_GET_CTRZERO) {
+                                struct nf_conn_counter *acct;
+
+                                acct = nf_conn_acct_find(ct);
+                                if (acct)
+                                        memset(acct, 0, sizeof(struct nf_conn_counter[IP_CT_DIR_MAX]));
+                        }
                 }
                 if (cb->args[1]) {
                         cb->args[1] = 0;
@@ -832,14 +833,9 @@ ctnetlink_get_conntrack(struct sock *ctnl, struct sk_buff *skb,
         u_int8_t u3 = nfmsg->nfgen_family;
         int err = 0;
 
-        if (nlh->nlmsg_flags & NLM_F_DUMP) {
-#ifndef CONFIG_NF_CT_ACCT
-                if (NFNL_MSG_TYPE(nlh->nlmsg_type) == IPCTNL_MSG_CT_GET_CTRZERO)
-                        return -ENOTSUPP;
-#endif
+        if (nlh->nlmsg_flags & NLM_F_DUMP)
                 return netlink_dump_start(ctnl, skb, nlh, ctnetlink_dump_table,
                                           ctnetlink_done);
-        }
 
         if (cda[CTA_TUPLE_ORIG])
                 err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3);
@@ -1152,6 +1148,8 @@ ctnetlink_create_conntrack(struct nlattr *cda[],
                         goto err;
         }
 
+        nf_ct_acct_ext_add(ct, GFP_KERNEL);
+
 #if defined(CONFIG_NF_CONNTRACK_MARK)
         if (cda[CTA_MARK])
                 ct->mark = ntohl(nla_get_be32(cda[CTA_MARK]));
diff --git a/net/netfilter/nf_conntrack_proto_sctp.c b/net/netfilter/nf_conntrack_proto_sctp.c
index 41183a4d2d62..30aa5b94a771 100644
--- a/net/netfilter/nf_conntrack_proto_sctp.c
+++ b/net/netfilter/nf_conntrack_proto_sctp.c
@@ -482,11 +482,11 @@ static int sctp_to_nlattr(struct sk_buff *skb, struct nlattr *nla,
 
         NLA_PUT_BE32(skb,
                      CTA_PROTOINFO_SCTP_VTAG_ORIGINAL,
-                     htonl(ct->proto.sctp.vtag[IP_CT_DIR_ORIGINAL]));
+                     ct->proto.sctp.vtag[IP_CT_DIR_ORIGINAL]);
 
         NLA_PUT_BE32(skb,
                      CTA_PROTOINFO_SCTP_VTAG_REPLY,
-                     htonl(ct->proto.sctp.vtag[IP_CT_DIR_REPLY]));
+                     ct->proto.sctp.vtag[IP_CT_DIR_REPLY]);
 
         read_unlock_bh(&sctp_lock);
 
@@ -530,9 +530,9 @@ static int nlattr_to_sctp(struct nlattr *cda[], struct nf_conn *ct)
         write_lock_bh(&sctp_lock);
         ct->proto.sctp.state = nla_get_u8(tb[CTA_PROTOINFO_SCTP_STATE]);
         ct->proto.sctp.vtag[IP_CT_DIR_ORIGINAL] =
-                ntohl(nla_get_be32(tb[CTA_PROTOINFO_SCTP_VTAG_ORIGINAL]));
+                nla_get_be32(tb[CTA_PROTOINFO_SCTP_VTAG_ORIGINAL]);
         ct->proto.sctp.vtag[IP_CT_DIR_REPLY] =
-                ntohl(nla_get_be32(tb[CTA_PROTOINFO_SCTP_VTAG_REPLY]));
+                nla_get_be32(tb[CTA_PROTOINFO_SCTP_VTAG_REPLY]);
         write_unlock_bh(&sctp_lock);
 
         return 0;
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index 46ea542d0df9..869ef9349d0f 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -25,6 +25,7 @@
 #include <net/netfilter/nf_conntrack_l4proto.h>
 #include <net/netfilter/nf_conntrack_expect.h>
 #include <net/netfilter/nf_conntrack_helper.h>
+#include <net/netfilter/nf_conntrack_acct.h>
 
 MODULE_LICENSE("GPL");
 
@@ -38,19 +39,6 @@ print_tuple(struct seq_file *s, const struct nf_conntrack_tuple *tuple,
 }
 EXPORT_SYMBOL_GPL(print_tuple);
 
-#ifdef CONFIG_NF_CT_ACCT
-static unsigned int
-seq_print_counters(struct seq_file *s,
-                   const struct ip_conntrack_counter *counter)
-{
-        return seq_printf(s, "packets=%llu bytes=%llu ",
-                          (unsigned long long)counter->packets,
-                          (unsigned long long)counter->bytes);
-}
-#else
-#define seq_print_counters(x, y)        0
-#endif
-
 struct ct_iter_state {
         unsigned int bucket;
 };
@@ -146,7 +134,7 @@ static int ct_seq_show(struct seq_file *s, void *v)
                         l3proto, l4proto))
                 return -ENOSPC;
 
-        if (seq_print_counters(s, &ct->counters[IP_CT_DIR_ORIGINAL]))
+        if (seq_print_acct(s, ct, IP_CT_DIR_ORIGINAL))
                 return -ENOSPC;
 
         if (!(test_bit(IPS_SEEN_REPLY_BIT, &ct->status)))
@@ -157,7 +145,7 @@ static int ct_seq_show(struct seq_file *s, void *v)
                         l3proto, l4proto))
                 return -ENOSPC;
 
-        if (seq_print_counters(s, &ct->counters[IP_CT_DIR_REPLY]))
+        if (seq_print_acct(s, ct, IP_CT_DIR_REPLY))
                 return -ENOSPC;
 
         if (test_bit(IPS_ASSURED_BIT, &ct->status))
diff --git a/net/netfilter/nfnetlink_log.c b/net/netfilter/nfnetlink_log.c
index b8173af8c24a..9a35b57ab76d 100644
--- a/net/netfilter/nfnetlink_log.c
+++ b/net/netfilter/nfnetlink_log.c
@@ -453,6 +453,14 @@ __build_packet_message(struct nfulnl_instance *inst,
                 }
         }
 
+        if (indev && skb_mac_header_was_set(skb)) {
+                NLA_PUT_BE16(inst->skb, NFULA_HWTYPE, htons(skb->dev->type));
+                NLA_PUT_BE16(inst->skb, NFULA_HWLEN,
+                             htons(skb->dev->hard_header_len));
+                NLA_PUT(inst->skb, NFULA_HWHEADER, skb->dev->hard_header_len,
+                        skb_mac_header(skb));
+        }
+
         if (skb->tstamp.tv64) {
                 struct nfulnl_msg_packet_timestamp ts;
                 struct timeval tv = ktime_to_timeval(skb->tstamp);
diff --git a/net/netfilter/xt_TCPMSS.c b/net/netfilter/xt_TCPMSS.c
index 217e2b686322..beb5094703cb 100644
--- a/net/netfilter/xt_TCPMSS.c
+++ b/net/netfilter/xt_TCPMSS.c
@@ -147,17 +147,21 @@ tcpmss_mangle_packet(struct sk_buff *skb,
         return TCPOLEN_MSS;
 }
 
-static u_int32_t tcpmss_reverse_mtu4(const struct iphdr *iph)
+static u_int32_t tcpmss_reverse_mtu(const struct sk_buff *skb,
+                                    unsigned int family)
 {
-        struct flowi fl = {
-                .fl4_dst = iph->saddr,
-        };
+        struct flowi fl = {};
         const struct nf_afinfo *ai;
         struct rtable *rt = NULL;
         u_int32_t mtu     = ~0U;
 
+        if (family == PF_INET)
+                fl.fl4_dst = ip_hdr(skb)->saddr;
+        else
+                fl.fl6_dst = ipv6_hdr(skb)->saddr;
+
         rcu_read_lock();
-        ai = nf_get_afinfo(AF_INET);
+        ai = nf_get_afinfo(family);
         if (ai != NULL)
                 ai->route((struct dst_entry **)&rt, &fl);
         rcu_read_unlock();
@@ -178,7 +182,8 @@ tcpmss_tg4(struct sk_buff *skb, const struct net_device *in,
         __be16 newlen;
         int ret;
 
-        ret = tcpmss_mangle_packet(skb, targinfo, tcpmss_reverse_mtu4(iph),
+        ret = tcpmss_mangle_packet(skb, targinfo,
+                                   tcpmss_reverse_mtu(skb, PF_INET),
                                    iph->ihl * 4,
                                    sizeof(*iph) + sizeof(struct tcphdr));
         if (ret < 0)
@@ -193,28 +198,6 @@ tcpmss_tg4(struct sk_buff *skb, const struct net_device *in,
 }
 
 #if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
-static u_int32_t tcpmss_reverse_mtu6(const struct ipv6hdr *iph)
-{
-        struct flowi fl = {
-                .fl6_dst = iph->saddr,
-        };
-        const struct nf_afinfo *ai;
-        struct rtable *rt = NULL;
-        u_int32_t mtu     = ~0U;
-
-        rcu_read_lock();
-        ai = nf_get_afinfo(AF_INET6);
-        if (ai != NULL)
-                ai->route((struct dst_entry **)&rt, &fl);
-        rcu_read_unlock();
-
-        if (rt != NULL) {
-                mtu = dst_mtu(&rt->u.dst);
-                dst_release(&rt->u.dst);
-        }
-        return mtu;
-}
-
 static unsigned int
 tcpmss_tg6(struct sk_buff *skb, const struct net_device *in,
            const struct net_device *out, unsigned int hooknum,
@@ -229,7 +212,8 @@ tcpmss_tg6(struct sk_buff *skb, const struct net_device *in,
         tcphoff = ipv6_skip_exthdr(skb, sizeof(*ipv6h), &nexthdr);
         if (tcphoff < 0)
                 return NF_DROP;
-        ret = tcpmss_mangle_packet(skb, targinfo, tcpmss_reverse_mtu6(ipv6h),
+        ret = tcpmss_mangle_packet(skb, targinfo,
+                                   tcpmss_reverse_mtu(skb, PF_INET6),
                                    tcphoff,
                                    sizeof(*ipv6h) + sizeof(struct tcphdr));
         if (ret < 0)
diff --git a/net/netfilter/xt_connbytes.c b/net/netfilter/xt_connbytes.c
index d7e8983cd37f..3e39c4fe1931 100644
--- a/net/netfilter/xt_connbytes.c
+++ b/net/netfilter/xt_connbytes.c
@@ -8,6 +8,7 @@
 #include <linux/netfilter/x_tables.h>
 #include <linux/netfilter/xt_connbytes.h>
 #include <net/netfilter/nf_conntrack.h>
+#include <net/netfilter/nf_conntrack_acct.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
@@ -27,12 +28,15 @@ connbytes_mt(const struct sk_buff *skb, const struct net_device *in,
         u_int64_t what = 0;     /* initialize to make gcc happy */
         u_int64_t bytes = 0;
         u_int64_t pkts = 0;
-        const struct ip_conntrack_counter *counters;
+        const struct nf_conn_counter *counters;
 
         ct = nf_ct_get(skb, &ctinfo);
         if (!ct)
                 return false;
-        counters = ct->counters;
+
+        counters = nf_conn_acct_find(ct);
+        if (!counters)
+                return false;
 
         switch (sinfo->what) {
         case XT_CONNBYTES_PKTS:
diff --git a/net/netfilter/xt_time.c b/net/netfilter/xt_time.c
index ed76baab4734..9f328593287e 100644
--- a/net/netfilter/xt_time.c
+++ b/net/netfilter/xt_time.c
@@ -173,7 +173,7 @@ time_mt(const struct sk_buff *skb, const struct net_device *in,
                 __net_timestamp((struct sk_buff *)skb);
 
         stamp = ktime_to_ns(skb->tstamp);
-        do_div(stamp, NSEC_PER_SEC);
+        stamp = div_s64(stamp, NSEC_PER_SEC);
 
         if (info->flags & XT_TIME_LOCAL_TZ)
                 /* Adjust for local timezone */
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index fccc250f95f5..532e4faa29f7 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -73,6 +73,7 @@ static const struct proto_ops nr_proto_ops;
  * separate class since they always nest.
  */
 static struct lock_class_key nr_netdev_xmit_lock_key;
+static struct lock_class_key nr_netdev_addr_lock_key;
 
 static void nr_set_lockdep_one(struct net_device *dev,
                                struct netdev_queue *txq,
@@ -83,6 +84,7 @@ static void nr_set_lockdep_one(struct net_device *dev,
 
 static void nr_set_lockdep_key(struct net_device *dev)
 {
+        lockdep_set_class(&dev->addr_list_lock, &nr_netdev_addr_lock_key);
         netdev_for_each_tx_queue(dev, nr_set_lockdep_one, NULL);
 }
 
diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c
index dbc963b4f5fb..a7f1ce11bc22 100644
--- a/net/rose/af_rose.c
+++ b/net/rose/af_rose.c
@@ -74,6 +74,7 @@ ax25_address rose_callsign;
  * separate class since they always nest.
  */
 static struct lock_class_key rose_netdev_xmit_lock_key;
+static struct lock_class_key rose_netdev_addr_lock_key;
 
 static void rose_set_lockdep_one(struct net_device *dev,
                                  struct netdev_queue *txq,
@@ -84,6 +85,7 @@ static void rose_set_lockdep_one(struct net_device *dev,
 
 static void rose_set_lockdep_key(struct net_device *dev)
 {
+        lockdep_set_class(&dev->addr_list_lock, &rose_netdev_addr_lock_key);
         netdev_for_each_tx_queue(dev, rose_set_lockdep_one, NULL);
 }
 
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index 5219d5f9d754..b0601642e227 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -447,7 +447,7 @@ void qdisc_watchdog_cancel(struct qdisc_watchdog *wd)
 }
 EXPORT_SYMBOL(qdisc_watchdog_cancel);
 
-struct hlist_head *qdisc_class_hash_alloc(unsigned int n)
+static struct hlist_head *qdisc_class_hash_alloc(unsigned int n)
 {
         unsigned int size = n * sizeof(struct hlist_head), i;
         struct hlist_head *h;
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 0ddf69286f92..4ac7e3a8c253 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -212,9 +212,9 @@ static void dev_watchdog(unsigned long arg)
                         if (some_queue_stopped &&
                             time_after(jiffies, (dev->trans_start +
                                                  dev->watchdog_timeo))) {
-                                printk(KERN_INFO "NETDEV WATCHDOG: %s: "
-                                       "transmit timed out\n",
-                                       dev->name);
+                                char drivername[64];
+                                printk(KERN_INFO "NETDEV WATCHDOG: %s (%s): transmit timed out\n",
+                                       dev->name, netdev_drivername(dev, drivername, 64));
                                 dev->tx_timeout(dev);
                                 WARN_ON_ONCE(1);
                         }
@@ -356,44 +356,99 @@ static struct Qdisc noqueue_qdisc = {
 };
 
 
-static int fifo_fast_enqueue(struct sk_buff *skb, struct Qdisc* qdisc)
+static const u8 prio2band[TC_PRIO_MAX+1] =
+        { 1, 2, 2, 2, 1, 2, 0, 0 , 1, 1, 1, 1, 1, 1, 1, 1 };
+
+/* 3-band FIFO queue: old style, but should be a bit faster than
+   generic prio+fifo combination.
+ */
+
+#define PFIFO_FAST_BANDS 3
+
+static inline struct sk_buff_head *prio2list(struct sk_buff *skb,
+                                             struct Qdisc *qdisc)
+{
+        struct sk_buff_head *list = qdisc_priv(qdisc);
+        return list + prio2band[skb->priority & TC_PRIO_MAX];
+}
+
+static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc* qdisc)
 {
-        struct sk_buff_head *list = &qdisc->q;
+        struct sk_buff_head *list = prio2list(skb, qdisc);
 
-        if (skb_queue_len(list) < qdisc_dev(qdisc)->tx_queue_len)
+        if (skb_queue_len(list) < qdisc_dev(qdisc)->tx_queue_len) {
+                qdisc->q.qlen++;
                 return __qdisc_enqueue_tail(skb, qdisc, list);
+        }
 
         return qdisc_drop(skb, qdisc);
 }
 
-static struct sk_buff *fifo_fast_dequeue(struct Qdisc* qdisc)
+static struct sk_buff *pfifo_fast_dequeue(struct Qdisc* qdisc)
 {
-        struct sk_buff_head *list = &qdisc->q;
+        int prio;
+        struct sk_buff_head *list = qdisc_priv(qdisc);
 
-        if (!skb_queue_empty(list))
-                return __qdisc_dequeue_head(qdisc, list);
+        for (prio = 0; prio < PFIFO_FAST_BANDS; prio++) {
+                if (!skb_queue_empty(list + prio)) {
+                        qdisc->q.qlen--;
+                        return __qdisc_dequeue_head(qdisc, list + prio);
+                }
+        }
 
         return NULL;
 }
 
-static int fifo_fast_requeue(struct sk_buff *skb, struct Qdisc* qdisc)
+static int pfifo_fast_requeue(struct sk_buff *skb, struct Qdisc* qdisc)
 {
-        return __qdisc_requeue(skb, qdisc, &qdisc->q);
+        qdisc->q.qlen++;
+        return __qdisc_requeue(skb, qdisc, prio2list(skb, qdisc));
 }
 
-static void fifo_fast_reset(struct Qdisc* qdisc)
+static void pfifo_fast_reset(struct Qdisc* qdisc)
 {
-        __qdisc_reset_queue(qdisc, &qdisc->q);
+        int prio;
+        struct sk_buff_head *list = qdisc_priv(qdisc);
+
+        for (prio = 0; prio < PFIFO_FAST_BANDS; prio++)
+                __qdisc_reset_queue(qdisc, list + prio);
+
         qdisc->qstats.backlog = 0;
+        qdisc->q.qlen = 0;
 }
 
-static struct Qdisc_ops fifo_fast_ops __read_mostly = {
-        .id             =       "fifo_fast",
-        .priv_size      =       0,
-        .enqueue        =       fifo_fast_enqueue,
-        .dequeue        =       fifo_fast_dequeue,
-        .requeue        =       fifo_fast_requeue,
-        .reset          =       fifo_fast_reset,
+static int pfifo_fast_dump(struct Qdisc *qdisc, struct sk_buff *skb)
+{
+        struct tc_prio_qopt opt = { .bands = PFIFO_FAST_BANDS };
+
+        memcpy(&opt.priomap, prio2band, TC_PRIO_MAX+1);
+        NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
+        return skb->len;
+
+nla_put_failure:
+        return -1;
+}
+
+static int pfifo_fast_init(struct Qdisc *qdisc, struct nlattr *opt)
+{
+        int prio;
+        struct sk_buff_head *list = qdisc_priv(qdisc);
+
+        for (prio = 0; prio < PFIFO_FAST_BANDS; prio++)
+                skb_queue_head_init(list + prio);
+
+        return 0;
+}
+
+static struct Qdisc_ops pfifo_fast_ops __read_mostly = {
+        .id             =       "pfifo_fast",
+        .priv_size      =       PFIFO_FAST_BANDS * sizeof(struct sk_buff_head),
+        .enqueue        =       pfifo_fast_enqueue,
+        .dequeue        =       pfifo_fast_dequeue,
+        .requeue        =       pfifo_fast_requeue,
+        .init           =       pfifo_fast_init,
+        .reset          =       pfifo_fast_reset,
+        .dump           =       pfifo_fast_dump,
         .owner          =       THIS_MODULE,
 };
 
@@ -522,7 +577,7 @@ static void attach_one_default_qdisc(struct net_device *dev,
 
         if (dev->tx_queue_len) {
                 qdisc = qdisc_create_dflt(dev, dev_queue,
-                                          &fifo_fast_ops, TC_H_ROOT);
+                                          &pfifo_fast_ops, TC_H_ROOT);
                 if (!qdisc) {
                         printk(KERN_INFO "%s: activation failed\n", dev->name);
                         return;
@@ -550,9 +605,9 @@ void dev_activate(struct net_device *dev)
         int need_watchdog;
 
         /* No queueing discipline is attached to device;
-         * create default one i.e. fifo_fast for devices,
-         * which need queueing and noqueue_qdisc for
-         * virtual interfaces.
+           create default one i.e. pfifo_fast for devices,
+           which need queueing and noqueue_qdisc for
+           virtual interfaces
          */
 
         if (dev_all_qdisc_sleeping_noop(dev))
@@ -576,7 +631,6 @@ static void dev_deactivate_queue(struct net_device *dev,
                                  void *_qdisc_default)
 {
         struct Qdisc *qdisc_default = _qdisc_default;
-        struct sk_buff *skb = NULL;
         struct Qdisc *qdisc;
 
         qdisc = dev_queue->qdisc;
@@ -588,8 +642,6 @@ static void dev_deactivate_queue(struct net_device *dev,
 
                 spin_unlock_bh(qdisc_lock(qdisc));
         }
-
-        kfree_skb(skb);
 }
 
 static bool some_qdisc_is_running(struct net_device *dev, int lock)
diff --git a/net/sctp/outqueue.c b/net/sctp/outqueue.c
index 70ead8dc3485..4328ad5439c9 100644
--- a/net/sctp/outqueue.c
+++ b/net/sctp/outqueue.c
@@ -71,6 +71,8 @@ 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);
+
 /* Add data to the front of the queue. */
 static inline void sctp_outq_head_data(struct sctp_outq *q,
                                         struct sctp_chunk *ch)
@@ -712,7 +714,7 @@ int sctp_outq_uncork(struct sctp_outq *q)
  * locking concerns must be made.  Today we use the sock lock to protect
  * this function.
  */
-int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
+static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
 {
         struct sctp_packet *packet;
         struct sctp_packet singleton;
diff --git a/net/sctp/proc.c b/net/sctp/proc.c
index 5dd89831eceb..f268910620be 100644
--- a/net/sctp/proc.c
+++ b/net/sctp/proc.c
@@ -519,8 +519,3 @@ int __init sctp_remaddr_proc_init(void)
 
         return 0;
 }
-
-void sctp_assoc_proc_exit(void)
-{
-        remove_proc_entry("remaddr", proc_net_sctp);
-}