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

All conflicts were simple overlapping changes except perhaps
for the Thunder driver.

That driver has a change_mtu method explicitly for sending
a message to the hardware.  If that fails it returns an
error.

Normally a driver doesn't need an ndo_change_mtu method becuase those
are usually just range changes, which are now handled generically.
But since this extra operation is needed in the Thunder driver, it has
to stay.

However, if the message send fails we have to restore the original
MTU before the change because the entire call chain expects that if
an error is thrown by ndo_change_mtu then the MTU did not change.
Therefore code is added to nicvf_change_mtu to remember the original
MTU, and to restore it upon nicvf_update_hw_max_frs() failue.

Signed-off-by: David S. Miller <davem@davemloft.net>

27 files changed, 321 insertions, 113 deletions

diff --git a/net/batman-adv/hard-interface.c b/net/batman-adv/hard-interface.c
index 672150b42c61..61a431a9772b 100644
--- a/net/batman-adv/hard-interface.c
+++ b/net/batman-adv/hard-interface.c
@@ -851,6 +851,7 @@ void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface,
                         batadv_softif_destroy_sysfs(hard_iface->soft_iface);
         }
 
+        hard_iface->soft_iface = NULL;
         batadv_hardif_put(hard_iface);
 
 out:
diff --git a/net/batman-adv/tp_meter.c b/net/batman-adv/tp_meter.c
index f1564520dfae..981e8c5b07e9 100644
--- a/net/batman-adv/tp_meter.c
+++ b/net/batman-adv/tp_meter.c
@@ -834,6 +834,7 @@ static int batadv_tp_send(void *arg)
         primary_if = batadv_primary_if_get_selected(bat_priv);
         if (unlikely(!primary_if)) {
                 err = BATADV_TP_REASON_DST_UNREACHABLE;
+                tp_vars->reason = err;
                 goto out;
         }
 
diff --git a/net/core/net_namespace.c b/net/core/net_namespace.c
index 35d37b196e67..a38feac547d7 100644
--- a/net/core/net_namespace.c
+++ b/net/core/net_namespace.c
@@ -218,6 +218,8 @@ int peernet2id_alloc(struct net *net, struct net *peer)
         bool alloc;
         int id;
 
