1 files changed, 66 insertions, 72 deletions

diff --git a/net/core/dev.c b/net/core/dev.c
index 6ba50a1e404c..8afb244b205f 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -137,6 +137,7 @@
 #include <linux/if_pppox.h>
 #include <linux/ppp_defs.h>
 #include <linux/net_tstamp.h>
+#include <linux/jump_label.h>
 
 #include "net-sysfs.h"
 
@@ -1320,8 +1321,6 @@ EXPORT_SYMBOL(dev_close);
  */
 void dev_disable_lro(struct net_device *dev)
 {
-        u32 flags;
-
         /*
          * If we're trying to disable lro on a vlan device
          * use the underlying physical device instead
@@ -1329,15 +1328,9 @@ void dev_disable_lro(struct net_device *dev)
         if (is_vlan_dev(dev))
                 dev = vlan_dev_real_dev(dev);
 
-        if (dev->ethtool_ops && dev->ethtool_ops->get_flags)
-                flags = dev->ethtool_ops->get_flags(dev);
-        else
-                flags = ethtool_op_get_flags(dev);
+        dev->wanted_features &= ~NETIF_F_LRO;
+        netdev_update_features(dev);
 
-        if (!(flags & ETH_FLAG_LRO))
-                return;
-
-        __ethtool_set_flags(dev, flags & ~ETH_FLAG_LRO);
         if (unlikely(dev->features & NETIF_F_LRO))
                 netdev_WARN(dev, "failed to disable LRO!\n");
 }
@@ -1449,34 +1442,32 @@ int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
 }
 EXPORT_SYMBOL(call_netdevice_notifiers);
 
-/* When > 0 there are consumers of rx skb time stamps */
-static atomic_t netstamp_needed = ATOMIC_INIT(0);
+static struct jump_label_key netstamp_needed __read_mostly;
 
 void net_enable_timestamp(void)
 {
-        atomic_inc(&netstamp_needed);
+        jump_label_inc(&netstamp_needed);
 }
 EXPORT_SYMBOL(net_enable_timestamp);
 
 void net_disable_timestamp(void)
 {
-        atomic_dec(&netstamp_needed);
+        jump_label_dec(&netstamp_needed);
 }
 EXPORT_SYMBOL(net_disable_timestamp);
 
 static inline void net_timestamp_set(struct sk_buff *skb)
 {
-        if (atomic_read(&netstamp_needed))
+        skb->tstamp.tv64 = 0;
+        if (static_branch(&netstamp_needed))
                 __net_timestamp(skb);
-        else
-                skb->tstamp.tv64 = 0;
 }
 
-static inline void net_timestamp_check(struct sk_buff *skb)
-{
-        if (!skb->tstamp.tv64 && atomic_read(&netstamp_needed))
-                __net_timestamp(skb);
-}
+#define net_timestamp_check(COND, SKB)                  \
+        if (static_branch(&netstamp_needed)) {          \
+                if ((COND) && !(SKB)->tstamp.tv64)      \
+                        __net_timestamp(SKB);           \
+        }                                               \
 
 static int net_hwtstamp_validate(struct ifreq *ifr)
 {
@@ -1923,7 +1914,8 @@ EXPORT_SYMBOL(skb_checksum_help);
  *      It may return NULL if the skb requires no segmentation.  This is
  *      only possible when GSO is used for verifying header integrity.
  */
-struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features)
+struct sk_buff *skb_gso_segment(struct sk_buff *skb,
+        netdev_features_t features)
 {
         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
         struct packet_type *ptype;
@@ -1953,9 +1945,9 @@ struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features)
                 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
                         dev->ethtool_ops->get_drvinfo(dev, &info);
 
-                WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d ip_summed=%d\n",
-                     info.driver, dev ? dev->features : 0L,
-                     skb->sk ? skb->sk->sk_route_caps : 0L,
+                WARN(1, "%s: caps=(%pNF, %pNF) len=%d data_len=%d ip_summed=%d\n",
+                     info.driver, dev ? &dev->features : NULL,
+                     skb->sk ? &skb->sk->sk_route_caps : NULL,
                      skb->len, skb->data_len, skb->ip_summed);
 
                 if (skb_header_cloned(skb) &&
@@ -2064,7 +2056,7 @@ static void dev_gso_skb_destructor(struct sk_buff *skb)
  *      This function segments the given skb and stores the list of segments
  *      in skb->next.
  */
-static int dev_gso_segment(struct sk_buff *skb, int features)
+static int dev_gso_segment(struct sk_buff *skb, netdev_features_t features)
 {
         struct sk_buff *segs;
 
@@ -2103,7 +2095,7 @@ static inline void skb_orphan_try(struct sk_buff *skb)
         }
 }
 
-static bool can_checksum_protocol(unsigned long features, __be16 protocol)
+static bool can_checksum_protocol(netdev_features_t features, __be16 protocol)
 {
         return ((features & NETIF_F_GEN_CSUM) ||
                 ((features & NETIF_F_V4_CSUM) &&
@@ -2114,7 +2106,8 @@ static bool can_checksum_protocol(unsigned long features, __be16 protocol)
                  protocol == htons(ETH_P_FCOE)));
 }
 
-static u32 harmonize_features(struct sk_buff *skb, __be16 protocol, u32 features)
+static netdev_features_t harmonize_features(struct sk_buff *skb,
+        __be16 protocol, netdev_features_t features)
 {
         if (!can_checksum_protocol(features, protocol)) {
                 features &= ~NETIF_F_ALL_CSUM;
@@ -2126,10 +2119,10 @@ static u32 harmonize_features(struct sk_buff *skb, __be16 protocol, u32 features
         return features;
 }
 
-u32 netif_skb_features(struct sk_buff *skb)
+netdev_features_t netif_skb_features(struct sk_buff *skb)
 {
         __be16 protocol = skb->protocol;
-        u32 features = skb->dev->features;
+        netdev_features_t features = skb->dev->features;
 
         if (protocol == htons(ETH_P_8021Q)) {
                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
@@ -2175,7 +2168,7 @@ int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
         unsigned int skb_len;
 
         if (likely(!skb->next)) {
-                u32 features;
+                netdev_features_t features;
 
                 /*
                  * If device doesn't need skb->dst, release it right now while
@@ -2456,6 +2449,18 @@ static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
         return rc;
 }
 
+#if IS_ENABLED(CONFIG_NETPRIO_CGROUP)
+static void skb_update_prio(struct sk_buff *skb)
+{
+        struct netprio_map *map = rcu_dereference(skb->dev->priomap);
+
+        if ((!skb->priority) && (skb->sk) && map)
+                skb->priority = map->priomap[skb->sk->sk_cgrp_prioidx];
+}
+#else
+#define skb_update_prio(skb)
+#endif
+
 static DEFINE_PER_CPU(int, xmit_recursion);
 #define RECURSION_LIMIT 10
 
@@ -2496,6 +2501,8 @@ int dev_queue_xmit(struct sk_buff *skb)
          */
         rcu_read_lock_bh();
 
+        skb_update_prio(skb);
+
         txq = dev_pick_tx(dev, skb);
         q = rcu_dereference_bh(txq->qdisc);
 
@@ -2718,6 +2725,8 @@ EXPORT_SYMBOL(__skb_get_rxhash);
 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
 EXPORT_SYMBOL(rps_sock_flow_table);
 
+struct jump_label_key rps_needed __read_mostly;
+
 static struct rps_dev_flow *
 set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
             struct rps_dev_flow *rflow, u16 next_cpu)
@@ -2997,12 +3006,11 @@ int netif_rx(struct sk_buff *skb)
         if (netpoll_rx(skb))
                 return NET_RX_DROP;
 
-        if (netdev_tstamp_prequeue)
-                net_timestamp_check(skb);
+        net_timestamp_check(netdev_tstamp_prequeue, skb);
 
         trace_netif_rx(skb);
 #ifdef CONFIG_RPS
-        {
+        if (static_branch(&rps_needed)) {
                 struct rps_dev_flow voidflow, *rflow = &voidflow;
                 int cpu;
 
@@ -3017,14 +3025,13 @@ int netif_rx(struct sk_buff *skb)
 
                 rcu_read_unlock();
                 preempt_enable();
-        }
-#else
+        } else
+#endif
         {
                 unsigned int qtail;
                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
                 put_cpu();
         }
-#endif
         return ret;
 }
 EXPORT_SYMBOL(netif_rx);
@@ -3230,8 +3237,7 @@ static int __netif_receive_skb(struct sk_buff *skb)
         int ret = NET_RX_DROP;
         __be16 type;
 
-        if (!netdev_tstamp_prequeue)
-                net_timestamp_check(skb);
+        net_timestamp_check(!netdev_tstamp_prequeue, skb);
 
         trace_netif_receive_skb(skb);
 
@@ -3362,14 +3368,13 @@ out:
  */
 int netif_receive_skb(struct sk_buff *skb)
 {
-        if (netdev_tstamp_prequeue)
-                net_timestamp_check(skb);
+        net_timestamp_check(netdev_tstamp_prequeue, skb);
 
         if (skb_defer_rx_timestamp(skb))
                 return NET_RX_SUCCESS;
 
 #ifdef CONFIG_RPS
-        {
+        if (static_branch(&rps_needed)) {
                 struct rps_dev_flow voidflow, *rflow = &voidflow;
                 int cpu, ret;
 
@@ -3380,16 +3385,12 @@ int netif_receive_skb(struct sk_buff *skb)
                 if (cpu >= 0) {
                         ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
                         rcu_read_unlock();
-                } else {
-                        rcu_read_unlock();
-                        ret = __netif_receive_skb(skb);
+                        return ret;
                 }
-
-                return ret;
+                rcu_read_unlock();
         }
-#else
-        return __netif_receive_skb(skb);
 #endif
+        return __netif_receive_skb(skb);
 }
 EXPORT_SYMBOL(netif_receive_skb);
 
@@ -5362,7 +5363,8 @@ static void rollback_registered(struct net_device *dev)
         list_del(&single);
 }
 
-static u32 netdev_fix_features(struct net_device *dev, u32 features)
+static netdev_features_t netdev_fix_features(struct net_device *dev,
+        netdev_features_t features)
 {
         /* Fix illegal checksum combinations */
         if ((features & NETIF_F_HW_CSUM) &&
@@ -5371,12 +5373,6 @@ static u32 netdev_fix_features(struct net_device *dev, u32 features)
                 features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
         }
 
-        if ((features & NETIF_F_NO_CSUM) &&
-            (features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
-                netdev_warn(dev, "mixed no checksumming and other settings.\n");
-                features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
-        }
-
         /* Fix illegal SG+CSUM combinations. */
         if ((features & NETIF_F_SG) &&
             !(features & NETIF_F_ALL_CSUM)) {
@@ -5424,7 +5420,7 @@ static u32 netdev_fix_features(struct net_device *dev, u32 features)
 
 int __netdev_update_features(struct net_device *dev)
 {
-        u32 features;
+        netdev_features_t features;
         int err = 0;
 
         ASSERT_RTNL();
@@ -5440,16 +5436,16 @@ int __netdev_update_features(struct net_device *dev)
         if (dev->features == features)
                 return 0;
 
-        netdev_dbg(dev, "Features changed: 0x%08x -> 0x%08x\n",
-                dev->features, features);
+        netdev_dbg(dev, "Features changed: %pNF -> %pNF\n",
+                &dev->features, &features);
 
         if (dev->netdev_ops->ndo_set_features)
                 err = dev->netdev_ops->ndo_set_features(dev, features);
 
         if (unlikely(err < 0)) {
                 netdev_err(dev,
-                        "set_features() failed (%d); wanted 0x%08x, left 0x%08x\n",
-                        err, features, dev->features);
+                        "set_features() failed (%d); wanted %pNF, left %pNF\n",
+                        err, &features, &dev->features);
                 return -1;
         }
 
@@ -5633,11 +5629,12 @@ int register_netdevice(struct net_device *dev)
         dev->wanted_features = dev->features & dev->hw_features;
 
         /* Turn on no cache copy if HW is doing checksum */
-        dev->hw_features |= NETIF_F_NOCACHE_COPY;
-        if ((dev->features & NETIF_F_ALL_CSUM) &&
-            !(dev->features & NETIF_F_NO_CSUM)) {
-                dev->wanted_features |= NETIF_F_NOCACHE_COPY;
-                dev->features |= NETIF_F_NOCACHE_COPY;
+        if (!(dev->flags & IFF_LOOPBACK)) {
+                dev->hw_features |= NETIF_F_NOCACHE_COPY;
+                if (dev->features & NETIF_F_ALL_CSUM) {
+                        dev->wanted_features |= NETIF_F_NOCACHE_COPY;
+                        dev->features |= NETIF_F_NOCACHE_COPY;
+                }
         }
 
         /* Make NETIF_F_HIGHDMA inheritable to VLAN devices.
@@ -6373,7 +6370,8 @@ static int dev_cpu_callback(struct notifier_block *nfb,
  *      @one to the master device with current feature set @all.  Will not
  *      enable anything that is off in @mask. Returns the new feature set.
  */
-u32 netdev_increment_features(u32 all, u32 one, u32 mask)
+netdev_features_t netdev_increment_features(netdev_features_t all,
+        netdev_features_t one, netdev_features_t mask)
 {
         if (mask & NETIF_F_GEN_CSUM)
                 mask |= NETIF_F_ALL_CSUM;
@@ -6382,10 +6380,6 @@ u32 netdev_increment_features(u32 all, u32 one, u32 mask)
         all |= one & (NETIF_F_ONE_FOR_ALL|NETIF_F_ALL_CSUM) & mask;
         all &= one | ~NETIF_F_ALL_FOR_ALL;
 
-        /* If device needs checksumming, downgrade to it. */
-        if (all & (NETIF_F_ALL_CSUM & ~NETIF_F_NO_CSUM))
-                all &= ~NETIF_F_NO_CSUM;
-
         /* If one device supports hw checksumming, set for all. */
         if (all & NETIF_F_GEN_CSUM)
                 all &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);