Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Pull networking fixes from David Miller:

 1) nfnetlink timestamp taken from wrong skb, fix from Florian Westphal.

 2) Revert some msleep conversions in rtlwifi as these spots are in
    atomic context, from Larry Finger.

 3) Validate that NFTA_SET_TABLE attribute is actually specified when we
    call nf_tables_getset().  From Phil Turnbull.

 4) Don't do mdio_reset in stmmac driver with spinlock held as that can
    sleep, from Vincent Palatin.

 5) sk_filter() does things other than run a BPF filter, so we should
    not elide it's call just because sk->sk_filter is NULL.  Fix from
    Eric Dumazet.

 6) Fix missing backlog updates in several packet schedulers, from Cong
    Wang.

 7) bnx2x driver should allow VLAN add/remove while the interface is
    down, from Michal Schmidt.

 8) Several RDS/TCP race fixes from Sowmini Varadhan.

 9) fq_codel scheduler doesn't return correct queue length in dumps,
    from Eric Dumazet.

10) Fix TCP stats for tail loss probe and early retransmit in ipv6, from
    Yuchung Cheng.

11) Properly initialize udp_tunnel_socket_cfg in l2tp_tunnel_create(),
    from Guillaume Nault.

12) qfq scheduler leaks SKBs if a kzalloc fails, fix from Florian
    Westphal.

13) sock_fprog passed into PACKET_FANOUT_DATA needs compat handling,
    from Willem de Bruijn.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (85 commits)
  vmxnet3: segCnt can be 1 for LRO packets
  packet: compat support for sock_fprog
  stmmac: fix parameter to dwmac4_set_umac_addr()
  net/mlx5e: Fix blue flame quota logic
  net/mlx5e: Use ndo_stop explicitly at shutdown flow
  net/mlx5: E-Switch, always set mc_promisc for allmulti vports
  net/mlx5: E-Switch, Modify node guid on vf set MAC
  net/mlx5: E-Switch, Fix vport enable flow
  net/mlx5: E-Switch, Use the correct error check on returned pointers
  net/mlx5: E-Switch, Use the correct free() function
  net/mlx5: Fix E-Switch flow steering capabilities check
  net/mlx5: Fix flow steering NIC capabilities check
  net/mlx5: Fix root flow table update
  net/mlx5: Fix MLX5_CMD_OP_MAX to be defined correctly
  net/mlx5: Fix masking of reserved bits in XRCD number
  net/mlx5: Fix the size of modify QP mailbox
  mlxsw: spectrum: Don't sleep during ndo_get_phys_port_name()
  mlxsw: spectrum: Make split flow match firmware requirements
  wext: Fix 32 bit iwpriv compatibility issue with 64 bit Kernel
  cfg80211: remove get/set antenna and tx power warnings
  ...

51 files changed, 348 insertions, 155 deletions

diff --git a/net/bridge/br_fdb.c b/net/bridge/br_fdb.c
index dcea4f4c62b3..c18080ad4085 100644
--- a/net/bridge/br_fdb.c
+++ b/net/bridge/br_fdb.c
@@ -279,6 +279,8 @@ void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
          * change from under us.
          */
         list_for_each_entry(v, &vg->vlan_list, vlist) {
+                if (!br_vlan_should_use(v))
+                        continue;
                 f = __br_fdb_get(br, br->dev->dev_addr, v->vid);
                 if (f && f->is_local && !f->dst)
                         fdb_delete_local(br, NULL, f);
diff --git a/net/compat.c b/net/compat.c
index 5cfd26a0006f..1cd2ec046164 100644
--- a/net/compat.c
+++ b/net/compat.c
@@ -309,8 +309,8 @@ void scm_detach_fds_compat(struct msghdr *kmsg, struct scm_cookie *scm)
         __scm_destroy(scm);
 }
 
-static int do_set_attach_filter(struct socket *sock, int level, int optname,
-                                char __user *optval, unsigned int optlen)
+/* allocate a 64-bit sock_fprog on the user stack for duration of syscall. */
+struct sock_fprog __user *get_compat_bpf_fprog(char __user *optval)
 {
         struct compat_sock_fprog __user *fprog32 = (struct compat_sock_fprog __user *)optval;
         struct sock_fprog __user *kfprog = compat_alloc_user_space(sizeof(struct sock_fprog));
@@ -323,6 +323,19 @@ static int do_set_attach_filter(struct socket *sock, int level, int optname,
             __get_user(ptr, &fprog32->filter) ||
             __put_user(len, &kfprog->len) ||
             __put_user(compat_ptr(ptr), &kfprog->filter))
+                return NULL;
+
+        return kfprog;
+}
+EXPORT_SYMBOL_GPL(get_compat_bpf_fprog);
+
+static int do_set_attach_filter(struct socket *sock, int level, int optname,
+                                char __user *optval, unsigned int optlen)
+{
+        struct sock_fprog __user *kfprog;
+
+        kfprog = get_compat_bpf_fprog(optval);
+        if (!kfprog)
                 return -EFAULT;
 
         return sock_setsockopt(sock, level, optname, (char __user *)kfprog,
@@ -354,7 +367,8 @@ static int do_set_sock_timeout(struct socket *sock, int level,
 static int compat_sock_setsockopt(struct socket *sock, int level, int optname,
                                 char __user *optval, unsigned int optlen)
 {
-        if (optname == SO_ATTACH_FILTER)
+        if (optname == SO_ATTACH_FILTER ||
+            optname == SO_ATTACH_REUSEPORT_CBPF)
                 return do_set_attach_filter(sock, level, optname,
                                             optval, optlen);
         if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)
diff --git a/net/core/gen_stats.c b/net/core/gen_stats.c
index f96ee8b9478d..be873e4e3125 100644
--- a/net/core/gen_stats.c
+++ b/net/core/gen_stats.c
@@ -47,6 +47,7 @@ nla_put_failure:
  * @xstats_type: TLV type for backward compatibility xstats TLV
  * @lock: statistics lock
  * @d: dumping handle
+ * @padattr: padding attribute
  *
  * Initializes the dumping handle, grabs the statistic lock and appends
  * an empty TLV header to the socket buffer for use a container for all
@@ -87,6 +88,7 @@ EXPORT_SYMBOL(gnet_stats_start_copy_compat);
  * @type: TLV type for top level statistic TLV
  * @lock: statistics lock
  * @d: dumping handle
+ * @padattr: padding attribute
  *
  * Initializes the dumping handle, grabs the statistic lock and appends
  * an empty TLV header to the socket buffer for use a container for all
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index 2b3f76fe65f4..7a0b616557ab 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -24,6 +24,7 @@
 #include <linux/jiffies.h>
 #include <linux/pm_runtime.h>
 #include <linux/of.h>
+#include <linux/of_net.h>
 
 #include "net-sysfs.h"
 
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index d56c0559b477..0ff31d97d485 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -1618,12 +1618,12 @@ int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
                 }
         }
 
-        if (rcu_access_pointer(sk->sk_filter)) {
-                if (udp_lib_checksum_complete(skb))
+        if (rcu_access_pointer(sk->sk_filter) &&
+            udp_lib_checksum_complete(skb))
                         goto csum_error;
-                if (sk_filter(sk, skb))
-                        goto drop;
-        }
+
+        if (sk_filter(sk, skb))
+                goto drop;
 
         udp_csum_pull_header(skb);
         if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {
diff --git a/net/ipv6/ip6_gre.c b/net/ipv6/ip6_gre.c
index f4ac2842d4d9..fdc9de276ab1 100644
--- a/net/ipv6/ip6_gre.c
+++ b/net/ipv6/ip6_gre.c
@@ -1256,6 +1256,8 @@ static int ip6gre_tap_init(struct net_device *dev)
         if (ret)
                 return ret;
 
+        dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
+
         tunnel = netdev_priv(dev);
 
         ip6gre_tnl_link_config(tunnel, 1);
@@ -1289,6 +1291,7 @@ static void ip6gre_tap_setup(struct net_device *dev)
 
         dev->features |= NETIF_F_NETNS_LOCAL;
         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
+        dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
 }
 
 static bool ip6gre_netlink_encap_parms(struct nlattr *data[],
diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c
index cbf127ae7c67..635b8d340cdb 100644
--- a/net/ipv6/ip6_output.c
+++ b/net/ipv6/ip6_output.c
@@ -1071,17 +1071,12 @@ struct dst_entry *ip6_sk_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6,
                                          const struct in6_addr *final_dst)
 {
         struct dst_entry *dst = sk_dst_check(sk, inet6_sk(sk)->dst_cookie);
-        int err;
 
         dst = ip6_sk_dst_check(sk, dst, fl6);
+        if (!dst)
+                dst = ip6_dst_lookup_flow(sk, fl6, final_dst);
 
-        err = ip6_dst_lookup_tail(sock_net(sk), sk, &dst, fl6);
-        if (err)
-                return ERR_PTR(err);
-        if (final_dst)
-                fl6->daddr = *final_dst;
-
-        return xfrm_lookup_route(sock_net(sk), dst, flowi6_to_flowi(fl6), sk, 0);
+        return dst;
 }
 EXPORT_SYMBOL_GPL(ip6_sk_dst_lookup_flow);
 
diff --git a/net/ipv6/netfilter/nf_dup_ipv6.c b/net/ipv6/netfilter/nf_dup_ipv6.c
index 6989c70ae29f..4a84b5ad9ecb 100644
--- a/net/ipv6/netfilter/nf_dup_ipv6.c
+++ b/net/ipv6/netfilter/nf_dup_ipv6.c
@@ -33,6 +33,7 @@ static bool nf_dup_ipv6_route(struct net *net, struct sk_buff *skb,
         fl6.daddr = *gw;
         fl6.flowlabel = (__force __be32)(((iph->flow_lbl[0] & 0xF) << 16) |
                         (iph->flow_lbl[1] << 8) | iph->flow_lbl[2]);
+        fl6.flowi6_flags = FLOWI_FLAG_KNOWN_NH;
         dst = ip6_route_output(net, NULL, &fl6);
         if (dst->error) {
                 dst_release(dst);
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 79e33e02f11a..f36c2d076fce 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1721,7 +1721,9 @@ static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
         destp = ntohs(inet->inet_dport);
         srcp  = ntohs(inet->inet_sport);
 
-        if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
+        if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
+            icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
+            icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
                 timer_active    = 1;
                 timer_expires   = icsk->icsk_timeout;
         } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index 2da1896af934..f421c9f23c5b 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -653,12 +653,12 @@ int udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
                 }
         }
 