+        if (atomic_read(&net->count) == 0)
+                return NETNSA_NSID_NOT_ASSIGNED;
         spin_lock_irqsave(&net->nsid_lock, flags);
         alloc = atomic_read(&peer->count) == 0 ? false : true;
         id = __peernet2id_alloc(net, peer, &alloc);
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index db313ec7af32..a99917b5de33 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -840,18 +840,20 @@ static inline int rtnl_vfinfo_size(const struct net_device *dev,
         if (dev->dev.parent && dev_is_pci(dev->dev.parent) &&
             (ext_filter_mask & RTEXT_FILTER_VF)) {
                 int num_vfs = dev_num_vf(dev->dev.parent);
-                size_t size = nla_total_size(sizeof(struct nlattr));
-                size += nla_total_size(num_vfs * sizeof(struct nlattr));
+                size_t size = nla_total_size(0);
                 size += num_vfs *
-                        (nla_total_size(sizeof(struct ifla_vf_mac)) +
-                         nla_total_size(MAX_VLAN_LIST_LEN *
-                                        sizeof(struct nlattr)) +
+                        (nla_total_size(0) +
+                         nla_total_size(sizeof(struct ifla_vf_mac)) +
+                         nla_total_size(sizeof(struct ifla_vf_vlan)) +
+                         nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */
                          nla_total_size(MAX_VLAN_LIST_LEN *
                                         sizeof(struct ifla_vf_vlan_info)) +
                          nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
+                         nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
                          nla_total_size(sizeof(struct ifla_vf_rate)) +
                          nla_total_size(sizeof(struct ifla_vf_link_state)) +
                          nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
+                         nla_total_size(0) + /* nest IFLA_VF_STATS */
                          /* IFLA_VF_STATS_RX_PACKETS */
                          nla_total_size_64bit(sizeof(__u64)) +
                          /* IFLA_VF_STATS_TX_PACKETS */
@@ -899,7 +901,8 @@ static size_t rtnl_port_size(const struct net_device *dev,
 
 static size_t rtnl_xdp_size(const struct net_device *dev)
 {
-        size_t xdp_size = nla_total_size(1);    /* XDP_ATTACHED */
+        size_t xdp_size = nla_total_size(0) +   /* nest IFLA_XDP */
+                          nla_total_size(1);    /* XDP_ATTACHED */
 
         if (!dev->netdev_ops->ndo_xdp)
                 return 0;
@@ -1606,7 +1609,7 @@ static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
                 head = &net->dev_index_head[h];
                 hlist_for_each_entry(dev, head, index_hlist) {
                         if (link_dump_filtered(dev, master_idx, kind_ops))
-                                continue;
+                                goto cont;
                         if (idx < s_idx)
                                 goto cont;
                         err = rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
@@ -2849,7 +2852,10 @@ nla_put_failure:
 
 static inline size_t rtnl_fdb_nlmsg_size(void)
 {
-        return NLMSG_ALIGN(sizeof(struct ndmsg)) + nla_total_size(ETH_ALEN);
+        return NLMSG_ALIGN(sizeof(struct ndmsg)) +
+               nla_total_size(ETH_ALEN) +       /* NDA_LLADDR */
+               nla_total_size(sizeof(u16)) +    /* NDA_VLAN */
+               0;
 }
 
 static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type,
diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index d93eea8e2409..121384bbb40b 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -151,7 +151,7 @@ static void fib_replace_table(struct net *net, struct fib_table *old,
 
 int fib_unmerge(struct net *net)
 {
-        struct fib_table *old, *new;
+        struct fib_table *old, *new, *main_table;
 
         /* attempt to fetch local table if it has been allocated */
         old = fib_get_table(net, RT_TABLE_LOCAL);
@@ -162,11 +162,21 @@ int fib_unmerge(struct net *net)
         if (!new)
                 return -ENOMEM;
 
+        /* table is already unmerged */
+        if (new == old)
+                return 0;
+
         /* replace merged table with clean table */
-        if (new != old) {
-                fib_replace_table(net, old, new);
-                fib_free_table(old);
-        }
+        fib_replace_table(net, old, new);
+        fib_free_table(old);
+
+        /* attempt to fetch main table if it has been allocated */
+        main_table = fib_get_table(net, RT_TABLE_MAIN);
+        if (!main_table)
+                return 0;
+
+        /* flush local entries from main table */
+        fib_table_flush_external(main_table);
 
         return 0;
 }
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index 4cff74d4133f..026f309c51e9 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -1743,8 +1743,10 @@ struct fib_table *fib_trie_unmerge(struct fib_table *oldtb)
                                 local_l = fib_find_node(lt, &local_tp, l->key);
 
                         if (fib_insert_alias(lt, local_tp, local_l, new_fa,
-                                             NULL, l->key))
+                                             NULL, l->key)) {
+                                kmem_cache_free(fn_alias_kmem, new_fa);
                                 goto out;
+                        }
                 }
 
                 /* stop loop if key wrapped back to 0 */
@@ -1760,6 +1762,71 @@ out:
         return NULL;
 }
 
+/* Caller must hold RTNL */
+void fib_table_flush_external(struct fib_table *tb)
+{
+        struct trie *t = (struct trie *)tb->tb_data;
+        struct key_vector *pn = t->kv;
+        unsigned long cindex = 1;
+        struct hlist_node *tmp;
+        struct fib_alias *fa;
+
+        /* walk trie in reverse order */
+        for (;;) {
+                unsigned char slen = 0;
+                struct key_vector *n;
+
+                if (!(cindex--)) {
+                        t_key pkey = pn->key;
+
+                        /* cannot resize the trie vector */
+                        if (IS_TRIE(pn))
+                                break;
+
+                        /* resize completed node */
+                        pn = resize(t, pn);
+                        cindex = get_index(pkey, pn);
+
+                        continue;
+                }
+
+                /* grab the next available node */
+                n = get_child(pn, cindex);
+                if (!n)
+                        continue;
+
+                if (IS_TNODE(n)) {
+                        /* record pn and cindex for leaf walking */
+                        pn = n;
+                        cindex = 1ul << n->bits;
+
+                        continue;
+                }
+
+                hlist_for_each_entry_safe(fa, tmp, &n->leaf, fa_list) {
+                        /* if alias was cloned to local then we just
+                         * need to remove the local copy from main
+                         */
+                        if (tb->tb_id != fa->tb_id) {
+                                hlist_del_rcu(&fa->fa_list);
+                                alias_free_mem_rcu(fa);
+                                continue;
+                        }
+
+                        /* record local slen */
+                        slen = fa->fa_slen;
+                }
+
+                /* update leaf slen */
+                n->slen = slen;
+
+                if (hlist_empty(&n->leaf)) {
+                        put_child_root(pn, n->key, NULL);
+                        node_free(n);
+                }
+        }
+}
+
 /* Caller must hold RTNL. */
 int fib_table_flush(struct net *net, struct fib_table *tb)
 {
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index 606cc3e85d2b..15db786d50ed 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -162,7 +162,7 @@ static int unsolicited_report_interval(struct in_device *in_dev)
 }
 
 static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im);
-static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr);
+static void igmpv3_del_delrec(struct in_device *in_dev, struct ip_mc_list *im);
 static void igmpv3_clear_delrec(struct in_device *in_dev);
 static int sf_setstate(struct ip_mc_list *pmc);
 static void sf_markstate(struct ip_mc_list *pmc);
@@ -1130,10 +1130,15 @@ static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im)
         spin_unlock_bh(&in_dev->mc_tomb_lock);
 }
 
-static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr)
+/*
+ * restore ip_mc_list deleted records
+ */
+static void igmpv3_del_delrec(struct in_device *in_dev, struct ip_mc_list *im)
 {
         struct ip_mc_list *pmc, *pmc_prev;
-        struct ip_sf_list *psf, *psf_next;
+        struct ip_sf_list *psf;
+        struct net *net = dev_net(in_dev->dev);
+        __be32 multiaddr = im->multiaddr;
 
         spin_lock_bh(&in_dev->mc_tomb_lock);
         pmc_prev = NULL;
@@ -1149,16 +1154,26 @@ static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr)
                         in_dev->mc_tomb = pmc->next;
         }
         spin_unlock_bh(&in_dev->mc_tomb_lock);
