1 files changed, 120 insertions, 32 deletions

diff --git a/net/core/dev.c b/net/core/dev.c
index 722d50dbf8a4..1b5a4410be0e 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -145,6 +145,7 @@
 #include <linux/sctp.h>
 #include <net/udp_tunnel.h>
 #include <linux/net_namespace.h>
+#include <linux/indirect_call_wrapper.h>
 
 #include "net-sysfs.h"
 
@@ -162,6 +163,9 @@ static struct list_head offload_base __read_mostly;
 static int netif_rx_internal(struct sk_buff *skb);
 static int call_netdevice_notifiers_info(unsigned long val,
                                          struct netdev_notifier_info *info);
+static int call_netdevice_notifiers_extack(unsigned long val,
+                                           struct net_device *dev,
+                                           struct netlink_ext_ack *extack);
 static struct napi_struct *napi_by_id(unsigned int napi_id);
 
 /*
@@ -1361,7 +1365,7 @@ void netdev_notify_peers(struct net_device *dev)
 }
 EXPORT_SYMBOL(netdev_notify_peers);
 
-static int __dev_open(struct net_device *dev)
+static int __dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
 {
         const struct net_device_ops *ops = dev->netdev_ops;
         int ret;
@@ -1377,7 +1381,7 @@ static int __dev_open(struct net_device *dev)
          */
         netpoll_poll_disable(dev);
 
-        ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
+        ret = call_netdevice_notifiers_extack(NETDEV_PRE_UP, dev, extack);
         ret = notifier_to_errno(ret);
         if (ret)
                 return ret;
@@ -1406,7 +1410,8 @@ static int __dev_open(struct net_device *dev)
 
 /**
  *      dev_open        - prepare an interface for use.
- *      @dev:   device to open
+ *      @dev: device to open
+ *      @extack: netlink extended ack
  *
  *      Takes a device from down to up state. The device's private open
  *      function is invoked and then the multicast lists are loaded. Finally
@@ -1416,14 +1421,14 @@ static int __dev_open(struct net_device *dev)
  *      Calling this function on an active interface is a nop. On a failure
  *      a negative errno code is returned.
  */
-int dev_open(struct net_device *dev)
+int dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
 {
         int ret;
 
         if (dev->flags & IFF_UP)
                 return 0;
 
-        ret = __dev_open(dev);
+        ret = __dev_open(dev, extack);
         if (ret < 0)
                 return ret;
 
@@ -1585,6 +1590,7 @@ const char *netdev_cmd_to_name(enum netdev_cmd cmd)
         N(UDP_TUNNEL_DROP_INFO) N(CHANGE_TX_QUEUE_LEN)
         N(CVLAN_FILTER_PUSH_INFO) N(CVLAN_FILTER_DROP_INFO)
         N(SVLAN_FILTER_PUSH_INFO) N(SVLAN_FILTER_DROP_INFO)
+        N(PRE_CHANGEADDR)
         }
 #undef N
         return "UNKNOWN_NETDEV_EVENT";
@@ -1733,6 +1739,18 @@ static int call_netdevice_notifiers_info(unsigned long val,
         return raw_notifier_call_chain(&netdev_chain, val, info);
 }
 
+static int call_netdevice_notifiers_extack(unsigned long val,
+                                           struct net_device *dev,
+                                           struct netlink_ext_ack *extack)
+{
+        struct netdev_notifier_info info = {
+                .dev = dev,
+                .extack = extack,
+        };
+
+        return call_netdevice_notifiers_info(val, &info);
+}
+
 /**
  *      call_netdevice_notifiers - call all network notifier blocks
  *      @val: value passed unmodified to notifier function
@@ -1744,11 +1762,7 @@ static int call_netdevice_notifiers_info(unsigned long val,
 
 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
 {
-        struct netdev_notifier_info info = {
-                .dev = dev,
-        };
-
-        return call_netdevice_notifiers_info(val, &info);
+        return call_netdevice_notifiers_extack(val, dev, NULL);
 }
 EXPORT_SYMBOL(call_netdevice_notifiers);
 
@@ -3096,10 +3110,17 @@ EXPORT_SYMBOL(__skb_gso_segment);
 
 /* Take action when hardware reception checksum errors are detected. */
 #ifdef CONFIG_BUG