-        if (rcu_access_pointer(sk->sk_filter)) {
-                if (udp_lib_checksum_complete(skb))
-                        goto csum_error;
-                if (sk_filter(sk, skb))
-                        goto drop;
-        }
+        if (rcu_access_pointer(sk->sk_filter) &&
+            udp_lib_checksum_complete(skb))
+                goto csum_error;
+
+        if (sk_filter(sk, skb))
+                goto drop;
 
         udp_csum_pull_header(skb);
         if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {
diff --git a/net/l2tp/l2tp_core.c b/net/l2tp/l2tp_core.c
index 6edfa9980314..1e40dacaa137 100644
--- a/net/l2tp/l2tp_core.c
+++ b/net/l2tp/l2tp_core.c
@@ -1581,7 +1581,7 @@ int l2tp_tunnel_create(struct net *net, int fd, int version, u32 tunnel_id, u32
         /* Mark socket as an encapsulation socket. See net/ipv4/udp.c */
         tunnel->encap = encap;
         if (encap == L2TP_ENCAPTYPE_UDP) {
-                struct udp_tunnel_sock_cfg udp_cfg;
+                struct udp_tunnel_sock_cfg udp_cfg = { };
 
                 udp_cfg.sk_user_data = tunnel;
                 udp_cfg.encap_type = UDP_ENCAP_L2TPINUDP;
diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c
index 4c6404e1ad6e..21b1fdf5d01d 100644
--- a/net/mac80211/mesh.c
+++ b/net/mac80211/mesh.c
@@ -161,6 +161,10 @@ void mesh_sta_cleanup(struct sta_info *sta)
                 del_timer_sync(&sta->mesh->plink_timer);
         }
 
+        /* make sure no readers can access nexthop sta from here on */
+        mesh_path_flush_by_nexthop(sta);
+        synchronize_net();
+
         if (changed)
                 ieee80211_mbss_info_change_notify(sdata, changed);
 }
diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h
index c8b8ccc370eb..78b0ef32dddd 100644
--- a/net/mac80211/sta_info.h
+++ b/net/mac80211/sta_info.h
@@ -280,7 +280,7 @@ struct ieee80211_fast_tx {
         u8 sa_offs, da_offs, pn_offs;
         u8 band;
         u8 hdr[30 + 2 + IEEE80211_FAST_XMIT_MAX_IV +
-               sizeof(rfc1042_header)];
+               sizeof(rfc1042_header)] __aligned(2);
 
         struct rcu_head rcu_head;
 };