+
+        spin_lock_bh(&im->lock);
         if (pmc) {
-                for (psf = pmc->tomb; psf; psf = psf_next) {
-                        psf_next = psf->sf_next;
-                        kfree(psf);
+                im->interface = pmc->interface;
+                im->crcount = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv;
+                im->sfmode = pmc->sfmode;
+                if (pmc->sfmode == MCAST_INCLUDE) {
+                        im->tomb = pmc->tomb;
+                        im->sources = pmc->sources;
+                        for (psf = im->sources; psf; psf = psf->sf_next)
+                                psf->sf_crcount = im->crcount;
                 }
                 in_dev_put(pmc->interface);
-                kfree(pmc);
         }
+        spin_unlock_bh(&im->lock);
 }
 
+/*
+ * flush ip_mc_list deleted records
+ */
 static void igmpv3_clear_delrec(struct in_device *in_dev)
 {
         struct ip_mc_list *pmc, *nextpmc;
@@ -1366,7 +1381,7 @@ void ip_mc_inc_group(struct in_device *in_dev, __be32 addr)
         ip_mc_hash_add(in_dev, im);
 
 #ifdef CONFIG_IP_MULTICAST
-        igmpv3_del_delrec(in_dev, im->multiaddr);
+        igmpv3_del_delrec(in_dev, im);
 #endif
         igmp_group_added(im);
         if (!in_dev->dead)
@@ -1626,8 +1641,12 @@ void ip_mc_remap(struct in_device *in_dev)
 
         ASSERT_RTNL();
 
-        for_each_pmc_rtnl(in_dev, pmc)
+        for_each_pmc_rtnl(in_dev, pmc) {
+#ifdef CONFIG_IP_MULTICAST
+                igmpv3_del_delrec(in_dev, pmc);
+#endif
                 igmp_group_added(pmc);
+        }
 }
 
 /* Device going down */
@@ -1648,7 +1667,6 @@ void ip_mc_down(struct in_device *in_dev)
         in_dev->mr_gq_running = 0;
         if (del_timer(&in_dev->mr_gq_timer))
                 __in_dev_put(in_dev);
-        igmpv3_clear_delrec(in_dev);
 #endif
 
         ip_mc_dec_group(in_dev, IGMP_ALL_HOSTS);
@@ -1688,8 +1706,12 @@ void ip_mc_up(struct in_device *in_dev)
 #endif
         ip_mc_inc_group(in_dev, IGMP_ALL_HOSTS);
 
-        for_each_pmc_rtnl(in_dev, pmc)
+        for_each_pmc_rtnl(in_dev, pmc) {
+#ifdef CONFIG_IP_MULTICAST
+                igmpv3_del_delrec(in_dev, pmc);
+#endif
                 igmp_group_added(pmc);
+        }
 }
 
 /*
@@ -1704,13 +1726,13 @@ void ip_mc_destroy_dev(struct in_device *in_dev)
 
         /* Deactivate timers */
         ip_mc_down(in_dev);
+#ifdef CONFIG_IP_MULTICAST
+        igmpv3_clear_delrec(in_dev);
+#endif
 
         while ((i = rtnl_dereference(in_dev->mc_list)) != NULL) {
                 in_dev->mc_list = i->next_rcu;
                 in_dev->mc_count--;
-
-                /* We've dropped the groups in ip_mc_down already */
-                ip_mc_clear_src(i);
                 ip_ma_put(i);
         }
 }
diff --git a/net/ipv4/tcp_cong.c b/net/ipv4/tcp_cong.c
index 38905ec5f508..79c4817abc94 100644
--- a/net/ipv4/tcp_cong.c
+++ b/net/ipv4/tcp_cong.c
@@ -201,8 +201,10 @@ static void tcp_reinit_congestion_control(struct sock *sk,
         icsk->icsk_ca_ops = ca;
         icsk->icsk_ca_setsockopt = 1;
 
-        if (sk->sk_state != TCP_CLOSE)
+        if (sk->sk_state != TCP_CLOSE) {
+                memset(icsk->icsk_ca_priv, 0, sizeof(icsk->icsk_ca_priv));
                 tcp_init_congestion_control(sk);
+        }
 }
 
 /* Manage refcounts on socket close. */
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index b949770fdc08..b3b6bc5b9731 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -1743,10 +1743,10 @@ static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
 
         if (use_hash2) {
                 hash2_any = udp4_portaddr_hash(net, htonl(INADDR_ANY), hnum) &
-                            udp_table.mask;
-                hash2 = udp4_portaddr_hash(net, daddr, hnum) & udp_table.mask;
+                            udptable->mask;
+                hash2 = udp4_portaddr_hash(net, daddr, hnum) & udptable->mask;
 start_lookup:
-                hslot = &udp_table.hash2[hash2];
+                hslot = &udptable->hash2[hash2];
                 offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node);
         }
 
diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c
index d3c619eda051..1f49fb1101a1 100644
--- a/net/ipv6/ip6_tunnel.c
+++ b/net/ipv6/ip6_tunnel.c
@@ -1034,6 +1034,7 @@ int ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev, __u8 dsfield,
         int mtu;
         unsigned int psh_hlen = sizeof(struct ipv6hdr) + t->encap_hlen;
         unsigned int max_headroom = psh_hlen;
+        bool use_cache = false;
         u8 hop_limit;
         int err = -1;
 
