24 files changed, 272 insertions, 154 deletions

diff --git a/net/batman-adv/fragmentation.c b/net/batman-adv/fragmentation.c
index fc1835c6bb40..00f9e144cc97 100644
--- a/net/batman-adv/fragmentation.c
+++ b/net/batman-adv/fragmentation.c
@@ -251,7 +251,7 @@ batadv_frag_merge_packets(struct hlist_head *chain, struct sk_buff *skb)
         kfree(entry);
 
         /* Make room for the rest of the fragments. */
-        if (pskb_expand_head(skb_out, 0, size - skb->len, GFP_ATOMIC) < 0) {
+        if (pskb_expand_head(skb_out, 0, size - skb_out->len, GFP_ATOMIC) < 0) {
                 kfree_skb(skb_out);
                 skb_out = NULL;
                 goto free;
@@ -434,7 +434,7 @@ bool batadv_frag_send_packet(struct sk_buff *skb,
          * fragments larger than BATADV_FRAG_MAX_FRAG_SIZE
          */
         mtu = min_t(unsigned, mtu, BATADV_FRAG_MAX_FRAG_SIZE);
-        max_fragment_size = (mtu - header_size - ETH_HLEN);
+        max_fragment_size = mtu - header_size;
         max_packet_size = max_fragment_size * BATADV_FRAG_MAX_FRAGMENTS;
 
         /* Don't even try to fragment, if we need more than 16 fragments */
diff --git a/net/batman-adv/gateway_client.c b/net/batman-adv/gateway_client.c
index 90cff585b37d..e0bcf9e84273 100644
--- a/net/batman-adv/gateway_client.c
+++ b/net/batman-adv/gateway_client.c
@@ -810,7 +810,7 @@ bool batadv_gw_out_of_range(struct batadv_priv *bat_priv,
                 goto out;
 
         gw_node = batadv_gw_node_get(bat_priv, orig_dst_node);
-        if (!gw_node->bandwidth_down == 0)
+        if (!gw_node)
                 goto out;
 
         switch (atomic_read(&bat_priv->gw_mode)) {
diff --git a/net/bluetooth/6lowpan.c b/net/bluetooth/6lowpan.c
index 76617be1e797..c989253737f0 100644
--- a/net/bluetooth/6lowpan.c
+++ b/net/bluetooth/6lowpan.c
@@ -390,7 +390,6 @@ static int recv_pkt(struct sk_buff *skb, struct net_device *dev,
 
 drop:
         dev->stats.rx_dropped++;
-        kfree_skb(skb);
         return NET_RX_DROP;
 }
 
diff --git a/net/bluetooth/bnep/core.c b/net/bluetooth/bnep/core.c
index 85bcc21e84d2..ce82722d049b 100644
--- a/net/bluetooth/bnep/core.c
+++ b/net/bluetooth/bnep/core.c
@@ -533,6 +533,9 @@ int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
 
         BT_DBG("");
 
+        if (!l2cap_is_socket(sock))
+                return -EBADFD;
+
         baswap((void *) dst, &l2cap_pi(sock->sk)->chan->dst);
         baswap((void *) src, &l2cap_pi(sock->sk)->chan->src);
 
diff --git a/net/bluetooth/cmtp/core.c b/net/bluetooth/cmtp/core.c
index 67fe5e84e68f..278a194e6af4 100644
--- a/net/bluetooth/cmtp/core.c
+++ b/net/bluetooth/cmtp/core.c
@@ -334,6 +334,9 @@ int cmtp_add_connection(struct cmtp_connadd_req *req, struct socket *sock)
 
         BT_DBG("");
 
+        if (!l2cap_is_socket(sock))
+                return -EBADFD;
+
         session = kzalloc(sizeof(struct cmtp_session), GFP_KERNEL);
         if (!session)
                 return -ENOMEM;
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 39a5c8a01726..3f2e8b830cbd 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -242,7 +242,8 @@ static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
         if (rp->status)
                 return;
 
-        if (test_bit(HCI_SETUP, &hdev->dev_flags))
+        if (test_bit(HCI_SETUP, &hdev->dev_flags) ||
+            test_bit(HCI_CONFIG, &hdev->dev_flags))
                 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
 }
 
@@ -509,7 +510,8 @@ static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
         if (rp->status)
                 return;
 
-        if (test_bit(HCI_SETUP, &hdev->dev_flags)) {
+        if (test_bit(HCI_SETUP, &hdev->dev_flags) ||
+            test_bit(HCI_CONFIG, &hdev->dev_flags)) {
                 hdev->hci_ver = rp->hci_ver;
                 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
                 hdev->lmp_ver = rp->lmp_ver;
@@ -528,7 +530,8 @@ static void hci_cc_read_local_commands(struct hci_dev *hdev,
         if (rp->status)
                 return;
 
-        if (test_bit(HCI_SETUP, &hdev->dev_flags))
+        if (test_bit(HCI_SETUP, &hdev->dev_flags) ||
+            test_bit(HCI_CONFIG, &hdev->dev_flags))
                 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
 }
 
@@ -2194,7 +2197,12 @@ static void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
                 return;
         }
 
-        if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags) &&
+        /* Require HCI_CONNECTABLE or a whitelist entry to accept the
+         * connection. These features are only touched through mgmt so
+         * only do the checks if HCI_MGMT is set.
+         */
+        if (test_bit(HCI_MGMT, &hdev->dev_flags) &&
+            !test_bit(HCI_CONNECTABLE, &hdev->dev_flags) &&
             !hci_bdaddr_list_lookup(&hdev->whitelist, &ev->bdaddr,
                                     BDADDR_BREDR)) {
                     hci_reject_conn(hdev, &ev->bdaddr);
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index cc25d0b74b36..07348e142f16 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -1314,13 +1314,14 @@ int hidp_connection_add(struct hidp_connadd_req *req,
 {
         struct hidp_session *session;
         struct l2cap_conn *conn;
-        struct l2cap_chan *chan = l2cap_pi(ctrl_sock->sk)->chan;
+        struct l2cap_chan *chan;
         int ret;
 
         ret = hidp_verify_sockets(ctrl_sock, intr_sock);
         if (ret)
                 return ret;
 
+        chan = l2cap_pi(ctrl_sock->sk)->chan;
         conn = NULL;
         l2cap_chan_lock(chan);
         if (chan->conn)
diff --git a/net/core/dev.c b/net/core/dev.c
index f411c28d0a66..683d493aa1bf 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1694,6 +1694,7 @@ int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
 
         skb_scrub_packet(skb, true);
         skb->protocol = eth_type_trans(skb, dev);
+        skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
 
         return 0;
 }
@@ -2522,7 +2523,7 @@ static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
 /* If MPLS offload request, verify we are testing hardware MPLS features
  * instead of standard features for the netdev.
  */
-#ifdef CONFIG_NET_MPLS_GSO
+#if IS_ENABLED(CONFIG_NET_MPLS_GSO)
 static netdev_features_t net_mpls_features(struct sk_buff *skb,
                                            netdev_features_t features,
                                            __be16 type)
@@ -2562,7 +2563,7 @@ static netdev_features_t harmonize_features(struct sk_buff *skb,
 
 netdev_features_t netif_skb_features(struct sk_buff *skb)
 {
-        const struct net_device *dev = skb->dev;
+        struct net_device *dev = skb->dev;
         netdev_features_t features = dev->features;
         u16 gso_segs = skb_shinfo(skb)->gso_segs;
         __be16 protocol = skb->protocol;
@@ -2570,11 +2571,21 @@ netdev_features_t netif_skb_features(struct sk_buff *skb)
         if (gso_segs > dev->gso_max_segs || gso_segs < dev->gso_min_segs)
                 features &= ~NETIF_F_GSO_MASK;
 
-        if (protocol == htons(ETH_P_8021Q) || protocol == htons(ETH_P_8021AD)) {
-                struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
-                protocol = veh->h_vlan_encapsulated_proto;
-        } else if (!vlan_tx_tag_present(skb)) {
-                return harmonize_features(skb, features);
+        /* If encapsulation offload request, verify we are testing
+         * hardware encapsulation features instead of standard
+         * features for the netdev
+         */
+        if (skb->encapsulation)
+                features &= dev->hw_enc_features;
+
+        if (!vlan_tx_tag_present(skb)) {
+                if (unlikely(protocol == htons(ETH_P_8021Q) ||
+                             protocol == htons(ETH_P_8021AD))) {
+                        struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
+                        protocol = veh->h_vlan_encapsulated_proto;
+                } else {
+                        goto finalize;
+                }
         }
 
         features = netdev_intersect_features(features,
@@ -2591,6 +2602,11 @@ netdev_features_t netif_skb_features(struct sk_buff *skb)
                                                      NETIF_F_HW_VLAN_CTAG_TX |
                                                      NETIF_F_HW_VLAN_STAG_TX);
 
+finalize:
+        if (dev->netdev_ops->ndo_features_check)
+                features &= dev->netdev_ops->ndo_features_check(skb, dev,
+                                                                features);
+
         return harmonize_features(skb, features);
 }
 EXPORT_SYMBOL(netif_skb_features);
@@ -2661,19 +2677,12 @@ static struct sk_buff *validate_xmit_skb(struct sk_buff *skb, struct net_device
         if (unlikely(!skb))
                 goto out_null;
 
-        /* If encapsulation offload request, verify we are testing
-         * hardware encapsulation features instead of standard
-         * features for the netdev
-         */
-        if (skb->encapsulation)
-                features &= dev->hw_enc_features;
-
         if (netif_needs_gso(dev, skb, features)) {
                 struct sk_buff *segs;
 
                 segs = skb_gso_segment(skb, features);
                 if (IS_ERR(segs)) {
-                        segs = NULL;
+                        goto out_kfree_skb;
                 } else if (segs) {
                         consume_skb(skb);
                         skb = segs;
@@ -4557,6 +4566,68 @@ void netif_napi_del(struct napi_struct *napi)
 }
 EXPORT_SYMBOL(netif_napi_del);
 
+static int napi_poll(struct napi_struct *n, struct list_head *repoll)
+{
+        void *have;
+        int work, weight;
+
+        list_del_init(&n->poll_list);
+
+        have = netpoll_poll_lock(n);
+
+        weight = n->weight;
+
+        /* This NAPI_STATE_SCHED test is for avoiding a race
+         * with netpoll's poll_napi().  Only the entity which
+         * obtains the lock and sees NAPI_STATE_SCHED set will
+         * actually make the ->poll() call.  Therefore we avoid
+         * accidentally calling ->poll() when NAPI is not scheduled.
+         */
+        work = 0;
+        if (test_bit(NAPI_STATE_SCHED, &n->state)) {
+                work = n->poll(n, weight);
+                trace_napi_poll(n);
+        }
+
+        WARN_ON_ONCE(work > weight);
+
+        if (likely(work < weight))
+                goto out_unlock;
+
+        /* Drivers must not modify the NAPI state if they
+         * consume the entire weight.  In such cases this code
+         * still "owns" the NAPI instance and therefore can
+         * move the instance around on the list at-will.
+         */
+        if (unlikely(napi_disable_pending(n))) {
+                napi_complete(n);
+                goto out_unlock;
+        }
+
+        if (n->gro_list) {
+                /* flush too old packets
+                 * If HZ < 1000, flush all packets.
+                 */
+                napi_gro_flush(n, HZ >= 1000);
+        }
+
+        /* Some drivers may have called napi_schedule
+         * prior to exhausting their budget.
+         */
+        if (unlikely(!list_empty(&n->poll_list))) {
+                pr_warn_once("%s: Budget exhausted after napi rescheduled\n",
+                             n->dev ? n->dev->name : "backlog");
+                goto out_unlock;
+        }
+
+        list_add_tail(&n->poll_list, repoll);
+
+out_unlock:
+        netpoll_poll_unlock(have);
+
+        return work;
+}
+
 static void net_rx_action(struct softirq_action *h)
 {
         struct softnet_data *sd = this_cpu_ptr(&softnet_data);
@@ -4564,74 +4635,34 @@ static void net_rx_action(struct softirq_action *h)
         int budget = netdev_budget;
         LIST_HEAD(list);
         LIST_HEAD(repoll);
-        void *have;
 
         local_irq_disable();
         list_splice_init(&sd->poll_list, &list);
         local_irq_enable();
 
-        while (!list_empty(&list)) {
+        for (;;) {
                 struct napi_struct *n;
-                int work, weight;
-
-                /* If softirq window is exhausted then punt.
-                 * Allow this to run for 2 jiffies since which will allow
-                 * an average latency of 1.5/HZ.
-                 */
-                if (unlikely(budget <= 0 || time_after_eq(jiffies, time_limit)))
-                        goto softnet_break;
-
-
-                n = list_first_entry(&list, struct napi_struct, poll_list);
-                list_del_init(&n->poll_list);
 
-                have = netpoll_poll_lock(n);
-
-                weight = n->weight;
-
-                /* This NAPI_STATE_SCHED test is for avoiding a race
-                 * with netpoll's poll_napi().  Only the entity which
-                 * obtains the lock and sees NAPI_STATE_SCHED set will
-                 * actually make the ->poll() call.  Therefore we avoid
-                 * accidentally calling ->poll() when NAPI is not scheduled.
-                 */
-                work = 0;
-                if (test_bit(NAPI_STATE_SCHED, &n->state)) {
-                        work = n->poll(n, weight);
-                        trace_napi_poll(n);
+                if (list_empty(&list)) {
+                        if (!sd_has_rps_ipi_waiting(sd) && list_empty(&repoll))
+                                return;
+                        break;
                 }
 
-                WARN_ON_ONCE(work > weight);
-
-                budget -= work;
+                n = list_first_entry(&list, struct napi_struct, poll_list);
+                budget -= napi_poll(n, &repoll);
 
-                /* Drivers must not modify the NAPI state if they
-                 * consume the entire weight.  In such cases this code
-                 * still "owns" the NAPI instance and therefore can
-                 * move the instance around on the list at-will.
+                /* If softirq window is exhausted then punt.
+                 * Allow this to run for 2 jiffies since which will allow
+                 * an average latency of 1.5/HZ.
                  */
-                if (unlikely(work == weight)) {
-                        if (unlikely(napi_disable_pending(n))) {
-                                napi_complete(n);
-                        } else {
-                                if (n->gro_list) {
-                                        /* flush too old packets
-                                         * If HZ < 1000, flush all packets.
-                                         */
-                                        napi_gro_flush(n, HZ >= 1000);
-                                }
-                                list_add_tail(&n->poll_list, &repoll);
-                        }
+                if (unlikely(budget <= 0 ||
+                             time_after_eq(jiffies, time_limit))) {
+                        sd->time_squeeze++;
+                        break;
                 }
-
-                netpoll_poll_unlock(have);
         }
 
-        if (!sd_has_rps_ipi_waiting(sd) &&
-            list_empty(&list) &&
-            list_empty(&repoll))
-                return;
-out:
         local_irq_disable();
 
         list_splice_tail_init(&sd->poll_list, &list);
@@ -4641,12 +4672,6 @@ out:
                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
 
         net_rps_action_and_irq_enable(sd);
-
-        return;
-
-softnet_break:
-        sd->time_squeeze++;
-        goto out;
 }
 
 struct netdev_adjacent {
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index ae13ef6b3ea7..395c15b82087 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -4148,6 +4148,7 @@ void skb_scrub_packet(struct sk_buff *skb, bool xnet)
         skb->ignore_df = 0;
         skb_dst_drop(skb);
         skb->mark = 0;
+        skb_init_secmark(skb);
         secpath_reset(skb);
         nf_reset(skb);
         nf_reset_trace(skb);
diff --git a/net/ipv4/geneve.c b/net/ipv4/geneve.c
index 95e47c97585e..394a200f93c1 100644
--- a/net/ipv4/geneve.c
+++ b/net/ipv4/geneve.c
@@ -122,14 +122,18 @@ int geneve_xmit_skb(struct geneve_sock *gs, struct rtable *rt,
         int err;
 
         skb = udp_tunnel_handle_offloads(skb, !gs->sock->sk->sk_no_check_tx);
+        if (IS_ERR(skb))
+                return PTR_ERR(skb);
 
         min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
                         + GENEVE_BASE_HLEN + opt_len + sizeof(struct iphdr)
                         + (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
 
         err = skb_cow_head(skb, min_headroom);
-        if (unlikely(err))
+        if (unlikely(err)) {
+                kfree_skb(skb);
                 return err;
+        }
 
         skb = vlan_hwaccel_push_inside(skb);
         if (unlikely(!skb))
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 5ff87805258e..9c0b54e87b47 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1387,6 +1387,28 @@ ipv6_pktoptions:
         return 0;
 }
 
+static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr,
+                           const struct tcphdr *th)
+{
+        /* This is tricky: we move IP6CB at its correct location into
+         * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because
+         * _decode_session6() uses IP6CB().
+         * barrier() makes sure compiler won't play aliasing games.
+         */
+        memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
+                sizeof(struct inet6_skb_parm));
+        barrier();
+
+        TCP_SKB_CB(skb)->seq = ntohl(th->seq);
+        TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
+                                    skb->len - th->doff*4);
+        TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
+        TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
+        TCP_SKB_CB(skb)->tcp_tw_isn = 0;
+        TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
+        TCP_SKB_CB(skb)->sacked = 0;
+}
+
 static int tcp_v6_rcv(struct sk_buff *skb)
 {
         const struct tcphdr *th;
@@ -1418,24 +1440,9 @@ static int tcp_v6_rcv(struct sk_buff *skb)
 
         th = tcp_hdr(skb);
         hdr = ipv6_hdr(skb);
-        /* This is tricky : We move IPCB at its correct location into TCP_SKB_CB()
-         * barrier() makes sure compiler wont play fool^Waliasing games.
-         */
-        memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
-                sizeof(struct inet6_skb_parm));
-        barrier();
-
-        TCP_SKB_CB(skb)->seq = ntohl(th->seq);
-        TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
-                                    skb->len - th->doff*4);
-        TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
-        TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
-        TCP_SKB_CB(skb)->tcp_tw_isn = 0;
-        TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
-        TCP_SKB_CB(skb)->sacked = 0;
 
         sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest,
-                                tcp_v6_iif(skb));
+                                inet6_iif(skb));
         if (!sk)
                 goto no_tcp_socket;
 
@@ -1451,6 +1458,8 @@ process:
         if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
                 goto discard_and_relse;
 
+        tcp_v6_fill_cb(skb, hdr, th);
+
 #ifdef CONFIG_TCP_MD5SIG
         if (tcp_v6_inbound_md5_hash(sk, skb))
                 goto discard_and_relse;
@@ -1482,6 +1491,8 @@ no_tcp_socket:
         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
                 goto discard_it;
 
+        tcp_v6_fill_cb(skb, hdr, th);
+
         if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
 csum_error:
                 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
@@ -1505,6 +1516,8 @@ do_time_wait:
                 goto discard_it;
         }
 
+        tcp_v6_fill_cb(skb, hdr, th);
+
         if (skb->len < (th->doff<<2)) {
                 inet_twsk_put(inet_twsk(sk));
                 goto bad_packet;
diff --git a/net/mpls/mpls_gso.c b/net/mpls/mpls_gso.c
index ca27837974fe..349295d21946 100644
--- a/net/mpls/mpls_gso.c
+++ b/net/mpls/mpls_gso.c
@@ -31,10 +31,7 @@ static struct sk_buff *mpls_gso_segment(struct sk_buff *skb,
                                   SKB_GSO_TCPV6 |
                                   SKB_GSO_UDP |
                                   SKB_GSO_DODGY |
-                                  SKB_GSO_TCP_ECN |
-                                  SKB_GSO_GRE |
-                                  SKB_GSO_GRE_CSUM |
-                                  SKB_GSO_IPIP)))
+                                  SKB_GSO_TCP_ECN)))
                 goto out;
 
         /* Setup inner SKB. */
diff --git a/net/netfilter/nfnetlink.c b/net/netfilter/nfnetlink.c
index 13c2e17bbe27..cde4a6702fa3 100644
--- a/net/netfilter/nfnetlink.c
+++ b/net/netfilter/nfnetlink.c
@@ -463,7 +463,7 @@ static void nfnetlink_rcv(struct sk_buff *skb)
 }
 
 #ifdef CONFIG_MODULES
-static int nfnetlink_bind(int group)
+static int nfnetlink_bind(struct net *net, int group)
 {
         const struct nfnetlink_subsystem *ss;
         int type;
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index 074cf3e91c6f..84ea76ca3f1f 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -1091,8 +1091,10 @@ static void netlink_remove(struct sock *sk)
         mutex_unlock(&nl_sk_hash_lock);
 
         netlink_table_grab();
-        if (nlk_sk(sk)->subscriptions)
+        if (nlk_sk(sk)->subscriptions) {
                 __sk_del_bind_node(sk);
+                netlink_update_listeners(sk);
+        }
         netlink_table_ungrab();
 }
 
@@ -1139,8 +1141,8 @@ static int netlink_create(struct net *net, struct socket *sock, int protocol,
         struct module *module = NULL;
         struct mutex *cb_mutex;
         struct netlink_sock *nlk;
-        int (*bind)(int group);
-        void (*unbind)(int group);
+        int (*bind)(struct net *net, int group);
+        void (*unbind)(struct net *net, int group);
         int err = 0;
 
         sock->state = SS_UNCONNECTED;
@@ -1226,8 +1228,8 @@ static int netlink_release(struct socket *sock)
 
         module_put(nlk->module);
 
-        netlink_table_grab();
         if (netlink_is_kernel(sk)) {
+                netlink_table_grab();
                 BUG_ON(nl_table[sk->sk_protocol].registered == 0);
                 if (--nl_table[sk->sk_protocol].registered == 0) {
                         struct listeners *old;
@@ -1241,11 +1243,16 @@ static int netlink_release(struct socket *sock)
                         nl_table[sk->sk_protocol].flags = 0;
                         nl_table[sk->sk_protocol].registered = 0;
                 }
-        } else if (nlk->subscriptions) {
-                netlink_update_listeners(sk);
+                netlink_table_ungrab();
         }
-        netlink_table_ungrab();
 
+        if (nlk->netlink_unbind) {
+                int i;
+
+                for (i = 0; i < nlk->ngroups; i++)
+                        if (test_bit(i, nlk->groups))
+                                nlk->netlink_unbind(sock_net(sk), i + 1);
+        }
         kfree(nlk->groups);
         nlk->groups = NULL;
 
@@ -1410,9 +1417,10 @@ static int netlink_realloc_groups(struct sock *sk)
         return err;
 }
 
-static void netlink_unbind(int group, long unsigned int groups,
-                           struct netlink_sock *nlk)
+static void netlink_undo_bind(int group, long unsigned int groups,
+                              struct sock *sk)
 {
+        struct netlink_sock *nlk = nlk_sk(sk);
         int undo;
 
         if (!nlk->netlink_unbind)
@@ -1420,7 +1428,7 @@ static void netlink_unbind(int group, long unsigned int groups,
 
         for (undo = 0; undo < group; undo++)
                 if (test_bit(undo, &groups))
-                        nlk->netlink_unbind(undo);
+                        nlk->netlink_unbind(sock_net(sk), undo);
 }
 
 static int netlink_bind(struct socket *sock, struct sockaddr *addr,
@@ -1458,10 +1466,10 @@ static int netlink_bind(struct socket *sock, struct sockaddr *addr,
                 for (group = 0; group < nlk->ngroups; group++) {
                         if (!test_bit(group, &groups))
                                 continue;
-                        err = nlk->netlink_bind(group);
+                        err = nlk->netlink_bind(net, group);
                         if (!err)
                                 continue;
-                        netlink_unbind(group, groups, nlk);
+                        netlink_undo_bind(group, groups, sk);
                         return err;
                 }
         }
@@ -1471,7 +1479,7 @@ static int netlink_bind(struct socket *sock, struct sockaddr *addr,
                         netlink_insert(sk, net, nladdr->nl_pid) :
                         netlink_autobind(sock);
                 if (err) {
-                        netlink_unbind(nlk->ngroups, groups, nlk);
+                        netlink_undo_bind(nlk->ngroups, groups, sk);
                         return err;
                 }
         }
@@ -2122,7 +2130,7 @@ static int netlink_setsockopt(struct socket *sock, int level, int optname,
                 if (!val || val - 1 >= nlk->ngroups)
                         return -EINVAL;
                 if (optname == NETLINK_ADD_MEMBERSHIP && nlk->netlink_bind) {
-                        err = nlk->netlink_bind(val);
+                        err = nlk->netlink_bind(sock_net(sk), val);
                         if (err)
                                 return err;
                 }
@@ -2131,7 +2139,7 @@ static int netlink_setsockopt(struct socket *sock, int level, int optname,
                                          optname == NETLINK_ADD_MEMBERSHIP);
                 netlink_table_ungrab();
                 if (optname == NETLINK_DROP_MEMBERSHIP && nlk->netlink_unbind)
-                        nlk->netlink_unbind(val);
+                        nlk->netlink_unbind(sock_net(sk), val);
 
                 err = 0;
                 break;
diff --git a/net/netlink/af_netlink.h b/net/netlink/af_netlink.h
index b20a1731759b..f123a88496f8 100644
--- a/net/netlink/af_netlink.h
+++ b/net/netlink/af_netlink.h
@@ -39,8 +39,8 @@ struct netlink_sock {
         struct mutex            *cb_mutex;
         struct mutex            cb_def_mutex;
         void                    (*netlink_rcv)(struct sk_buff *skb);
-        int                     (*netlink_bind)(int group);
-        void                    (*netlink_unbind)(int group);
+        int                     (*netlink_bind)(struct net *net, int group);
+        void                    (*netlink_unbind)(struct net *net, int group);
         struct module           *module;
 #ifdef CONFIG_NETLINK_MMAP
         struct mutex            pg_vec_lock;
@@ -65,8 +65,8 @@ struct netlink_table {
         unsigned int            groups;
         struct mutex            *cb_mutex;
         struct module           *module;
-        int                     (*bind)(int group);
-        void                    (*unbind)(int group);
+        int                     (*bind)(struct net *net, int group);
+        void                    (*unbind)(struct net *net, int group);
         bool                    (*compare)(struct net *net, struct sock *sock);
         int                     registered;
 };
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index 76393f2f4b22..2e11061ef885 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -983,11 +983,67 @@ static struct genl_multicast_group genl_ctrl_groups[] = {
         { .name = "notify", },
 };
 
+static int genl_bind(struct net *net, int group)
+{
+        int i, err = 0;
+
+        down_read(&cb_lock);
+        for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
+                struct genl_family *f;
+
+                list_for_each_entry(f, genl_family_chain(i), family_list) {
+                        if (group >= f->mcgrp_offset &&
+                            group < f->mcgrp_offset + f->n_mcgrps) {
+                                int fam_grp = group - f->mcgrp_offset;
+
+                                if (!f->netnsok && net != &init_net)
+                                        err = -ENOENT;
+                                else if (f->mcast_bind)
+                                        err = f->mcast_bind(net, fam_grp);
+                                else
+                                        err = 0;
+                                break;
+                        }
+                }
+        }
+        up_read(&cb_lock);
+
+        return err;
+}
+
+static void genl_unbind(struct net *net, int group)
+{
+        int i;
+        bool found = false;
+
+        down_read(&cb_lock);
+        for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
+                struct genl_family *f;
+
+                list_for_each_entry(f, genl_family_chain(i), family_list) {
+                        if (group >= f->mcgrp_offset &&
+                            group < f->mcgrp_offset + f->n_mcgrps) {
+                                int fam_grp = group - f->mcgrp_offset;
+
+                                if (f->mcast_unbind)
+                                        f->mcast_unbind(net, fam_grp);
+                                found = true;
+                                break;
+                        }
+                }
+        }
+        up_read(&cb_lock);
+
+        WARN_ON(!found);
+}
+
 static int __net_init genl_pernet_init(struct net *net)
 {
         struct netlink_kernel_cfg cfg = {
                 .input          = genl_rcv,
                 .flags          = NL_CFG_F_NONROOT_RECV,
+                .bind           = genl_bind,
+                .unbind         = genl_unbind,
         };
 
         /* we'll bump the group number right afterwards */
diff --git a/net/openvswitch/actions.c b/net/openvswitch/actions.c
index 764fdc39c63b..770064c83711 100644
--- a/net/openvswitch/actions.c
+++ b/net/openvswitch/actions.c
@@ -147,7 +147,8 @@ static int push_mpls(struct sk_buff *skb, struct sw_flow_key *key,
         hdr = eth_hdr(skb);
         hdr->h_proto = mpls->mpls_ethertype;
 
-        skb_set_inner_protocol(skb, skb->protocol);
+        if (!skb->inner_protocol)
+                skb_set_inner_protocol(skb, skb->protocol);
         skb->protocol = mpls->mpls_ethertype;
 
         invalidate_flow_key(key);
diff --git a/net/openvswitch/datapath.c b/net/openvswitch/datapath.c
index 332b5a031739..4e9a5f035cbc 100644
--- a/net/openvswitch/datapath.c
+++ b/net/openvswitch/datapath.c
@@ -83,8 +83,7 @@ static bool ovs_must_notify(struct genl_family *family, struct genl_info *info,
                             unsigned int group)
 {
         return info->nlhdr->nlmsg_flags & NLM_F_ECHO ||
-               genl_has_listeners(family, genl_info_net(info)->genl_sock,
-                                  group);
+               genl_has_listeners(family, genl_info_net(info), group);
 }
 
 static void ovs_notify(struct genl_family *family,
diff --git a/net/openvswitch/flow_netlink.c b/net/openvswitch/flow_netlink.c
index 9645a21d9eaa..d1eecf707613 100644
--- a/net/openvswitch/flow_netlink.c
+++ b/net/openvswitch/flow_netlink.c
@@ -1753,7 +1753,6 @@ static int __ovs_nla_copy_actions(const struct nlattr *attr,
                                   __be16 eth_type, __be16 vlan_tci, bool log)
 {
         const struct nlattr *a;
-        bool out_tnl_port = false;
         int rem, err;
 
         if (depth >= SAMPLE_ACTION_DEPTH)
@@ -1796,8 +1795,6 @@ static int __ovs_nla_copy_actions(const struct nlattr *attr,
                 case OVS_ACTION_ATTR_OUTPUT:
                         if (nla_get_u32(a) >= DP_MAX_PORTS)
                                 return -EINVAL;
-                        out_tnl_port = false;
-
                         break;
 
                 case OVS_ACTION_ATTR_HASH: {
@@ -1832,12 +1829,6 @@ static int __ovs_nla_copy_actions(const struct nlattr *attr,
                 case OVS_ACTION_ATTR_PUSH_MPLS: {
                         const struct ovs_action_push_mpls *mpls = nla_data(a);
 
-                        /* Networking stack do not allow simultaneous Tunnel
-                         * and MPLS GSO.
-                         */
-                        if (out_tnl_port)
-                                return -EINVAL;
-
                         if (!eth_p_mpls(mpls->mpls_ethertype))
                                 return -EINVAL;
                         /* Prohibit push MPLS other than to a white list
@@ -1873,11 +1864,9 @@ static int __ovs_nla_copy_actions(const struct nlattr *attr,
 
                 case OVS_ACTION_ATTR_SET:
                         err = validate_set(a, key, sfa,
-                                           &out_tnl_port, eth_type, log);
+                                           &skip_copy, eth_type, log);
                         if (err)
                                 return err;
-
-                        skip_copy = out_tnl_port;
                         break;
 
                 case OVS_ACTION_ATTR_SAMPLE:
diff --git a/net/openvswitch/vport-geneve.c b/net/openvswitch/vport-geneve.c
index 347fa2325b22..484864dd0e68 100644
--- a/net/openvswitch/vport-geneve.c
+++ b/net/openvswitch/vport-geneve.c
@@ -219,7 +219,10 @@ static int geneve_tnl_send(struct vport *vport, struct sk_buff *skb)
                               false);
         if (err < 0)
                 ip_rt_put(rt);
+        return err;
+
 error:
+        kfree_skb(skb);
         return err;
 }
 
diff --git a/net/openvswitch/vport-gre.c b/net/openvswitch/vport-gre.c
index 6b69df545b1d..d4168c442db5 100644
--- a/net/openvswitch/vport-gre.c
+++ b/net/openvswitch/vport-gre.c
@@ -73,7 +73,7 @@ static struct sk_buff *__build_header(struct sk_buff *skb,
 
         skb = gre_handle_offloads(skb, !!(tun_key->tun_flags & TUNNEL_CSUM));
         if (IS_ERR(skb))
-                return NULL;
+                return skb;
 
         tpi.flags = filter_tnl_flags(tun_key->tun_flags);
         tpi.proto = htons(ETH_P_TEB);
@@ -144,7 +144,7 @@ static int gre_tnl_send(struct vport *vport, struct sk_buff *skb)
 
         if (unlikely(!OVS_CB(skb)->egress_tun_info)) {
                 err = -EINVAL;
-                goto error;
+                goto err_free_skb;
         }
 
         tun_key = &OVS_CB(skb)->egress_tun_info->tunnel;
@@ -157,8 +157,10 @@ static int gre_tnl_send(struct vport *vport, struct sk_buff *skb)
         fl.flowi4_proto = IPPROTO_GRE;
 
         rt = ip_route_output_key(net, &fl);
-        if (IS_ERR(rt))
-                return PTR_ERR(rt);
+        if (IS_ERR(rt)) {
+                err = PTR_ERR(rt);
+                goto err_free_skb;
+        }
 
         tunnel_hlen = ip_gre_calc_hlen(tun_key->tun_flags);
 
@@ -183,8 +185,9 @@ static int gre_tnl_send(struct vport *vport, struct sk_buff *skb)
 
         /* Push Tunnel header. */
         skb = __build_header(skb, tunnel_hlen);
-        if (unlikely(!skb)) {
-                err = 0;
+        if (IS_ERR(skb)) {
+                err = PTR_ERR(skb);
+                skb = NULL;
                 goto err_free_rt;
         }
 
@@ -198,7 +201,8 @@ static int gre_tnl_send(struct vport *vport, struct sk_buff *skb)
                              tun_key->ipv4_tos, tun_key->ipv4_ttl, df, false);
 err_free_rt:
         ip_rt_put(rt);
-error:
+err_free_skb:
+        kfree_skb(skb);
         return err;
 }
 
diff --git a/net/openvswitch/vport-vxlan.c b/net/openvswitch/vport-vxlan.c
index 38f95a52241b..d7c46b301024 100644
--- a/net/openvswitch/vport-vxlan.c
+++ b/net/openvswitch/vport-vxlan.c
@@ -187,7 +187,9 @@ static int vxlan_tnl_send(struct vport *vport, struct sk_buff *skb)
                              false);
         if (err < 0)
                 ip_rt_put(rt);
+        return err;
 error:
+        kfree_skb(skb);
         return err;
 }
 
diff --git a/net/openvswitch/vport.c b/net/openvswitch/vport.c
index 9584526c0778..53f3ebbfceab 100644
--- a/net/openvswitch/vport.c
+++ b/net/openvswitch/vport.c
@@ -519,10 +519,9 @@ int ovs_vport_send(struct vport *vport, struct sk_buff *skb)
                 u64_stats_update_end(&stats->syncp);
         } else if (sent < 0) {
                 ovs_vport_record_error(vport, VPORT_E_TX_ERROR);
-                kfree_skb(skb);
-        } else
+        } else {
                 ovs_vport_record_error(vport, VPORT_E_TX_DROPPED);
-
+        }
         return sent;
 }
 
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index e52a44785681..6880f34a529a 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -785,6 +785,7 @@ static void prb_close_block(struct tpacket_kbdq_core *pkc1,
 
         struct tpacket3_hdr *last_pkt;
         struct tpacket_hdr_v1 *h1 = &pbd1->hdr.bh1;
+        struct sock *sk = &po->sk;
 
         if (po->stats.stats3.tp_drops)
                 status |= TP_STATUS_LOSING;
@@ -809,6 +810,8 @@ static void prb_close_block(struct tpacket_kbdq_core *pkc1,
         /* Flush the block */
         prb_flush_block(pkc1, pbd1, status);
 
+        sk->sk_data_ready(sk);
+
         pkc1->kactive_blk_num = GET_NEXT_PRB_BLK_NUM(pkc1);
 }
 
@@ -2052,12 +2055,12 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev,
         smp_wmb();
 #endif
 
-        if (po->tp_version <= TPACKET_V2)
+        if (po->tp_version <= TPACKET_V2) {
                 __packet_set_status(po, h.raw, status);
-        else
+                sk->sk_data_ready(sk);
+        } else {
                 prb_clear_blk_fill_status(&po->rx_ring);
-
-        sk->sk_data_ready(sk);
+        }
 
 drop_n_restore:
         if (skb_head != skb->data && skb_shared(skb)) {