-void netdev_rx_csum_fault(struct net_device *dev)
+void netdev_rx_csum_fault(struct net_device *dev, struct sk_buff *skb)
 {
         if (net_ratelimit()) {
                 pr_err("%s: hw csum failure\n", dev ? dev->name : "<unknown>");
+                if (dev)
+                        pr_err("dev features: %pNF\n", &dev->features);
+                pr_err("skb len=%u data_len=%u pkt_type=%u gso_size=%u gso_type=%u nr_frags=%u ip_summed=%u csum=%x csum_complete_sw=%d csum_valid=%d csum_level=%u\n",
+                       skb->len, skb->data_len, skb->pkt_type,
+                       skb_shinfo(skb)->gso_size, skb_shinfo(skb)->gso_type,
+                       skb_shinfo(skb)->nr_frags, skb->ip_summed, skb->csum,
+                       skb->csum_complete_sw, skb->csum_valid, skb->csum_level);
                 dump_stack();
         }
 }
@@ -4525,9 +4546,14 @@ static int netif_rx_internal(struct sk_buff *skb)
 
 int netif_rx(struct sk_buff *skb)
 {
+        int ret;
+
         trace_netif_rx_entry(skb);
 
-        return netif_rx_internal(skb);
+        ret = netif_rx_internal(skb);
+        trace_netif_rx_exit(ret);
+
+        return ret;
 }
 EXPORT_SYMBOL(netif_rx);
 
@@ -4542,6 +4568,7 @@ int netif_rx_ni(struct sk_buff *skb)
         if (local_softirq_pending())
                 do_softirq();
         preempt_enable();
+        trace_netif_rx_ni_exit(err);
 
         return err;
 }
@@ -4894,7 +4921,7 @@ skip_classify:
                  * and set skb->priority like in vlan_do_receive()
                  * For the time being, just ignore Priority Code Point
                  */
-                skb->vlan_tci = 0;
+                __vlan_hwaccel_clear_tag(skb);
         }
 
         type = skb->protocol;
@@ -5227,9 +5254,14 @@ static void netif_receive_skb_list_internal(struct list_head *head)
  */
 int netif_receive_skb(struct sk_buff *skb)
 {
+        int ret;
+
         trace_netif_receive_skb_entry(skb);
 
-        return netif_receive_skb_internal(skb);
+        ret = netif_receive_skb_internal(skb);
+        trace_netif_receive_skb_exit(ret);
+
+        return ret;
 }
 EXPORT_SYMBOL(netif_receive_skb);
 
@@ -5249,9 +5281,12 @@ void netif_receive_skb_list(struct list_head *head)
 
         if (list_empty(head))
                 return;
-        list_for_each_entry(skb, head, list)
-                trace_netif_receive_skb_list_entry(skb);
+        if (trace_netif_receive_skb_list_entry_enabled()) {
+                list_for_each_entry(skb, head, list)
+                        trace_netif_receive_skb_list_entry(skb);
+        }
         netif_receive_skb_list_internal(head);
+        trace_netif_receive_skb_list_exit(0);
 }
 EXPORT_SYMBOL(netif_receive_skb_list);
 
@@ -5304,6 +5339,8 @@ static void flush_all_backlogs(void)
         put_online_cpus();
 }
 
+INDIRECT_CALLABLE_DECLARE(int inet_gro_complete(struct sk_buff *, int));
+INDIRECT_CALLABLE_DECLARE(int ipv6_gro_complete(struct sk_buff *, int));
 static int napi_gro_complete(struct sk_buff *skb)
 {
         struct packet_offload *ptype;
@@ -5323,7 +5360,9 @@ static int napi_gro_complete(struct sk_buff *skb)
                 if (ptype->type != type || !ptype->callbacks.gro_complete)
                         continue;
 
-                err = ptype->callbacks.gro_complete(skb, 0);
+                err = INDIRECT_CALL_INET(ptype->callbacks.gro_complete,
+                                         ipv6_gro_complete, inet_gro_complete,
+                                         skb, 0);
                 break;
         }
         rcu_read_unlock();