@@ -1066,7 +1067,15 @@ int ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev, __u8 dsfield,
 
                 memcpy(&fl6->daddr, addr6, sizeof(fl6->daddr));
                 neigh_release(neigh);
-        } else if (!fl6->flowi6_mark)
+        } else if (!(t->parms.flags &
+                     (IP6_TNL_F_USE_ORIG_TCLASS | IP6_TNL_F_USE_ORIG_FWMARK))) {
+                /* enable the cache only only if the routing decision does
+                 * not depend on the current inner header value
+                 */
+                use_cache = true;
+        }
+
+        if (use_cache)
                 dst = dst_cache_get(&t->dst_cache);
 
         if (!ip6_tnl_xmit_ctl(t, &fl6->saddr, &fl6->daddr))
@@ -1150,7 +1159,7 @@ route_lookup:
                 if (t->encap.type != TUNNEL_ENCAP_NONE)
                         goto tx_err_dst_release;
         } else {
-                if (!fl6->flowi6_mark && ndst)
+                if (use_cache && ndst)
                         dst_cache_set_ip6(&t->dst_cache, ndst, &fl6->saddr);
         }
         skb_dst_set(skb, dst);
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index 8fd4d89380b8..ba25ec20806b 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -691,10 +691,10 @@ static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
 
         if (use_hash2) {
                 hash2_any = udp6_portaddr_hash(net, &in6addr_any, hnum) &
-                            udp_table.mask;
-                hash2 = udp6_portaddr_hash(net, daddr, hnum) & udp_table.mask;
+                            udptable->mask;
+                hash2 = udp6_portaddr_hash(net, daddr, hnum) & udptable->mask;
 start_lookup:
-                hslot = &udp_table.hash2[hash2];
+                hslot = &udptable->hash2[hash2];
                 offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node);
         }
 
diff --git a/net/l2tp/l2tp_eth.c b/net/l2tp/l2tp_eth.c
index e2c6ae024565..5b90eb6c82c4 100644
--- a/net/l2tp/l2tp_eth.c
+++ b/net/l2tp/l2tp_eth.c
@@ -97,7 +97,7 @@ static int l2tp_eth_dev_xmit(struct sk_buff *skb, struct net_device *dev)
         unsigned int len = skb->len;
         int ret = l2tp_xmit_skb(session, skb, session->hdr_len);
 
-        if (likely(ret == NET_XMIT_SUCCESS)) {
+        if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
                 atomic_long_add(len, &priv->tx_bytes);
                 atomic_long_inc(&priv->tx_packets);
         } else {
diff --git a/net/l2tp/l2tp_ip.c b/net/l2tp/l2tp_ip.c
index fce25afb652a..982f6c44ea01 100644
--- a/net/l2tp/l2tp_ip.c
+++ b/net/l2tp/l2tp_ip.c
@@ -251,8 +251,6 @@ static int l2tp_ip_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
         int ret;
         int chk_addr_ret;
 
-        if (!sock_flag(sk, SOCK_ZAPPED))
-                return -EINVAL;
         if (addr_len < sizeof(struct sockaddr_l2tpip))
                 return -EINVAL;
         if (addr->l2tp_family != AF_INET)
@@ -267,6 +265,9 @@ static int l2tp_ip_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
         read_unlock_bh(&l2tp_ip_lock);
 
         lock_sock(sk);
+        if (!sock_flag(sk, SOCK_ZAPPED))
+                goto out;
+
         if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_l2tpip))
                 goto out;
 
diff --git a/net/l2tp/l2tp_ip6.c b/net/l2tp/l2tp_ip6.c
index 1cea54feab27..667ec909846f 100644
--- a/net/l2tp/l2tp_ip6.c
+++ b/net/l2tp/l2tp_ip6.c
@@ -269,8 +269,6 @@ static int l2tp_ip6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
         int addr_type;
         int err;
 
-        if (!sock_flag(sk, SOCK_ZAPPED))
-                return -EINVAL;
         if (addr->l2tp_family != AF_INET6)
                 return -EINVAL;
         if (addr_len < sizeof(*addr))
@@ -296,6 +294,9 @@ static int l2tp_ip6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
         lock_sock(sk);
 
         err = -EINVAL;
+        if (!sock_flag(sk, SOCK_ZAPPED))
+                goto out_unlock;
+
         if (sk->sk_state != TCP_CLOSE)
                 goto out_unlock;
 
diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c
index 236d47e76ced..1711bae4abf2 100644
--- a/net/mac80211/sta_info.c
+++ b/net/mac80211/sta_info.c
@@ -688,7 +688,7 @@ static void __sta_info_recalc_tim(struct sta_info *sta, bool ignore_pending)
         }
 
         /* No need to do anything if the driver does all */