diff --git a/net/netfilter/ipvs/ip_vs_conn.c b/net/netfilter/ipvs/ip_vs_conn.c
index 2cb3c626cd43..096a45103f14 100644
--- a/net/netfilter/ipvs/ip_vs_conn.c
+++ b/net/netfilter/ipvs/ip_vs_conn.c
@@ -762,7 +762,7 @@ static int expire_quiescent_template(struct netns_ipvs *ipvs,
  *      If available, return 1, otherwise invalidate this connection
  *      template and return 0.
  */
-int ip_vs_check_template(struct ip_vs_conn *ct)
+int ip_vs_check_template(struct ip_vs_conn *ct, struct ip_vs_dest *cdest)
 {
         struct ip_vs_dest *dest = ct->dest;
         struct netns_ipvs *ipvs = ct->ipvs;
@@ -772,7 +772,8 @@ int ip_vs_check_template(struct ip_vs_conn *ct)
          */
         if ((dest == NULL) ||
             !(dest->flags & IP_VS_DEST_F_AVAILABLE) ||
-            expire_quiescent_template(ipvs, dest)) {
+            expire_quiescent_template(ipvs, dest) ||
+            (cdest && (dest != cdest))) {
                 IP_VS_DBG_BUF(9, "check_template: dest not available for "
                               "protocol %s s:%s:%d v:%s:%d "
                               "-> d:%s:%d\n",
diff --git a/net/netfilter/ipvs/ip_vs_core.c b/net/netfilter/ipvs/ip_vs_core.c
index 1207f20d24e4..2c1b498a7a27 100644
--- a/net/netfilter/ipvs/ip_vs_core.c
+++ b/net/netfilter/ipvs/ip_vs_core.c
@@ -321,7 +321,7 @@ ip_vs_sched_persist(struct ip_vs_service *svc,
 
         /* Check if a template already exists */
         ct = ip_vs_ct_in_get(&param);
-        if (!ct || !ip_vs_check_template(ct)) {
+        if (!ct || !ip_vs_check_template(ct, NULL)) {
                 struct ip_vs_scheduler *sched;
 
                 /*
@@ -1154,7 +1154,8 @@ struct ip_vs_conn *ip_vs_new_conn_out(struct ip_vs_service *svc,
                                                   vport, &param) < 0)
                         return NULL;
                 ct = ip_vs_ct_in_get(&param);
-                if (!ct) {
+                /* check if template exists and points to the same dest */
+                if (!ct || !ip_vs_check_template(ct, dest)) {
                         ct = ip_vs_conn_new(&param, dest->af, daddr, dport,
                                             IP_VS_CONN_F_TEMPLATE, dest, 0);
                         if (!ct) {
diff --git a/net/netfilter/nf_conntrack_ftp.c b/net/netfilter/nf_conntrack_ftp.c
index 883c691ec8d0..19efeba02abb 100644
--- a/net/netfilter/nf_conntrack_ftp.c
+++ b/net/netfilter/nf_conntrack_ftp.c
@@ -632,6 +632,7 @@ static int __init nf_conntrack_ftp_init(void)
                         if (ret) {
                                 pr_err("failed to register helper for pf: %d port: %d\n",
                                        ftp[i][j].tuple.src.l3num, ports[i]);
+                                ports_c = i;
                                 nf_conntrack_ftp_fini();
                                 return ret;
                         }
diff --git a/net/netfilter/nf_conntrack_helper.c b/net/netfilter/nf_conntrack_helper.c
index f703adb7e5f7..196cb39649e1 100644
--- a/net/netfilter/nf_conntrack_helper.c
+++ b/net/netfilter/nf_conntrack_helper.c
@@ -361,9 +361,10 @@ EXPORT_SYMBOL_GPL(nf_ct_helper_log);
 
 int nf_conntrack_helper_register(struct nf_conntrack_helper *me)
 {
-        int ret = 0;
-        struct nf_conntrack_helper *cur;
+        struct nf_conntrack_tuple_mask mask = { .src.u.all = htons(0xFFFF) };
         unsigned int h = helper_hash(&me->tuple);
+        struct nf_conntrack_helper *cur;
+        int ret = 0;
 
         BUG_ON(me->expect_policy == NULL);
         BUG_ON(me->expect_class_max >= NF_CT_MAX_EXPECT_CLASSES);
@@ -371,9 +372,7 @@ int nf_conntrack_helper_register(struct nf_conntrack_helper *me)
 
         mutex_lock(&nf_ct_helper_mutex);
         hlist_for_each_entry(cur, &nf_ct_helper_hash[h], hnode) {
-                if (strncmp(cur->name, me->name, NF_CT_HELPER_NAME_LEN) == 0 &&
-                    cur->tuple.src.l3num == me->tuple.src.l3num &&
-                    cur->tuple.dst.protonum == me->tuple.dst.protonum) {
+                if (nf_ct_tuple_src_mask_cmp(&cur->tuple, &me->tuple, &mask)) {
                         ret = -EEXIST;
                         goto out;
                 }
diff --git a/net/netfilter/nf_conntrack_irc.c b/net/netfilter/nf_conntrack_irc.c
index 8b6da2719600..f97ac61d2536 100644
--- a/net/netfilter/nf_conntrack_irc.c
+++ b/net/netfilter/nf_conntrack_irc.c
@@ -271,6 +271,7 @@ static int __init nf_conntrack_irc_init(void)
                 if (ret) {
                         pr_err("failed to register helper for pf: %u port: %u\n",
                                irc[i].tuple.src.l3num, ports[i]);
+                        ports_c = i;
                         nf_conntrack_irc_fini();
                         return ret;
                 }
diff --git a/net/netfilter/nf_conntrack_sane.c b/net/netfilter/nf_conntrack_sane.c
index 7523a575f6d1..3fcbaab83b3d 100644
--- a/net/netfilter/nf_conntrack_sane.c
+++ b/net/netfilter/nf_conntrack_sane.c
@@ -223,6 +223,7 @@ static int __init nf_conntrack_sane_init(void)
                         if (ret) {
                                 pr_err("failed to register helper for pf: %d port: %d\n",
                                        sane[i][j].tuple.src.l3num, ports[i]);
+                                ports_c = i;
                                 nf_conntrack_sane_fini();
                                 return ret;
                         }
diff --git a/net/netfilter/nf_conntrack_sip.c b/net/netfilter/nf_conntrack_sip.c
index 3e06402739e0..f72ba5587588 100644
--- a/net/netfilter/nf_conntrack_sip.c
+++ b/net/netfilter/nf_conntrack_sip.c
@@ -1669,6 +1669,7 @@ static int __init nf_conntrack_sip_init(void)
                         if (ret) {
                                 pr_err("failed to register helper for pf: %u port: %u\n",
                                        sip[i][j].tuple.src.l3num, ports[i]);
+                                ports_c = i;
                                 nf_conntrack_sip_fini();
                                 return ret;
                         }
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index f87e84ebcec3..c026c472ea80 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -487,8 +487,6 @@ static struct ctl_table nf_ct_sysctl_table[] = {
         { }
 };
 
-#define NET_NF_CONNTRACK_MAX 2089
-
 static struct ctl_table nf_ct_netfilter_table[] = {
         {
                 .procname       = "nf_conntrack_max",
diff --git a/net/netfilter/nf_conntrack_tftp.c b/net/netfilter/nf_conntrack_tftp.c
index 36f964066461..2e65b5430fba 100644
--- a/net/netfilter/nf_conntrack_tftp.c
+++ b/net/netfilter/nf_conntrack_tftp.c
@@ -142,6 +142,7 @@ static int __init nf_conntrack_tftp_init(void)
                         if (ret) {
                                 pr_err("failed to register helper for pf: %u port: %u\n",
                                        tftp[i][j].tuple.src.l3num, ports[i]);
+                                ports_c = i;
                                 nf_conntrack_tftp_fini();
                                 return ret;
                         }
diff --git a/net/netfilter/nf_queue.c b/net/netfilter/nf_queue.c
index 5baa8e24e6ac..b19ad20a705c 100644
--- a/net/netfilter/nf_queue.c
+++ b/net/netfilter/nf_queue.c
@@ -26,23 +26,21 @@
  * Once the queue is registered it must reinject all packets it
  * receives, no matter what.
  */
-static const struct nf_queue_handler __rcu *queue_handler __read_mostly;
 
 /* return EBUSY when somebody else is registered, return EEXIST if the
  * same handler is registered, return 0 in case of success. */
-void nf_register_queue_handler(const struct nf_queue_handler *qh)
+void nf_register_queue_handler(struct net *net, const struct nf_queue_handler *qh)
 {
         /* should never happen, we only have one queueing backend in kernel */
-        WARN_ON(rcu_access_pointer(queue_handler));
-        rcu_assign_pointer(queue_handler, qh);
+        WARN_ON(rcu_access_pointer(net->nf.queue_handler));
+        rcu_assign_pointer(net->nf.queue_handler, qh);
 }
 EXPORT_SYMBOL(nf_register_queue_handler);
 
 /* The caller must flush their queue before this */
-void nf_unregister_queue_handler(void)
+void nf_unregister_queue_handler(struct net *net)
 {
-        RCU_INIT_POINTER(queue_handler, NULL);
-        synchronize_rcu();
+        RCU_INIT_POINTER(net->nf.queue_handler, NULL);
 }
 EXPORT_SYMBOL(nf_unregister_queue_handler);
 
@@ -103,7 +101,7 @@ void nf_queue_nf_hook_drop(struct net *net, struct nf_hook_ops *ops)
         const struct nf_queue_handler *qh;
 
         rcu_read_lock();
-        qh = rcu_dereference(queue_handler);
+        qh = rcu_dereference(net->nf.queue_handler);
         if (qh)
                 qh->nf_hook_drop(net, ops);
         rcu_read_unlock();
@@ -122,9 +120,10 @@ int nf_queue(struct sk_buff *skb,
         struct nf_queue_entry *entry = NULL;
         const struct nf_afinfo *afinfo;
         const struct nf_queue_handler *qh;
+        struct net *net = state->net;
 
         /* QUEUE == DROP if no one is waiting, to be safe. */
-        qh = rcu_dereference(queue_handler);
+        qh = rcu_dereference(net->nf.queue_handler);
         if (!qh) {
                 status = -ESRCH;
                 goto err;
diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index 4d292b933b5c..7b7aa871a174 100644
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -2647,6 +2647,8 @@ static int nf_tables_getset(struct net *net, struct sock *nlsk,
         /* Only accept unspec with dump */
         if (nfmsg->nfgen_family == NFPROTO_UNSPEC)
                 return -EAFNOSUPPORT;
+        if (!nla[NFTA_SET_TABLE])
+                return -EINVAL;
 
         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME]);
         if (IS_ERR(set))
diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c
index aa93877ab6e2..5d36a0926b4a 100644
--- a/net/netfilter/nfnetlink_queue.c
+++ b/net/netfilter/nfnetlink_queue.c
@@ -557,7 +557,7 @@ nfqnl_build_packet_message(struct net *net, struct nfqnl_instance *queue,
 
         if (entskb->tstamp.tv64) {
                 struct nfqnl_msg_packet_timestamp ts;
-                struct timespec64 kts = ktime_to_timespec64(skb->tstamp);
+                struct timespec64 kts = ktime_to_timespec64(entskb->tstamp);
 
                 ts.sec = cpu_to_be64(kts.tv_sec);
                 ts.usec = cpu_to_be64(kts.tv_nsec / NSEC_PER_USEC);
@@ -1482,21 +1482,29 @@ static int __net_init nfnl_queue_net_init(struct net *net)
                          net->nf.proc_netfilter, &nfqnl_file_ops))
                 return -ENOMEM;
 #endif
+        nf_register_queue_handler(net, &nfqh);
         return 0;
 }
 
 static void __net_exit nfnl_queue_net_exit(struct net *net)
 {
+        nf_unregister_queue_handler(net);
 #ifdef CONFIG_PROC_FS
         remove_proc_entry("nfnetlink_queue", net->nf.proc_netfilter);
 #endif
 }
 
+static void nfnl_queue_net_exit_batch(struct list_head *net_exit_list)
+{
+        synchronize_rcu();
+}
+
 static struct pernet_operations nfnl_queue_net_ops = {
-        .init   = nfnl_queue_net_init,
-        .exit   = nfnl_queue_net_exit,
-        .id     = &nfnl_queue_net_id,
-        .size   = sizeof(struct nfnl_queue_net),
+        .init           = nfnl_queue_net_init,
+        .exit           = nfnl_queue_net_exit,
+        .exit_batch     = nfnl_queue_net_exit_batch,
+        .id             = &nfnl_queue_net_id,
+        .size           = sizeof(struct nfnl_queue_net),
 };
 
 static int __init nfnetlink_queue_init(void)
@@ -1517,7 +1525,6 @@ static int __init nfnetlink_queue_init(void)
         }
 
         register_netdevice_notifier(&nfqnl_dev_notifier);
-        nf_register_queue_handler(&nfqh);
         return status;
 
 cleanup_netlink_notifier:
@@ -1529,7 +1536,6 @@ out:
 
 static void __exit nfnetlink_queue_fini(void)
 {
-        nf_unregister_queue_handler();
         unregister_netdevice_notifier(&nfqnl_dev_notifier);
         nfnetlink_subsys_unregister(&nfqnl_subsys);
         netlink_unregister_notifier(&nfqnl_rtnl_notifier);
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index c69c892231d7..2675d580c490 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -612,7 +612,7 @@ int xt_compat_check_entry_offsets(const void *base, const char *elems,
                 return -EINVAL;
 
         if (strcmp(t->u.user.name, XT_STANDARD_TARGET) == 0 &&
-            target_offset + sizeof(struct compat_xt_standard_target) != next_offset)
+            COMPAT_XT_ALIGN(target_offset + sizeof(struct compat_xt_standard_target)) != next_offset)
                 return -EINVAL;
 
         /* compat_xt_entry match has less strict aligment requirements,
@@ -694,7 +694,7 @@ int xt_check_entry_offsets(const void *base,
                 return -EINVAL;
 
         if (strcmp(t->u.user.name, XT_STANDARD_TARGET) == 0 &&
-            target_offset + sizeof(struct xt_standard_target) != next_offset)
+            XT_ALIGN(target_offset + sizeof(struct xt_standard_target)) != next_offset)
                 return -EINVAL;
 
         return xt_check_entry_match(elems, base + target_offset,
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index 4040eb92d9c9..9bff6ef16fa7 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -93,6 +93,7 @@
 #include <net/inet_common.h>
 #endif
 #include <linux/bpf.h>
+#include <net/compat.h>
 
 #include "internal.h"
 
@@ -3940,6 +3941,27 @@ static int packet_getsockopt(struct socket *sock, int level, int optname,
 }
 
 
+#ifdef CONFIG_COMPAT
+static int compat_packet_setsockopt(struct socket *sock, int level, int optname,
+                                    char __user *optval, unsigned int optlen)
+{
+        struct packet_sock *po = pkt_sk(sock->sk);
+
+        if (level != SOL_PACKET)
+                return -ENOPROTOOPT;
+
+        if (optname == PACKET_FANOUT_DATA &&
+            po->fanout && po->fanout->type == PACKET_FANOUT_CBPF) {
+                optval = (char __user *)get_compat_bpf_fprog(optval);
+                if (!optval)
+                        return -EFAULT;
+                optlen = sizeof(struct sock_fprog);
+        }
+
+        return packet_setsockopt(sock, level, optname, optval, optlen);
+}
+#endif
+
 static int packet_notifier(struct notifier_block *this,
                            unsigned long msg, void *ptr)
 {
@@ -4416,6 +4438,9 @@ static const struct proto_ops packet_ops = {
         .shutdown =     sock_no_shutdown,
         .setsockopt =   packet_setsockopt,
         .getsockopt =   packet_getsockopt,
+#ifdef CONFIG_COMPAT
+        .compat_setsockopt = compat_packet_setsockopt,
+#endif
         .sendmsg =      packet_sendmsg,
         .recvmsg =      packet_recvmsg,
         .mmap =         packet_mmap,
diff --git a/net/rds/rds.h b/net/rds/rds.h
index 80256b08eac0..387df5f32e49 100644
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -74,6 +74,7 @@ enum {
         RDS_CONN_CONNECTING,
         RDS_CONN_DISCONNECTING,
         RDS_CONN_UP,
+        RDS_CONN_RESETTING,
         RDS_CONN_ERROR,
 };
 
@@ -813,6 +814,7 @@ void rds_connect_worker(struct work_struct *);
 void rds_shutdown_worker(struct work_struct *);
 void rds_send_worker(struct work_struct *);
 void rds_recv_worker(struct work_struct *);
+void rds_connect_path_complete(struct rds_connection *conn, int curr);
 void rds_connect_complete(struct rds_connection *conn);
 
 /* transport.c */
diff --git a/net/rds/recv.c b/net/rds/recv.c
index c0be1ecd11c9..8413f6c99e13 100644
--- a/net/rds/recv.c
+++ b/net/rds/recv.c
@@ -561,5 +561,7 @@ void rds_inc_info_copy(struct rds_incoming *inc,
                 minfo.fport = inc->i_hdr.h_dport;
         }
 
+        minfo.flags = 0;
+
         rds_info_copy(iter, &minfo, sizeof(minfo));
 }
diff --git a/net/rds/send.c b/net/rds/send.c
index c9cdb358ea88..b1962f8e30f7 100644
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -99,6 +99,7 @@ void rds_send_reset(struct rds_connection *conn)
         list_splice_init(&conn->c_retrans, &conn->c_send_queue);
         spin_unlock_irqrestore(&conn->c_lock, flags);
 }
+EXPORT_SYMBOL_GPL(rds_send_reset);
 
 static int acquire_in_xmit(struct rds_connection *conn)
 {
diff --git a/net/rds/tcp.c b/net/rds/tcp.c
index 86187dad1440..74ee126a6fe6 100644
--- a/net/rds/tcp.c
+++ b/net/rds/tcp.c
@@ -126,9 +126,81 @@ void rds_tcp_restore_callbacks(struct socket *sock,
 }
 
 /*
- * This is the only path that sets tc->t_sock.  Send and receive trust that
- * it is set.  The RDS_CONN_UP bit protects those paths from being
- * called while it isn't set.
+ * rds_tcp_reset_callbacks() switches the to the new sock and
+ * returns the existing tc->t_sock.
+ *
+ * The only functions that set tc->t_sock are rds_tcp_set_callbacks
+ * and rds_tcp_reset_callbacks.  Send and receive trust that
+ * it is set.  The absence of RDS_CONN_UP bit protects those paths
+ * from being called while it isn't set.
+ */
+void rds_tcp_reset_callbacks(struct socket *sock,
+                             struct rds_connection *conn)
+{
+        struct rds_tcp_connection *tc = conn->c_transport_data;
+        struct socket *osock = tc->t_sock;
+
+        if (!osock)
+                goto newsock;
+
+        /* Need to resolve a duelling SYN between peers.
+         * We have an outstanding SYN to this peer, which may
+         * potentially have transitioned to the RDS_CONN_UP state,
+         * so we must quiesce any send threads before resetting
+         * c_transport_data. We quiesce these threads by setting
+         * c_state to something other than RDS_CONN_UP, and then
+         * waiting for any existing threads in rds_send_xmit to
+         * complete release_in_xmit(). (Subsequent threads entering
+         * rds_send_xmit() will bail on !rds_conn_up().
+         *
+         * However an incoming syn-ack at this point would end up
+         * marking the conn as RDS_CONN_UP, and would again permit
+         * rds_send_xmi() threads through, so ideally we would
+         * synchronize on RDS_CONN_UP after lock_sock(), but cannot
+         * do that: waiting on !RDS_IN_XMIT after lock_sock() may
+         * end up deadlocking with tcp_sendmsg(), and the RDS_IN_XMIT
+         * would not get set. As a result, we set c_state to
+         * RDS_CONN_RESETTTING, to ensure that rds_tcp_state_change
+         * cannot mark rds_conn_path_up() in the window before lock_sock()
+         */
+        atomic_set(&conn->c_state, RDS_CONN_RESETTING);
+        wait_event(conn->c_waitq, !test_bit(RDS_IN_XMIT, &conn->c_flags));
+        lock_sock(osock->sk);
+        /* reset receive side state for rds_tcp_data_recv() for osock  */
+        if (tc->t_tinc) {
+                rds_inc_put(&tc->t_tinc->ti_inc);
+                tc->t_tinc = NULL;
+        }
+        tc->t_tinc_hdr_rem = sizeof(struct rds_header);
+        tc->t_tinc_data_rem = 0;
+        tc->t_sock = NULL;
+
+        write_lock_bh(&osock->sk->sk_callback_lock);
+
+        osock->sk->sk_user_data = NULL;
+        osock->sk->sk_data_ready = tc->t_orig_data_ready;
+        osock->sk->sk_write_space = tc->t_orig_write_space;
+        osock->sk->sk_state_change = tc->t_orig_state_change;
+        write_unlock_bh(&osock->sk->sk_callback_lock);
+        release_sock(osock->sk);
+        sock_release(osock);
+newsock:
+        rds_send_reset(conn);
+        lock_sock(sock->sk);
+        write_lock_bh(&sock->sk->sk_callback_lock);
+        tc->t_sock = sock;
+        sock->sk->sk_user_data = conn;
+        sock->sk->sk_data_ready = rds_tcp_data_ready;
+        sock->sk->sk_write_space = rds_tcp_write_space;
+        sock->sk->sk_state_change = rds_tcp_state_change;
+
+        write_unlock_bh(&sock->sk->sk_callback_lock);
+        release_sock(sock->sk);
+}
+
+/* Add tc to rds_tcp_tc_list and set tc->t_sock. See comments
+ * above rds_tcp_reset_callbacks for notes about synchronization
+ * with data path
  */
 void rds_tcp_set_callbacks(struct socket *sock, struct rds_connection *conn)
 {
diff --git a/net/rds/tcp.h b/net/rds/tcp.h
index 41c228300525..ec0602b0dc24 100644
--- a/net/rds/tcp.h
+++ b/net/rds/tcp.h
@@ -50,6 +50,7 @@ struct rds_tcp_statistics {
 void rds_tcp_tune(struct socket *sock);
 void rds_tcp_nonagle(struct socket *sock);
 void rds_tcp_set_callbacks(struct socket *sock, struct rds_connection *conn);
+void rds_tcp_reset_callbacks(struct socket *sock, struct rds_connection *conn);
 void rds_tcp_restore_callbacks(struct socket *sock,
                                struct rds_tcp_connection *tc);
 u32 rds_tcp_snd_nxt(struct rds_tcp_connection *tc);
diff --git a/net/rds/tcp_connect.c b/net/rds/tcp_connect.c
index fb82e0a0bf89..fba13d0305fb 100644
--- a/net/rds/tcp_connect.c
+++ b/net/rds/tcp_connect.c
@@ -60,7 +60,7 @@ void rds_tcp_state_change(struct sock *sk)
                 case TCP_SYN_RECV:
                         break;
                 case TCP_ESTABLISHED:
-                        rds_connect_complete(conn);
+                        rds_connect_path_complete(conn, RDS_CONN_CONNECTING);
                         break;
                 case TCP_CLOSE_WAIT:
                 case TCP_CLOSE:
diff --git a/net/rds/tcp_listen.c b/net/rds/tcp_listen.c
index 4bf4befe5066..686b1d03a558 100644
--- a/net/rds/tcp_listen.c
+++ b/net/rds/tcp_listen.c
@@ -78,7 +78,6 @@ int rds_tcp_accept_one(struct socket *sock)
         struct inet_sock *inet;
         struct rds_tcp_connection *rs_tcp = NULL;
         int conn_state;
-        struct sock *nsk;
 
         if (!sock) /* module unload or netns delete in progress */
                 return -ENETUNREACH;
@@ -136,26 +135,21 @@ int rds_tcp_accept_one(struct socket *sock)
                     !conn->c_outgoing) {
                         goto rst_nsk;
                 } else {
-                        atomic_set(&conn->c_state, RDS_CONN_CONNECTING);
-                        wait_event(conn->c_waitq,
-                                   !test_bit(RDS_IN_XMIT, &conn->c_flags));
-                        rds_tcp_restore_callbacks(rs_tcp->t_sock, rs_tcp);
+                        rds_tcp_reset_callbacks(new_sock, conn);
                         conn->c_outgoing = 0;
+                        /* rds_connect_path_complete() marks RDS_CONN_UP */
+                        rds_connect_path_complete(conn, RDS_CONN_DISCONNECTING);
                 }
+        } else {
+                rds_tcp_set_callbacks(new_sock, conn);
+                rds_connect_path_complete(conn, RDS_CONN_CONNECTING);
         }
-        rds_tcp_set_callbacks(new_sock, conn);
-        rds_connect_complete(conn); /* marks RDS_CONN_UP */
         new_sock = NULL;
         ret = 0;
         goto out;
 rst_nsk:
         /* reset the newly returned accept sock and bail */
-        nsk = new_sock->sk;
-        rds_tcp_stats_inc(s_tcp_listen_closed_stale);
-        nsk->sk_user_data = NULL;
-        nsk->sk_prot->disconnect(nsk, 0);
-        tcp_done(nsk);
-        new_sock = NULL;
+        kernel_sock_shutdown(new_sock, SHUT_RDWR);
         ret = 0;
 out:
         if (rs_tcp)
diff --git a/net/rds/threads.c b/net/rds/threads.c
index 454aa6d23327..4a323045719b 100644
--- a/net/rds/threads.c
+++ b/net/rds/threads.c
@@ -71,9 +71,9 @@
 struct workqueue_struct *rds_wq;
 EXPORT_SYMBOL_GPL(rds_wq);
 
-void rds_connect_complete(struct rds_connection *conn)
+void rds_connect_path_complete(struct rds_connection *conn, int curr)
 {
-        if (!rds_conn_transition(conn, RDS_CONN_CONNECTING, RDS_CONN_UP)) {
+        if (!rds_conn_transition(conn, curr, RDS_CONN_UP)) {
                 printk(KERN_WARNING "%s: Cannot transition to state UP, "
                                 "current state is %d\n",
                                 __func__,
@@ -90,6 +90,12 @@ void rds_connect_complete(struct rds_connection *conn)
         queue_delayed_work(rds_wq, &conn->c_send_w, 0);
         queue_delayed_work(rds_wq, &conn->c_recv_w, 0);
 }
+EXPORT_SYMBOL_GPL(rds_connect_path_complete);
+
+void rds_connect_complete(struct rds_connection *conn)
+{
+        rds_connect_path_complete(conn, RDS_CONN_CONNECTING);
+}
 EXPORT_SYMBOL_GPL(rds_connect_complete);
 
 /*
diff --git a/net/rxrpc/rxkad.c b/net/rxrpc/rxkad.c
index 6b726a046a7d..bab56ed649ba 100644
--- a/net/rxrpc/rxkad.c
+++ b/net/rxrpc/rxkad.c
@@ -1162,9 +1162,7 @@ static int rxkad_init(void)
         /* pin the cipher we need so that the crypto layer doesn't invoke
          * keventd to go get it */
         rxkad_ci = crypto_alloc_skcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC);
-        if (IS_ERR(rxkad_ci))
-                return PTR_ERR(rxkad_ci);
-        return 0;
+        return PTR_ERR_OR_ZERO(rxkad_ci);
 }
 
 /*
diff --git a/net/sched/act_police.c b/net/sched/act_police.c
index b884dae692a1..c557789765dc 100644
--- a/net/sched/act_police.c
+++ b/net/sched/act_police.c
@@ -38,7 +38,7 @@ struct tcf_police {
         bool                    peak_present;
 };
 #define to_police(pc)   \
-        container_of(pc, struct tcf_police, common)
+        container_of(pc->priv, struct tcf_police, common)
 
 #define POL_TAB_MASK     15
 
@@ -119,14 +119,12 @@ static int tcf_act_police_locate(struct net *net, struct nlattr *nla,
                                  struct nlattr *est, struct tc_action *a,
                                  int ovr, int bind)
 {
-        unsigned int h;
         int ret = 0, err;
         struct nlattr *tb[TCA_POLICE_MAX + 1];
         struct tc_police *parm;
         struct tcf_police *police;
         struct qdisc_rate_table *R_tab = NULL, *P_tab = NULL;
         struct tc_action_net *tn = net_generic(net, police_net_id);
-        struct tcf_hashinfo *hinfo = tn->hinfo;
         int size;
 
         if (nla == NULL)
@@ -145,7 +143,7 @@ static int tcf_act_police_locate(struct net *net, struct nlattr *nla,
 
         if (parm->index) {
                 if (tcf_hash_search(tn, a, parm->index)) {
-                        police = to_police(a->priv);
+                        police = to_police(a);
                         if (bind) {
                                 police->tcf_bindcnt += 1;
                                 police->tcf_refcnt += 1;
@@ -156,16 +154,15 @@ static int tcf_act_police_locate(struct net *net, struct nlattr *nla,
                         /* not replacing */
                         return -EEXIST;
                 }
+        } else {
+                ret = tcf_hash_create(tn, parm->index, NULL, a,
+                                      sizeof(*police), bind, false);
+                if (ret)
+                        return ret;
+                ret = ACT_P_CREATED;
         }
 
-        police = kzalloc(sizeof(*police), GFP_KERNEL);
-        if (police == NULL)
-                return -ENOMEM;
-        ret = ACT_P_CREATED;
-        police->tcf_refcnt = 1;
-        spin_lock_init(&police->tcf_lock);
-        if (bind)
-                police->tcf_bindcnt = 1;
+        police = to_police(a);
 override:
         if (parm->rate.rate) {
                 err = -ENOMEM;
@@ -237,16 +234,8 @@ override:
                 return ret;
 
         police->tcfp_t_c = ktime_get_ns();
-        police->tcf_index = parm->index ? parm->index :
-                tcf_hash_new_index(tn);
-        police->tcf_tm.install = jiffies;
-        police->tcf_tm.lastuse = jiffies;
-        h = tcf_hash(police->tcf_index, POL_TAB_MASK);
-        spin_lock_bh(&hinfo->lock);
-        hlist_add_head(&police->tcf_head, &hinfo->htab[h]);
-        spin_unlock_bh(&hinfo->lock);
+        tcf_hash_insert(tn, a);
 
-        a->priv = police;
         return ret;
 
 failure_unlock:
@@ -255,7 +244,7 @@ failure:
         qdisc_put_rtab(P_tab);
         qdisc_put_rtab(R_tab);
         if (ret == ACT_P_CREATED)
-                kfree(police);
+                tcf_hash_cleanup(a, est);
         return err;
 }
 
diff --git a/net/sched/cls_flower.c b/net/sched/cls_flower.c
index 730aacafc22d..b3b7978f4182 100644
--- a/net/sched/cls_flower.c
+++ b/net/sched/cls_flower.c
@@ -171,7 +171,7 @@ static void fl_hw_destroy_filter(struct tcf_proto *tp, unsigned long cookie)
         struct tc_cls_flower_offload offload = {0};
         struct tc_to_netdev tc;
 
-        if (!tc_should_offload(dev, 0))
+        if (!tc_should_offload(dev, tp, 0))
                 return;
 
         offload.command = TC_CLSFLOWER_DESTROY;
@@ -194,7 +194,7 @@ static void fl_hw_replace_filter(struct tcf_proto *tp,
         struct tc_cls_flower_offload offload = {0};
         struct tc_to_netdev tc;
 
-        if (!tc_should_offload(dev, flags))
+        if (!tc_should_offload(dev, tp, flags))
                 return;
 
         offload.command = TC_CLSFLOWER_REPLACE;
@@ -216,7 +216,7 @@ static void fl_hw_update_stats(struct tcf_proto *tp, struct cls_fl_filter *f)
         struct tc_cls_flower_offload offload = {0};
         struct tc_to_netdev tc;
 
-        if (!tc_should_offload(dev, 0))
+        if (!tc_should_offload(dev, tp, 0))
                 return;
 
         offload.command = TC_CLSFLOWER_STATS;
diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c
index 079b43b3c5d2..ffe593efe930 100644
--- a/net/sched/cls_u32.c
+++ b/net/sched/cls_u32.c
@@ -440,7 +440,7 @@ static void u32_remove_hw_knode(struct tcf_proto *tp, u32 handle)
         offload.type = TC_SETUP_CLSU32;
         offload.cls_u32 = &u32_offload;
 
-        if (tc_should_offload(dev, 0)) {
+        if (tc_should_offload(dev, tp, 0)) {
                 offload.cls_u32->command = TC_CLSU32_DELETE_KNODE;
                 offload.cls_u32->knode.handle = handle;
                 dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle,
@@ -457,20 +457,21 @@ static int u32_replace_hw_hnode(struct tcf_proto *tp,
         struct tc_to_netdev offload;
         int err;
 
+        if (!tc_should_offload(dev, tp, flags))
+                return tc_skip_sw(flags) ? -EINVAL : 0;
+
         offload.type = TC_SETUP_CLSU32;
         offload.cls_u32 = &u32_offload;
 
-        if (tc_should_offload(dev, flags)) {
-                offload.cls_u32->command = TC_CLSU32_NEW_HNODE;
-                offload.cls_u32->hnode.divisor = h->divisor;
-                offload.cls_u32->hnode.handle = h->handle;
-                offload.cls_u32->hnode.prio = h->prio;
+        offload.cls_u32->command = TC_CLSU32_NEW_HNODE;
+        offload.cls_u32->hnode.divisor = h->divisor;
+        offload.cls_u32->hnode.handle = h->handle;
+        offload.cls_u32->hnode.prio = h->prio;
 
-                err = dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle,
-                                                    tp->protocol, &offload);
-                if (tc_skip_sw(flags))
-                        return err;
-        }
+        err = dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle,
+                                            tp->protocol, &offload);
+        if (tc_skip_sw(flags))
+                return err;
 
         return 0;
 }
@@ -484,7 +485,7 @@ static void u32_clear_hw_hnode(struct tcf_proto *tp, struct tc_u_hnode *h)
         offload.type = TC_SETUP_CLSU32;
         offload.cls_u32 = &u32_offload;
 
-        if (tc_should_offload(dev, 0)) {
+        if (tc_should_offload(dev, tp, 0)) {
                 offload.cls_u32->command = TC_CLSU32_DELETE_HNODE;
                 offload.cls_u32->hnode.divisor = h->divisor;
                 offload.cls_u32->hnode.handle = h->handle;
@@ -507,27 +508,28 @@ static int u32_replace_hw_knode(struct tcf_proto *tp,
         offload.type = TC_SETUP_CLSU32;
         offload.cls_u32 = &u32_offload;
 
-        if (tc_should_offload(dev, flags)) {
-                offload.cls_u32->command = TC_CLSU32_REPLACE_KNODE;
-                offload.cls_u32->knode.handle = n->handle;
-                offload.cls_u32->knode.fshift = n->fshift;
+        if (!tc_should_offload(dev, tp, flags))
+                return tc_skip_sw(flags) ? -EINVAL : 0;
+
+        offload.cls_u32->command = TC_CLSU32_REPLACE_KNODE;
+        offload.cls_u32->knode.handle = n->handle;
+        offload.cls_u32->knode.fshift = n->fshift;
 #ifdef CONFIG_CLS_U32_MARK
-                offload.cls_u32->knode.val = n->val;
-                offload.cls_u32->knode.mask = n->mask;
+        offload.cls_u32->knode.val = n->val;
+        offload.cls_u32->knode.mask = n->mask;
 #else
-                offload.cls_u32->knode.val = 0;
-                offload.cls_u32->knode.mask = 0;
+        offload.cls_u32->knode.val = 0;
+        offload.cls_u32->knode.mask = 0;
 #endif
-                offload.cls_u32->knode.sel = &n->sel;
-                offload.cls_u32->knode.exts = &n->exts;
-                if (n->ht_down)
-                        offload.cls_u32->knode.link_handle = n->ht_down->handle;
-
-                err = dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle,
-                                                    tp->protocol, &offload);
-                if (tc_skip_sw(flags))
-                        return err;
-        }
+        offload.cls_u32->knode.sel = &n->sel;
+        offload.cls_u32->knode.exts = &n->exts;
+        if (n->ht_down)
+                offload.cls_u32->knode.link_handle = n->ht_down->handle;
+
+        err = dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle,
+                                            tp->protocol, &offload);
+        if (tc_skip_sw(flags))
+                return err;
 
         return 0;
 }
@@ -863,7 +865,7 @@ static int u32_change(struct net *net, struct sk_buff *in_skb,
         if (tb[TCA_U32_FLAGS]) {
                 flags = nla_get_u32(tb[TCA_U32_FLAGS]);
                 if (!tc_flags_valid(flags))
-                        return err;
+                        return -EINVAL;
         }
 
         n = (struct tc_u_knode *)*arg;
@@ -921,11 +923,17 @@ static int u32_change(struct net *net, struct sk_buff *in_skb,
                 ht->divisor = divisor;
                 ht->handle = handle;
                 ht->prio = tp->prio;
+
+                err = u32_replace_hw_hnode(tp, ht, flags);
+                if (err) {
+                        kfree(ht);
+                        return err;
+                }
+
                 RCU_INIT_POINTER(ht->next, tp_c->hlist);
                 rcu_assign_pointer(tp_c->hlist, ht);
                 *arg = (unsigned long)ht;
 
-                u32_replace_hw_hnode(tp, ht, flags);
                 return 0;
         }
 
diff --git a/net/sched/sch_drr.c b/net/sched/sch_drr.c
index a63e879e8975..bf8af2c43c2c 100644
--- a/net/sched/sch_drr.c
+++ b/net/sched/sch_drr.c
@@ -375,6 +375,7 @@ static int drr_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                 cl->deficit = cl->quantum;
         }
 
+        qdisc_qstats_backlog_inc(sch, skb);
         sch->q.qlen++;
         return err;
 }
@@ -407,6 +408,7 @@ static struct sk_buff *drr_dequeue(struct Qdisc *sch)
 
                         bstats_update(&cl->bstats, skb);
                         qdisc_bstats_update(sch, skb);
+                        qdisc_qstats_backlog_dec(sch, skb);
                         sch->q.qlen--;
                         return skb;
                 }
@@ -428,6 +430,7 @@ static unsigned int drr_drop(struct Qdisc *sch)
                 if (cl->qdisc->ops->drop) {
                         len = cl->qdisc->ops->drop(cl->qdisc);
                         if (len > 0) {
+                                sch->qstats.backlog -= len;
                                 sch->q.qlen--;
                                 if (cl->qdisc->q.qlen == 0)
                                         list_del(&cl->alist);
@@ -463,6 +466,7 @@ static void drr_reset_qdisc(struct Qdisc *sch)
                         qdisc_reset(cl->qdisc);
                 }
         }
+        sch->qstats.backlog = 0;
         sch->q.qlen = 0;
 }
 
diff --git a/net/sched/sch_fq_codel.c b/net/sched/sch_fq_codel.c
index 6883a8971562..da250b2e06ae 100644
--- a/net/sched/sch_fq_codel.c
+++ b/net/sched/sch_fq_codel.c
@@ -199,6 +199,7 @@ static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch)
         unsigned int idx, prev_backlog, prev_qlen;
         struct fq_codel_flow *flow;
         int uninitialized_var(ret);
+        unsigned int pkt_len;
         bool memory_limited;
 
         idx = fq_codel_classify(skb, sch, &ret);
@@ -230,6 +231,8 @@ static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch)
         prev_backlog = sch->qstats.backlog;
         prev_qlen = sch->q.qlen;
 
+        /* save this packet length as it might be dropped by fq_codel_drop() */
+        pkt_len = qdisc_pkt_len(skb);
         /* fq_codel_drop() is quite expensive, as it performs a linear search
          * in q->backlogs[] to find a fat flow.
          * So instead of dropping a single packet, drop half of its backlog
@@ -237,14 +240,23 @@ static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch)
          */
         ret = fq_codel_drop(sch, q->drop_batch_size);
 
-        q->drop_overlimit += prev_qlen - sch->q.qlen;
+        prev_qlen -= sch->q.qlen;
+        prev_backlog -= sch->qstats.backlog;
+        q->drop_overlimit += prev_qlen;
         if (memory_limited)
-                q->drop_overmemory += prev_qlen - sch->q.qlen;
-        /* As we dropped packet(s), better let upper stack know this */
-        qdisc_tree_reduce_backlog(sch, prev_qlen - sch->q.qlen,
-                                  prev_backlog - sch->qstats.backlog);
+                q->drop_overmemory += prev_qlen;
 
-        return ret == idx ? NET_XMIT_CN : NET_XMIT_SUCCESS;
+        /* As we dropped packet(s), better let upper stack know this.
+         * If we dropped a packet for this flow, return NET_XMIT_CN,
+         * but in this case, our parents wont increase their backlogs.
+         */
+        if (ret == idx) {
+                qdisc_tree_reduce_backlog(sch, prev_qlen - 1,
+                                          prev_backlog - pkt_len);
+                return NET_XMIT_CN;
+        }
+        qdisc_tree_reduce_backlog(sch, prev_qlen, prev_backlog);
+        return NET_XMIT_SUCCESS;
 }
 
 /* This is the specific function called from codel_dequeue()
@@ -649,7 +661,7 @@ static int fq_codel_dump_class_stats(struct Qdisc *sch, unsigned long cl,
                 qs.backlog = q->backlogs[idx];
                 qs.drops = flow->dropped;
         }
-        if (gnet_stats_copy_queue(d, NULL, &qs, 0) < 0)
+        if (gnet_stats_copy_queue(d, NULL, &qs, qs.qlen) < 0)
                 return -1;
         if (idx < q->flows_cnt)
                 return gnet_stats_copy_app(d, &xstats, sizeof(xstats));
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 269dd71b3828..f9e0e9c03d0a 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -49,6 +49,7 @@ static inline int dev_requeue_skb(struct sk_buff *skb, struct Qdisc *q)
 {
         q->gso_skb = skb;
         q->qstats.requeues++;
+        qdisc_qstats_backlog_inc(q, skb);
         q->q.qlen++;    /* it's still part of the queue */
         __netif_schedule(q);
 
@@ -92,6 +93,7 @@ static struct sk_buff *dequeue_skb(struct Qdisc *q, bool *validate,
                 txq = skb_get_tx_queue(txq->dev, skb);
                 if (!netif_xmit_frozen_or_stopped(txq)) {
                         q->gso_skb = NULL;
+                        qdisc_qstats_backlog_dec(q, skb);
                         q->q.qlen--;
                 } else
                         skb = NULL;
diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index d783d7cc3348..1ac9f9f03fe3 100644
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -1529,6 +1529,7 @@ hfsc_reset_qdisc(struct Qdisc *sch)
         q->eligible = RB_ROOT;
         INIT_LIST_HEAD(&q->droplist);
         qdisc_watchdog_cancel(&q->watchdog);
+        sch->qstats.backlog = 0;
         sch->q.qlen = 0;
 }
 
@@ -1559,14 +1560,6 @@ hfsc_dump_qdisc(struct Qdisc *sch, struct sk_buff *skb)
         struct hfsc_sched *q = qdisc_priv(sch);
         unsigned char *b = skb_tail_pointer(skb);
         struct tc_hfsc_qopt qopt;
-        struct hfsc_class *cl;
-        unsigned int i;
-
-        sch->qstats.backlog = 0;
-        for (i = 0; i < q->clhash.hashsize; i++) {
-                hlist_for_each_entry(cl, &q->clhash.hash[i], cl_common.hnode)
-                        sch->qstats.backlog += cl->qdisc->qstats.backlog;
-        }
 
         qopt.defcls = q->defcls;
         if (nla_put(skb, TCA_OPTIONS, sizeof(qopt), &qopt))
@@ -1604,6 +1597,7 @@ hfsc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
         if (cl->qdisc->q.qlen == 1)
                 set_active(cl, qdisc_pkt_len(skb));
 
+        qdisc_qstats_backlog_inc(sch, skb);
         sch->q.qlen++;
 
         return NET_XMIT_SUCCESS;
@@ -1672,6 +1666,7 @@ hfsc_dequeue(struct Qdisc *sch)
 
         qdisc_unthrottled(sch);
         qdisc_bstats_update(sch, skb);
+        qdisc_qstats_backlog_dec(sch, skb);
         sch->q.qlen--;
 
         return skb;
@@ -1695,6 +1690,7 @@ hfsc_drop(struct Qdisc *sch)
                         }
                         cl->qstats.drops++;
                         qdisc_qstats_drop(sch);
+                        sch->qstats.backlog -= len;
                         sch->q.qlen--;
                         return len;
                 }
diff --git a/net/sched/sch_ingress.c b/net/sched/sch_ingress.c
index 10adbc617905..8fe6999b642a 100644
--- a/net/sched/sch_ingress.c
+++ b/net/sched/sch_ingress.c
@@ -27,6 +27,11 @@ static unsigned long ingress_get(struct Qdisc *sch, u32 classid)
         return TC_H_MIN(classid) + 1;
 }
 
+static bool ingress_cl_offload(u32 classid)
+{
+        return true;
+}
+
 static unsigned long ingress_bind_filter(struct Qdisc *sch,
                                          unsigned long parent, u32 classid)
 {
@@ -86,6 +91,7 @@ static const struct Qdisc_class_ops ingress_class_ops = {
         .put            =       ingress_put,
         .walk           =       ingress_walk,
         .tcf_chain      =       ingress_find_tcf,
+        .tcf_cl_offload =       ingress_cl_offload,
         .bind_tcf       =       ingress_bind_filter,
         .unbind_tcf     =       ingress_put,
 };
@@ -110,6 +116,11 @@ static unsigned long clsact_get(struct Qdisc *sch, u32 classid)
         }
 }
 
+static bool clsact_cl_offload(u32 classid)
+{
+        return TC_H_MIN(classid) == TC_H_MIN(TC_H_MIN_INGRESS);
+}
+
 static unsigned long clsact_bind_filter(struct Qdisc *sch,
                                         unsigned long parent, u32 classid)
 {
@@ -158,6 +169,7 @@ static const struct Qdisc_class_ops clsact_class_ops = {
         .put            =       ingress_put,
         .walk           =       ingress_walk,
         .tcf_chain      =       clsact_find_tcf,
+        .tcf_cl_offload =       clsact_cl_offload,
         .bind_tcf       =       clsact_bind_filter,
         .unbind_tcf     =       ingress_put,
 };
diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c
index fee1b15506b2..4b0a82191bc4 100644
--- a/net/sched/sch_prio.c
+++ b/net/sched/sch_prio.c
@@ -85,6 +85,7 @@ prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 
         ret = qdisc_enqueue(skb, qdisc);
         if (ret == NET_XMIT_SUCCESS) {
+                qdisc_qstats_backlog_inc(sch, skb);
                 sch->q.qlen++;
                 return NET_XMIT_SUCCESS;
         }
@@ -117,6 +118,7 @@ static struct sk_buff *prio_dequeue(struct Qdisc *sch)
                 struct sk_buff *skb = qdisc_dequeue_peeked(qdisc);
                 if (skb) {
                         qdisc_bstats_update(sch, skb);
+                        qdisc_qstats_backlog_dec(sch, skb);
                         sch->q.qlen--;
                         return skb;
                 }
@@ -135,6 +137,7 @@ static unsigned int prio_drop(struct Qdisc *sch)
         for (prio = q->bands-1; prio >= 0; prio--) {
                 qdisc = q->queues[prio];
                 if (qdisc->ops->drop && (len = qdisc->ops->drop(qdisc)) != 0) {
+                        sch->qstats.backlog -= len;
                         sch->q.qlen--;
                         return len;
                 }
@@ -151,6 +154,7 @@ prio_reset(struct Qdisc *sch)
 
         for (prio = 0; prio < q->bands; prio++)
                 qdisc_reset(q->queues[prio]);
+        sch->qstats.backlog = 0;
         sch->q.qlen = 0;
 }
 
diff --git a/net/sched/sch_qfq.c b/net/sched/sch_qfq.c
index 8d2d8d953432..f18857febdad 100644
--- a/net/sched/sch_qfq.c
+++ b/net/sched/sch_qfq.c
@@ -1235,8 +1235,10 @@ static int qfq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                          cl->agg->lmax, qdisc_pkt_len(skb), cl->common.classid);
                 err = qfq_change_agg(sch, cl, cl->agg->class_weight,
                                      qdisc_pkt_len(skb));
-                if (err)
-                        return err;
+                if (err) {
+                        cl->qstats.drops++;
+                        return qdisc_drop(skb, sch);
+                }
         }
 
         err = qdisc_enqueue(skb, cl->qdisc);
diff --git a/net/sched/sch_red.c b/net/sched/sch_red.c
index 8c0508c0e287..91578bdd378c 100644
--- a/net/sched/sch_red.c
+++ b/net/sched/sch_red.c
@@ -97,6 +97,7 @@ static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 
         ret = qdisc_enqueue(skb, child);
         if (likely(ret == NET_XMIT_SUCCESS)) {
+                qdisc_qstats_backlog_inc(sch, skb);
                 sch->q.qlen++;
         } else if (net_xmit_drop_count(ret)) {
                 q->stats.pdrop++;
@@ -118,6 +119,7 @@ static struct sk_buff *red_dequeue(struct Qdisc *sch)
         skb = child->dequeue(child);
         if (skb) {
                 qdisc_bstats_update(sch, skb);
+                qdisc_qstats_backlog_dec(sch, skb);
                 sch->q.qlen--;
         } else {
                 if (!red_is_idling(&q->vars))
@@ -143,6 +145,7 @@ static unsigned int red_drop(struct Qdisc *sch)
         if (child->ops->drop && (len = child->ops->drop(child)) > 0) {
                 q->stats.other++;
                 qdisc_qstats_drop(sch);
+                sch->qstats.backlog -= len;
                 sch->q.qlen--;
                 return len;
         }
@@ -158,6 +161,7 @@ static void red_reset(struct Qdisc *sch)
         struct red_sched_data *q = qdisc_priv(sch);
 
         qdisc_reset(q->qdisc);
+        sch->qstats.backlog = 0;
         sch->q.qlen = 0;
         red_restart(&q->vars);
 }
diff --git a/net/sched/sch_tbf.c b/net/sched/sch_tbf.c
index 83b90b584fae..3161e491990b 100644
--- a/net/sched/sch_tbf.c
+++ b/net/sched/sch_tbf.c
@@ -207,6 +207,7 @@ static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch)
                 return ret;
         }
 
+        qdisc_qstats_backlog_inc(sch, skb);
         sch->q.qlen++;
         return NET_XMIT_SUCCESS;
 }