@@ -5362,11 +5401,13 @@ static void __napi_gro_flush_chain(struct napi_struct *napi, u32 index,
  */
 void napi_gro_flush(struct napi_struct *napi, bool flush_old)
 {
-        u32 i;
+        unsigned long bitmask = napi->gro_bitmask;
+        unsigned int i, base = ~0U;
 
-        for (i = 0; i < GRO_HASH_BUCKETS; i++) {
-                if (test_bit(i, &napi->gro_bitmask))
-                        __napi_gro_flush_chain(napi, i, flush_old);
+        while ((i = ffs(bitmask)) != 0) {
+                bitmask >>= i;
+                base += i;
+                __napi_gro_flush_chain(napi, base, flush_old);
         }
 }
 EXPORT_SYMBOL(napi_gro_flush);
@@ -5391,7 +5432,9 @@ static struct list_head *gro_list_prepare(struct napi_struct *napi,
                 }
 
                 diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev;
-                diffs |= p->vlan_tci ^ skb->vlan_tci;
+                diffs |= skb_vlan_tag_present(p) ^ skb_vlan_tag_present(skb);
+                if (skb_vlan_tag_present(p))
+                        diffs |= p->vlan_tci ^ skb->vlan_tci;
                 diffs |= skb_metadata_dst_cmp(p, skb);
                 diffs |= skb_metadata_differs(p, skb);
                 if (maclen == ETH_HLEN)
@@ -5466,6 +5509,10 @@ static void gro_flush_oldest(struct list_head *head)
         napi_gro_complete(oldest);
 }
 
+INDIRECT_CALLABLE_DECLARE(struct sk_buff *inet_gro_receive(struct list_head *,
+                                                           struct sk_buff *));
+INDIRECT_CALLABLE_DECLARE(struct sk_buff *ipv6_gro_receive(struct list_head *,
+                                                           struct sk_buff *));
 static enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
 {
         u32 hash = skb_get_hash_raw(skb) & (GRO_HASH_BUCKETS - 1);
@@ -5515,7 +5562,9 @@ static enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff
                         NAPI_GRO_CB(skb)->csum_valid = 0;
                 }
 
-                pp = ptype->callbacks.gro_receive(gro_head, skb);
+                pp = INDIRECT_CALL_INET(ptype->callbacks.gro_receive,
+                                        ipv6_gro_receive, inet_gro_receive,
+                                        gro_head, skb);
                 break;
         }
         rcu_read_unlock();
@@ -5639,12 +5688,17 @@ static gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
 
 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
 {
+        gro_result_t ret;
+
         skb_mark_napi_id(skb, napi);
         trace_napi_gro_receive_entry(skb);
 
         skb_gro_reset_offset(skb);
 
-        return napi_skb_finish(dev_gro_receive(napi, skb), skb);
+        ret = napi_skb_finish(dev_gro_receive(napi, skb), skb);
+        trace_napi_gro_receive_exit(ret);
+
+        return ret;
 }
 EXPORT_SYMBOL(napi_gro_receive);
 
@@ -5657,7 +5711,7 @@ static void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
         __skb_pull(skb, skb_headlen(skb));
         /* restore the reserve we had after netdev_alloc_skb_ip_align() */
         skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN - skb_headroom(skb));
-        skb->vlan_tci = 0;
+        __vlan_hwaccel_clear_tag(skb);
         skb->dev = napi->dev;
         skb->skb_iif = 0;
 
@@ -5762,6 +5816,7 @@ static struct sk_buff *napi_frags_skb(struct napi_struct *napi)
 
 gro_result_t napi_gro_frags(struct napi_struct *napi)
 {
+        gro_result_t ret;
         struct sk_buff *skb = napi_frags_skb(napi);
 
         if (!skb)
@@ -5769,7 +5824,10 @@ gro_result_t napi_gro_frags(struct napi_struct *napi)
 
         trace_napi_gro_frags_entry(skb);
 
-        return napi_frags_finish(napi, skb, dev_gro_receive(napi, skb));
+        ret = napi_frags_finish(napi, skb, dev_gro_receive(napi, skb));
+        trace_napi_gro_frags_exit(ret);
+
+        return ret;
 }
 EXPORT_SYMBOL(napi_gro_frags);
 