-        if (!local->ops->set_tim)
+        if (ieee80211_hw_check(&local->hw, AP_LINK_PS))
                 return;
 
         if (sta->dead)
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index 62ccaf6f585d..2c21b7039136 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -1500,7 +1500,6 @@ static bool ieee80211_queue_skb(struct ieee80211_local *local,
                                 struct sta_info *sta,
                                 struct sk_buff *skb)
 {
-        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         struct fq *fq = &local->fq;
         struct ieee80211_vif *vif;
         struct txq_info *txqi;
@@ -1525,8 +1524,6 @@ static bool ieee80211_queue_skb(struct ieee80211_local *local,
         if (!txqi)
                 return false;
 
-        info->control.vif = vif;
-
         spin_lock_bh(&fq->lock);
         ieee80211_txq_enqueue(local, txqi, skb);
         spin_unlock_bh(&fq->lock);
@@ -3238,7 +3235,6 @@ static void ieee80211_xmit_fast_finish(struct ieee80211_sub_if_data *sdata,
 
         if (hdr->frame_control & cpu_to_le16(IEEE80211_STYPE_QOS_DATA)) {
                 tid = skb->priority & IEEE80211_QOS_CTL_TAG1D_MASK;
-                *ieee80211_get_qos_ctl(hdr) = tid;
                 hdr->seq_ctrl = ieee80211_tx_next_seq(sta, tid);
         } else {
                 info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
@@ -3363,6 +3359,11 @@ static bool ieee80211_xmit_fast(struct ieee80211_sub_if_data *sdata,
                       (tid_tx ? IEEE80211_TX_CTL_AMPDU : 0);
         info->control.flags = IEEE80211_TX_CTRL_FAST_XMIT;
 
+        if (hdr->frame_control & cpu_to_le16(IEEE80211_STYPE_QOS_DATA)) {
+                tid = skb->priority & IEEE80211_QOS_CTL_TAG1D_MASK;
+                *ieee80211_get_qos_ctl(hdr) = tid;
+        }
+
         __skb_queue_head_init(&tx.skbs);
 
         tx.flags = IEEE80211_TX_UNICAST;
@@ -3451,6 +3452,11 @@ begin:
                 goto begin;
         }
 
+        if (test_bit(IEEE80211_TXQ_AMPDU, &txqi->flags))
+                info->flags |= IEEE80211_TX_CTL_AMPDU;
+        else
+                info->flags &= ~IEEE80211_TX_CTL_AMPDU;
+
         if (info->control.flags & IEEE80211_TX_CTRL_FAST_XMIT) {
                 struct sta_info *sta = container_of(txq->sta, struct sta_info,
                                                     sta);
diff --git a/net/mac80211/vht.c b/net/mac80211/vht.c
index ee715764a828..6832bf6ab69f 100644
--- a/net/mac80211/vht.c
+++ b/net/mac80211/vht.c
@@ -270,6 +270,22 @@ ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
                 vht_cap->vht_mcs.tx_mcs_map |= cpu_to_le16(peer_tx << i * 2);
         }
 
+        /*
+         * This is a workaround for VHT-enabled STAs which break the spec
+         * and have the VHT-MCS Rx map filled in with value 3 for all eight
+         * spacial streams, an example is AR9462.
+         *
+         * As per spec, in section 22.1.1 Introduction to the VHT PHY
+         * A VHT STA shall support at least single spactial stream VHT-MCSs
+         * 0 to 7 (transmit and receive) in all supported channel widths.
+         */
+        if (vht_cap->vht_mcs.rx_mcs_map == cpu_to_le16(0xFFFF)) {
+                vht_cap->vht_supported = false;
+                sdata_info(sdata, "Ignoring VHT IE from %pM due to invalid rx_mcs_map\n",
+                           sta->addr);
+                return;
+        }
+
         /* finally set up the bandwidth */
         switch (vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
         case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index 2b2a7974e4bb..8e93d4afe5ea 100644
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -112,7 +112,7 @@ static void tfilter_notify_chain(struct net *net, struct sk_buff *oskb,
 
         for (it_chain = chain; (tp = rtnl_dereference(*it_chain)) != NULL;
              it_chain = &tp->next)
-                tfilter_notify(net, oskb, n, tp, 0, event, false);
+                tfilter_notify(net, oskb, n, tp, n->nlmsg_flags, event, false);
 }
 
 /* Select new prio value from the range, managed by kernel. */
@@ -430,7 +430,8 @@ static int tfilter_notify(struct net *net, struct sk_buff *oskb,
         if (!skb)
                 return -ENOBUFS;
 
-        if (tcf_fill_node(net, skb, tp, fh, portid, n->nlmsg_seq, 0, event) <= 0) {
+        if (tcf_fill_node(net, skb, tp, fh, portid, n->nlmsg_seq,
+                          n->nlmsg_flags, event) <= 0) {
                 kfree_skb(skb);
                 return -EINVAL;
         }
diff --git a/net/socket.c b/net/socket.c
index f9e26c68c3cf..e2584c51aa1f 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -341,8 +341,23 @@ static const struct xattr_handler sockfs_xattr_handler = {
         .get = sockfs_xattr_get,
 };
 
+static int sockfs_security_xattr_set(const struct xattr_handler *handler,
+                                     struct dentry *dentry, struct inode *inode,
+                                     const char *suffix, const void *value,
+                                     size_t size, int flags)
+{
+        /* Handled by LSM. */
+        return -EAGAIN;
+}
+
+static const struct xattr_handler sockfs_security_xattr_handler = {
+        .prefix = XATTR_SECURITY_PREFIX,
+        .set = sockfs_security_xattr_set,
+};
+
 static const struct xattr_handler *sockfs_xattr_handlers[] = {
         &sockfs_xattr_handler,
+        &sockfs_security_xattr_handler,
         NULL
 };
 
diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c
index c3f652395a80..3bc1d61694cb 100644
--- a/net/sunrpc/svc_xprt.c
+++ b/net/sunrpc/svc_xprt.c
@@ -1002,14 +1002,8 @@ static void svc_age_temp_xprts(unsigned long closure)
 void svc_age_temp_xprts_now(struct svc_serv *serv, struct sockaddr *server_addr)
 {
         struct svc_xprt *xprt;
-        struct svc_sock *svsk;
-        struct socket *sock;
         struct list_head *le, *next;
         LIST_HEAD(to_be_closed);
-        struct linger no_linger = {
-                .l_onoff = 1,
-                .l_linger = 0,
-        };
 
         spin_lock_bh(&serv->sv_lock);
         list_for_each_safe(le, next, &serv->sv_tempsocks) {
@@ -1027,10 +1021,7 @@ void svc_age_temp_xprts_now(struct svc_serv *serv, struct sockaddr *server_addr)
                 list_del_init(le);
                 xprt = list_entry(le, struct svc_xprt, xpt_list);
                 dprintk("svc_age_temp_xprts_now: closing %p\n", xprt);
-                svsk = container_of(xprt, struct svc_sock, sk_xprt);
-                sock = svsk->sk_sock;
-                kernel_setsockopt(sock, SOL_SOCKET, SO_LINGER,
-                                  (char *)&no_linger, sizeof(no_linger));
+                xprt->xpt_ops->xpo_kill_temp_xprt(xprt);
                 svc_close_xprt(xprt);
         }
 }
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 78da4aee3543..135ec2c11b3b 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -451,6 +451,21 @@ static int svc_tcp_has_wspace(struct svc_xprt *xprt)
         return !test_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
 }
 
+static void svc_tcp_kill_temp_xprt(struct svc_xprt *xprt)
+{
+        struct svc_sock *svsk;
+        struct socket *sock;
+        struct linger no_linger = {
+                .l_onoff = 1,
+                .l_linger = 0,
+        };
+
+        svsk = container_of(xprt, struct svc_sock, sk_xprt);
+        sock = svsk->sk_sock;
+        kernel_setsockopt(sock, SOL_SOCKET, SO_LINGER,
+                          (char *)&no_linger, sizeof(no_linger));
+}
+
 /*
  * See net/ipv6/ip_sockglue.c : ip_cmsg_recv_pktinfo
  */
@@ -660,6 +675,10 @@ static struct svc_xprt *svc_udp_accept(struct svc_xprt *xprt)
         return NULL;
 }
 
+static void svc_udp_kill_temp_xprt(struct svc_xprt *xprt)
+{
+}
+
 static struct svc_xprt *svc_udp_create(struct svc_serv *serv,
                                        struct net *net,
                                        struct sockaddr *sa, int salen,
@@ -679,6 +698,7 @@ static struct svc_xprt_ops svc_udp_ops = {
         .xpo_has_wspace = svc_udp_has_wspace,
         .xpo_accept = svc_udp_accept,
         .xpo_secure_port = svc_sock_secure_port,
+        .xpo_kill_temp_xprt = svc_udp_kill_temp_xprt,
 };
 
 static struct svc_xprt_class svc_udp_class = {
@@ -1254,6 +1274,7 @@ static struct svc_xprt_ops svc_tcp_ops = {
         .xpo_has_wspace = svc_tcp_has_wspace,
         .xpo_accept = svc_tcp_accept,
         .xpo_secure_port = svc_sock_secure_port,
+        .xpo_kill_temp_xprt = svc_tcp_kill_temp_xprt,
 };
 
 static struct svc_xprt_class svc_tcp_class = {
diff --git a/net/sunrpc/xprtrdma/svc_rdma_transport.c b/net/sunrpc/xprtrdma/svc_rdma_transport.c
index 6864fb967038..1334de2715c2 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_transport.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_transport.c
@@ -67,6 +67,7 @@ static void svc_rdma_detach(struct svc_xprt *xprt);
 static void svc_rdma_free(struct svc_xprt *xprt);
 static int svc_rdma_has_wspace(struct svc_xprt *xprt);
 static int svc_rdma_secure_port(struct svc_rqst *);
+static void svc_rdma_kill_temp_xprt(struct svc_xprt *);
 
 static struct svc_xprt_ops svc_rdma_ops = {
         .xpo_create = svc_rdma_create,
@@ -79,6 +80,7 @@ static struct svc_xprt_ops svc_rdma_ops = {
         .xpo_has_wspace = svc_rdma_has_wspace,
         .xpo_accept = svc_rdma_accept,
         .xpo_secure_port = svc_rdma_secure_port,
+        .xpo_kill_temp_xprt = svc_rdma_kill_temp_xprt,
 };
 
 struct svc_xprt_class svc_rdma_class = {
@@ -1317,6 +1319,10 @@ static int svc_rdma_secure_port(struct svc_rqst *rqstp)
         return 1;
 }
 
+static void svc_rdma_kill_temp_xprt(struct svc_xprt *xprt)
+{
+}
+
 int svc_rdma_send(struct svcxprt_rdma *xprt, struct ib_send_wr *wr)
 {
         struct ib_send_wr *bad_wr, *n_wr;
diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index 22d92f0ec5ac..4916d8fea328 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -1,7 +1,7 @@
 /*
  * net/tipc/socket.c: TIPC socket API
  *
- * Copyright (c) 2001-2007, 2012-2015, Ericsson AB
+ * Copyright (c) 2001-2007, 2012-2016, Ericsson AB
  * Copyright (c) 2004-2008, 2010-2013, Wind River Systems
  * All rights reserved.
  *
@@ -127,54 +127,8 @@ static const struct proto_ops packet_ops;
 static const struct proto_ops stream_ops;
 static const struct proto_ops msg_ops;
 static struct proto tipc_proto;
-
 static const struct rhashtable_params tsk_rht_params;
 
-/*
- * Revised TIPC socket locking policy:
- *
- * Most socket operations take the standard socket lock when they start
- * and hold it until they finish (or until they need to sleep).  Acquiring
- * this lock grants the owner exclusive access to the fields of the socket
- * data structures, with the exception of the backlog queue.  A few socket
- * operations can be done without taking the socket lock because they only
- * read socket information that never changes during the life of the socket.
- *
- * Socket operations may acquire the lock for the associated TIPC port if they
- * need to perform an operation on the port.  If any routine needs to acquire
- * both the socket lock and the port lock it must take the socket lock first
- * to avoid the risk of deadlock.
- *
- * The dispatcher handling incoming messages cannot grab the socket lock in
- * the standard fashion, since invoked it runs at the BH level and cannot block.
- * Instead, it checks to see if the socket lock is currently owned by someone,
- * and either handles the message itself or adds it to the socket's backlog
- * queue; in the latter case the queued message is processed once the process
- * owning the socket lock releases it.
- *
- * NOTE: Releasing the socket lock while an operation is sleeping overcomes
- * the problem of a blocked socket operation preventing any other operations
- * from occurring.  However, applications must be careful if they have
- * multiple threads trying to send (or receive) on the same socket, as these
- * operations might interfere with each other.  For example, doing a connect
- * and a receive at the same time might allow the receive to consume the
- * ACK message meant for the connect.  While additional work could be done
- * to try and overcome this, it doesn't seem to be worthwhile at the present.
- *
- * NOTE: Releasing the socket lock while an operation is sleeping also ensures
- * that another operation that must be performed in a non-blocking manner is
- * not delayed for very long because the lock has already been taken.
- *
- * NOTE: This code assumes that certain fields of a port/socket pair are
- * constant over its lifetime; such fields can be examined without taking
- * the socket lock and/or port lock, and do not need to be re-read even
- * after resuming processing after waiting.  These fields include:
- *   - socket type
- *   - pointer to socket sk structure (aka tipc_sock structure)
- *   - pointer to port structure
- *   - port reference
- */
-
 static u32 tsk_own_node(struct tipc_sock *tsk)
 {
         return msg_prevnode(&tsk->phdr);
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 6a705d0ff889..1752d6b10ac4 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -2199,7 +2199,8 @@ out:
  *      Sleep until more data has arrived. But check for races..
  */
 static long unix_stream_data_wait(struct sock *sk, long timeo,
-                                  struct sk_buff *last, unsigned int last_len)
+                                  struct sk_buff *last, unsigned int last_len,
+                                  bool freezable)
 {
         struct sk_buff *tail;
         DEFINE_WAIT(wait);
@@ -2220,7 +2221,10 @@ static long unix_stream_data_wait(struct sock *sk, long timeo,
 
                 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
                 unix_state_unlock(sk);
-                timeo = freezable_schedule_timeout(timeo);
+                if (freezable)
+                        timeo = freezable_schedule_timeout(timeo);
+                else
+                        timeo = schedule_timeout(timeo);
                 unix_state_lock(sk);
 
                 if (sock_flag(sk, SOCK_DEAD))
@@ -2250,7 +2254,8 @@ struct unix_stream_read_state {
         unsigned int splice_flags;
 };
 
-static int unix_stream_read_generic(struct unix_stream_read_state *state)
+static int unix_stream_read_generic(struct unix_stream_read_state *state,
+                                    bool freezable)
 {
         struct scm_cookie scm;
         struct socket *sock = state->socket;
@@ -2330,7 +2335,7 @@ again:
                         mutex_unlock(&u->iolock);
 
                         timeo = unix_stream_data_wait(sk, timeo, last,
-                                                      last_len);
+                                                      last_len, freezable);
 
                         if (signal_pending(current)) {
                                 err = sock_intr_errno(timeo);
@@ -2472,7 +2477,7 @@ static int unix_stream_recvmsg(struct socket *sock, struct msghdr *msg,
                 .flags = flags
         };
 
-        return unix_stream_read_generic(&state);
+        return unix_stream_read_generic(&state, true);
 }
 
 static int unix_stream_splice_actor(struct sk_buff *skb,
@@ -2503,7 +2508,7 @@ static ssize_t unix_stream_splice_read(struct socket *sock,  loff_t *ppos,
             flags & SPLICE_F_NONBLOCK)
                 state.flags = MSG_DONTWAIT;
 
-        return unix_stream_read_generic(&state);
+        return unix_stream_read_generic(&state, false);
 }
 
 static int unix_shutdown(struct socket *sock, int mode)
diff --git a/net/wireless/core.h b/net/wireless/core.h
index fb2fcd5581fe..ec5f33311769 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -71,6 +71,7 @@ struct cfg80211_registered_device {
         struct list_head bss_list;
         struct rb_root bss_tree;
         u32 bss_generation;
+        u32 bss_entries;
         struct cfg80211_scan_request *scan_req; /* protected by RTNL */
         struct sk_buff *scan_msg;
         struct cfg80211_sched_scan_request __rcu *sched_scan_req;
diff --git a/net/wireless/scan.c b/net/wireless/scan.c
index b5bd58d0f731..35ad69fd0838 100644
--- a/net/wireless/scan.c
+++ b/net/wireless/scan.c
@@ -57,6 +57,19 @@
  * also linked into the probe response struct.
  */
 
+/*
+ * Limit the number of BSS entries stored in mac80211. Each one is
+ * a bit over 4k at most, so this limits to roughly 4-5M of memory.
+ * If somebody wants to really attack this though, they'd likely
+ * use small beacons, and only one type of frame, limiting each of
+ * the entries to a much smaller size (in order to generate more
+ * entries in total, so overhead is bigger.)
+ */
+static int bss_entries_limit = 1000;
+module_param(bss_entries_limit, int, 0644);
+MODULE_PARM_DESC(bss_entries_limit,
+                 "limit to number of scan BSS entries (per wiphy, default 1000)");
+
 #define IEEE80211_SCAN_RESULT_EXPIRE    (30 * HZ)
 
 static void bss_free(struct cfg80211_internal_bss *bss)
@@ -137,6 +150,10 @@ static bool __cfg80211_unlink_bss(struct cfg80211_registered_device *rdev,
 
         list_del_init(&bss->list);
         rb_erase(&bss->rbn, &rdev->bss_tree);
+        rdev->bss_entries--;
+        WARN_ONCE((rdev->bss_entries == 0) ^ list_empty(&rdev->bss_list),
+                  "rdev bss entries[%d]/list[empty:%d] corruption\n",
+                  rdev->bss_entries, list_empty(&rdev->bss_list));
         bss_ref_put(rdev, bss);
         return true;
 }
@@ -163,6 +180,40 @@ static void __cfg80211_bss_expire(struct cfg80211_registered_device *rdev,
                 rdev->bss_generation++;
 }
 
+static bool cfg80211_bss_expire_oldest(struct cfg80211_registered_device *rdev)
+{
+        struct cfg80211_internal_bss *bss, *oldest = NULL;
+        bool ret;
+
+        lockdep_assert_held(&rdev->bss_lock);
+
+        list_for_each_entry(bss, &rdev->bss_list, list) {
+                if (atomic_read(&bss->hold))
+                        continue;
+
+                if (!list_empty(&bss->hidden_list) &&
+                    !bss->pub.hidden_beacon_bss)
+                        continue;
+
+                if (oldest && time_before(oldest->ts, bss->ts))
+                        continue;
+                oldest = bss;
+        }
+
+        if (WARN_ON(!oldest))
+                return false;
+
+        /*
+         * The callers make sure to increase rdev->bss_generation if anything
+         * gets removed (and a new entry added), so there's no need to also do
+         * it here.
+         */
+
+        ret = __cfg80211_unlink_bss(rdev, oldest);
+        WARN_ON(!ret);
+        return ret;
+}
+
 void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
                            bool send_message)
 {
@@ -689,6 +740,7 @@ static bool cfg80211_combine_bsses(struct cfg80211_registered_device *rdev,
         const u8 *ie;
         int i, ssidlen;
         u8 fold = 0;
+        u32 n_entries = 0;
 
         ies = rcu_access_pointer(new->pub.beacon_ies);
         if (WARN_ON(!ies))
@@ -712,6 +764,12 @@ static bool cfg80211_combine_bsses(struct cfg80211_registered_device *rdev,
         /* This is the bad part ... */
 
         list_for_each_entry(bss, &rdev->bss_list, list) {
+                /*
+                 * we're iterating all the entries anyway, so take the
+                 * opportunity to validate the list length accounting
+                 */
+                n_entries++;
+
                 if (!ether_addr_equal(bss->pub.bssid, new->pub.bssid))
                         continue;
                 if (bss->pub.channel != new->pub.channel)
@@ -740,6 +798,10 @@ static bool cfg80211_combine_bsses(struct cfg80211_registered_device *rdev,
                                    new->pub.beacon_ies);
         }
 
+        WARN_ONCE(n_entries != rdev->bss_entries,
+                  "rdev bss entries[%d]/list[len:%d] corruption\n",
+                  rdev->bss_entries, n_entries);
+
         return true;
 }
 
@@ -894,7 +956,14 @@ cfg80211_bss_update(struct cfg80211_registered_device *rdev,
                         }
                 }
 
+                if (rdev->bss_entries >= bss_entries_limit &&
+                    !cfg80211_bss_expire_oldest(rdev)) {
+                        kfree(new);
+                        goto drop;
+                }
+
                 list_add_tail(&new->list, &rdev->bss_list);
+                rdev->bss_entries++;
                 rb_insert_bss(rdev, new);
                 found = new;
         }
diff --git a/net/wireless/util.c b/net/wireless/util.c
index 88725f8eefad..e9d040d29846 100644
--- a/net/wireless/util.c
+++ b/net/wireless/util.c
@@ -1159,7 +1159,8 @@ static u32 cfg80211_calculate_bitrate_vht(struct rate_info *rate)
                    58500000,
                    65000000,
                    78000000,
-                   0,
+                /* not in the spec, but some devices use this: */
+                   86500000,
                 },
                 {  13500000,
                    27000000,