@@ -217,6 +218,7 @@ static unsigned int tbf_drop(struct Qdisc *sch)
         unsigned int len = 0;
 
         if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
+                sch->qstats.backlog -= len;
                 sch->q.qlen--;
                 qdisc_qstats_drop(sch);
         }
@@ -263,6 +265,7 @@ static struct sk_buff *tbf_dequeue(struct Qdisc *sch)
                         q->t_c = now;
                         q->tokens = toks;
                         q->ptokens = ptoks;
+                        qdisc_qstats_backlog_dec(sch, skb);
                         sch->q.qlen--;
                         qdisc_unthrottled(sch);
                         qdisc_bstats_update(sch, skb);
@@ -294,6 +297,7 @@ static void tbf_reset(struct Qdisc *sch)
         struct tbf_sched_data *q = qdisc_priv(sch);
 
         qdisc_reset(q->qdisc);
+        sch->qstats.backlog = 0;
         sch->q.qlen = 0;
         q->t_c = ktime_get_ns();
         q->tokens = q->buffer;
diff --git a/net/tipc/netlink_compat.c b/net/tipc/netlink_compat.c
index f795b1dd0ccd..3ad9fab1985f 100644
--- a/net/tipc/netlink_compat.c
+++ b/net/tipc/netlink_compat.c
@@ -604,7 +604,8 @@ static int tipc_nl_compat_link_dump(struct tipc_nl_compat_msg *msg,
 
         link_info.dest = nla_get_flag(link[TIPC_NLA_LINK_DEST]);
         link_info.up = htonl(nla_get_flag(link[TIPC_NLA_LINK_UP]));
-        strcpy(link_info.str, nla_data(link[TIPC_NLA_LINK_NAME]));
+        nla_strlcpy(link_info.str, nla_data(link[TIPC_NLA_LINK_NAME]),
+                    TIPC_MAX_LINK_NAME);
 
         return tipc_add_tlv(msg->rep, TIPC_TLV_LINK_INFO,
                             &link_info, sizeof(link_info));
diff --git a/net/wireless/core.c b/net/wireless/core.c
index d25c82bc1bbe..ecca3896b9f7 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -363,8 +363,6 @@ struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
         WARN_ON(ops->remain_on_channel && !ops->cancel_remain_on_channel);
         WARN_ON(ops->tdls_channel_switch && !ops->tdls_cancel_channel_switch);
         WARN_ON(ops->add_tx_ts && !ops->del_tx_ts);
-        WARN_ON(ops->set_tx_power && !ops->get_tx_power);
-        WARN_ON(ops->set_antenna && !ops->get_antenna);
 
         alloc_size = sizeof(*rdev) + sizeof_priv;
 
diff --git a/net/wireless/wext-core.c b/net/wireless/wext-core.c
index 6250b1cfcde5..dbb2738e356a 100644
--- a/net/wireless/wext-core.c
+++ b/net/wireless/wext-core.c
@@ -958,8 +958,29 @@ static int wireless_process_ioctl(struct net *net, struct ifreq *ifr,
                         return private(dev, iwr, cmd, info, handler);
         }
         /* Old driver API : call driver ioctl handler */
-        if (dev->netdev_ops->ndo_do_ioctl)
-                return dev->netdev_ops->ndo_do_ioctl(dev, ifr, cmd);
+        if (dev->netdev_ops->ndo_do_ioctl) {
+#ifdef CONFIG_COMPAT
+                if (info->flags & IW_REQUEST_FLAG_COMPAT) {
+                        int ret = 0;
+                        struct iwreq iwr_lcl;
+                        struct compat_iw_point *iwp_compat = (void *) &iwr->u.data;
+
+                        memcpy(&iwr_lcl, iwr, sizeof(struct iwreq));
+                        iwr_lcl.u.data.pointer = compat_ptr(iwp_compat->pointer);
+                        iwr_lcl.u.data.length = iwp_compat->length;
+                        iwr_lcl.u.data.flags = iwp_compat->flags;
+
+                        ret = dev->netdev_ops->ndo_do_ioctl(dev, (void *) &iwr_lcl, cmd);
+
+                        iwp_compat->pointer = ptr_to_compat(iwr_lcl.u.data.pointer);
+                        iwp_compat->length = iwr_lcl.u.data.length;
+                        iwp_compat->flags = iwr_lcl.u.data.flags;
+
+                        return ret;
+                } else
+#endif
+                        return dev->netdev_ops->ndo_do_ioctl(dev, ifr, cmd);
+        }
         return -EOPNOTSUPP;
 }