@@ -5785,10 +5843,11 @@ __sum16 __skb_gro_checksum_complete(struct sk_buff *skb)
 
         /* NAPI_GRO_CB(skb)->csum holds pseudo checksum */
         sum = csum_fold(csum_add(NAPI_GRO_CB(skb)->csum, wsum));
+        /* See comments in __skb_checksum_complete(). */
         if (likely(!sum)) {
                 if (unlikely(skb->ip_summed == CHECKSUM_COMPLETE) &&
                     !skb->csum_complete_sw)
-                        netdev_rx_csum_fault(skb->dev);
+                        netdev_rx_csum_fault(skb->dev, skb);
         }
 
         NAPI_GRO_CB(skb)->csum = wsum;
@@ -7467,7 +7526,8 @@ unsigned int dev_get_flags(const struct net_device *dev)
 }
 EXPORT_SYMBOL(dev_get_flags);
 
-int __dev_change_flags(struct net_device *dev, unsigned int flags)
+int __dev_change_flags(struct net_device *dev, unsigned int flags,
+                       struct netlink_ext_ack *extack)
 {
         unsigned int old_flags = dev->flags;
         int ret;
@@ -7504,7 +7564,7 @@ int __dev_change_flags(struct net_device *dev, unsigned int flags)
                 if (old_flags & IFF_UP)
                         __dev_close(dev);
                 else
-                        ret = __dev_open(dev);
+                        ret = __dev_open(dev, extack);
         }
 
         if ((flags ^ dev->gflags) & IFF_PROMISC) {
@@ -7564,16 +7624,18 @@ void __dev_notify_flags(struct net_device *dev, unsigned int old_flags,
  *      dev_change_flags - change device settings
  *      @dev: device
  *      @flags: device state flags
+ *      @extack: netlink extended ack
  *
  *      Change settings on device based state flags. The flags are
  *      in the userspace exported format.
  */
-int dev_change_flags(struct net_device *dev, unsigned int flags)
+int dev_change_flags(struct net_device *dev, unsigned int flags,
+                     struct netlink_ext_ack *extack)
 {
         int ret;
         unsigned int changes, old_flags = dev->flags, old_gflags = dev->gflags;
 
-        ret = __dev_change_flags(dev, flags);
+        ret = __dev_change_flags(dev, flags, extack);
         if (ret < 0)
                 return ret;
 
@@ -7706,13 +7768,36 @@ void dev_set_group(struct net_device *dev, int new_group)
 EXPORT_SYMBOL(dev_set_group);
 
 /**
+ *      dev_pre_changeaddr_notify - Call NETDEV_PRE_CHANGEADDR.
+ *      @dev: device
+ *      @addr: new address
+ *      @extack: netlink extended ack
+ */
+int dev_pre_changeaddr_notify(struct net_device *dev, const char *addr,
+                              struct netlink_ext_ack *extack)
+{
+        struct netdev_notifier_pre_changeaddr_info info = {
+                .info.dev = dev,
+                .info.extack = extack,
+                .dev_addr = addr,
+        };
+        int rc;
+
+        rc = call_netdevice_notifiers_info(NETDEV_PRE_CHANGEADDR, &info.info);
+        return notifier_to_errno(rc);
+}
+EXPORT_SYMBOL(dev_pre_changeaddr_notify);
+
+/**
  *      dev_set_mac_address - Change Media Access Control Address
  *      @dev: device
  *      @sa: new address
+ *      @extack: netlink extended ack
  *
  *      Change the hardware (MAC) address of the device
  */
-int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
+int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
+                        struct netlink_ext_ack *extack)
 {
         const struct net_device_ops *ops = dev->netdev_ops;
         int err;
@@ -7723,6 +7808,9 @@ int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
                 return -EINVAL;
         if (!netif_device_present(dev))
                 return -ENODEV;
+        err = dev_pre_changeaddr_notify(dev, sa->sa_data, extack);
+        if (err)
+                return err;
         err = ops->ndo_set_mac_address(dev, sa);
         if (err)
                 return err;