LCOV - code coverage report
Current view: top level - net/core - ethtool.c (source / functions) Hit Total Coverage
Test: Real Lines: 40 1202 3.3 %
Date: 2020-10-17 15:46:43 Functions: 0 84 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * net/core/ethtool.c - Ethtool ioctl handler
       4                 :            :  * Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>
       5                 :            :  *
       6                 :            :  * This file is where we call all the ethtool_ops commands to get
       7                 :            :  * the information ethtool needs.
       8                 :            :  */
       9                 :            : 
      10                 :            : #include <linux/module.h>
      11                 :            : #include <linux/types.h>
      12                 :            : #include <linux/capability.h>
      13                 :            : #include <linux/errno.h>
      14                 :            : #include <linux/ethtool.h>
      15                 :            : #include <linux/netdevice.h>
      16                 :            : #include <linux/net_tstamp.h>
      17                 :            : #include <linux/phy.h>
      18                 :            : #include <linux/bitops.h>
      19                 :            : #include <linux/uaccess.h>
      20                 :            : #include <linux/vmalloc.h>
      21                 :            : #include <linux/sfp.h>
      22                 :            : #include <linux/slab.h>
      23                 :            : #include <linux/rtnetlink.h>
      24                 :            : #include <linux/sched/signal.h>
      25                 :            : #include <linux/net.h>
      26                 :            : #include <net/devlink.h>
      27                 :            : #include <net/xdp_sock.h>
      28                 :            : #include <net/flow_offload.h>
      29                 :            : 
      30                 :            : /*
      31                 :            :  * Some useful ethtool_ops methods that're device independent.
      32                 :            :  * If we find that all drivers want to do the same thing here,
      33                 :            :  * we can turn these into dev_() function calls.
      34                 :            :  */
      35                 :            : 
      36                 :          0 : u32 ethtool_op_get_link(struct net_device *dev)
      37                 :            : {
      38                 :          0 :         return netif_carrier_ok(dev) ? 1 : 0;
      39                 :            : }
      40                 :            : EXPORT_SYMBOL(ethtool_op_get_link);
      41                 :            : 
      42                 :          0 : int ethtool_op_get_ts_info(struct net_device *dev, struct ethtool_ts_info *info)
      43                 :            : {
      44                 :          0 :         info->so_timestamping =
      45                 :            :                 SOF_TIMESTAMPING_TX_SOFTWARE |
      46                 :            :                 SOF_TIMESTAMPING_RX_SOFTWARE |
      47                 :            :                 SOF_TIMESTAMPING_SOFTWARE;
      48                 :          0 :         info->phc_index = -1;
      49                 :          0 :         return 0;
      50                 :            : }
      51                 :            : EXPORT_SYMBOL(ethtool_op_get_ts_info);
      52                 :            : 
      53                 :            : /* Handlers for each ethtool command */
      54                 :            : 
      55                 :            : #define ETHTOOL_DEV_FEATURE_WORDS       ((NETDEV_FEATURE_COUNT + 31) / 32)
      56                 :            : 
      57                 :            : static const char netdev_features_strings[NETDEV_FEATURE_COUNT][ETH_GSTRING_LEN] = {
      58                 :            :         [NETIF_F_SG_BIT] =               "tx-scatter-gather",
      59                 :            :         [NETIF_F_IP_CSUM_BIT] =          "tx-checksum-ipv4",
      60                 :            :         [NETIF_F_HW_CSUM_BIT] =          "tx-checksum-ip-generic",
      61                 :            :         [NETIF_F_IPV6_CSUM_BIT] =        "tx-checksum-ipv6",
      62                 :            :         [NETIF_F_HIGHDMA_BIT] =          "highdma",
      63                 :            :         [NETIF_F_FRAGLIST_BIT] =         "tx-scatter-gather-fraglist",
      64                 :            :         [NETIF_F_HW_VLAN_CTAG_TX_BIT] =  "tx-vlan-hw-insert",
      65                 :            : 
      66                 :            :         [NETIF_F_HW_VLAN_CTAG_RX_BIT] =  "rx-vlan-hw-parse",
      67                 :            :         [NETIF_F_HW_VLAN_CTAG_FILTER_BIT] = "rx-vlan-filter",
      68                 :            :         [NETIF_F_HW_VLAN_STAG_TX_BIT] =  "tx-vlan-stag-hw-insert",
      69                 :            :         [NETIF_F_HW_VLAN_STAG_RX_BIT] =  "rx-vlan-stag-hw-parse",
      70                 :            :         [NETIF_F_HW_VLAN_STAG_FILTER_BIT] = "rx-vlan-stag-filter",
      71                 :            :         [NETIF_F_VLAN_CHALLENGED_BIT] =  "vlan-challenged",
      72                 :            :         [NETIF_F_GSO_BIT] =              "tx-generic-segmentation",
      73                 :            :         [NETIF_F_LLTX_BIT] =             "tx-lockless",
      74                 :            :         [NETIF_F_NETNS_LOCAL_BIT] =      "netns-local",
      75                 :            :         [NETIF_F_GRO_BIT] =              "rx-gro",
      76                 :            :         [NETIF_F_GRO_HW_BIT] =           "rx-gro-hw",
      77                 :            :         [NETIF_F_LRO_BIT] =              "rx-lro",
      78                 :            : 
      79                 :            :         [NETIF_F_TSO_BIT] =              "tx-tcp-segmentation",
      80                 :            :         [NETIF_F_GSO_ROBUST_BIT] =       "tx-gso-robust",
      81                 :            :         [NETIF_F_TSO_ECN_BIT] =          "tx-tcp-ecn-segmentation",
      82                 :            :         [NETIF_F_TSO_MANGLEID_BIT] =     "tx-tcp-mangleid-segmentation",
      83                 :            :         [NETIF_F_TSO6_BIT] =             "tx-tcp6-segmentation",
      84                 :            :         [NETIF_F_FSO_BIT] =              "tx-fcoe-segmentation",
      85                 :            :         [NETIF_F_GSO_GRE_BIT] =          "tx-gre-segmentation",
      86                 :            :         [NETIF_F_GSO_GRE_CSUM_BIT] =     "tx-gre-csum-segmentation",
      87                 :            :         [NETIF_F_GSO_IPXIP4_BIT] =       "tx-ipxip4-segmentation",
      88                 :            :         [NETIF_F_GSO_IPXIP6_BIT] =       "tx-ipxip6-segmentation",
      89                 :            :         [NETIF_F_GSO_UDP_TUNNEL_BIT] =   "tx-udp_tnl-segmentation",
      90                 :            :         [NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT] = "tx-udp_tnl-csum-segmentation",
      91                 :            :         [NETIF_F_GSO_PARTIAL_BIT] =      "tx-gso-partial",
      92                 :            :         [NETIF_F_GSO_SCTP_BIT] =         "tx-sctp-segmentation",
      93                 :            :         [NETIF_F_GSO_ESP_BIT] =          "tx-esp-segmentation",
      94                 :            :         [NETIF_F_GSO_UDP_L4_BIT] =       "tx-udp-segmentation",
      95                 :            : 
      96                 :            :         [NETIF_F_FCOE_CRC_BIT] =         "tx-checksum-fcoe-crc",
      97                 :            :         [NETIF_F_SCTP_CRC_BIT] =        "tx-checksum-sctp",
      98                 :            :         [NETIF_F_FCOE_MTU_BIT] =         "fcoe-mtu",
      99                 :            :         [NETIF_F_NTUPLE_BIT] =           "rx-ntuple-filter",
     100                 :            :         [NETIF_F_RXHASH_BIT] =           "rx-hashing",
     101                 :            :         [NETIF_F_RXCSUM_BIT] =           "rx-checksum",
     102                 :            :         [NETIF_F_NOCACHE_COPY_BIT] =     "tx-nocache-copy",
     103                 :            :         [NETIF_F_LOOPBACK_BIT] =         "loopback",
     104                 :            :         [NETIF_F_RXFCS_BIT] =            "rx-fcs",
     105                 :            :         [NETIF_F_RXALL_BIT] =            "rx-all",
     106                 :            :         [NETIF_F_HW_L2FW_DOFFLOAD_BIT] = "l2-fwd-offload",
     107                 :            :         [NETIF_F_HW_TC_BIT] =            "hw-tc-offload",
     108                 :            :         [NETIF_F_HW_ESP_BIT] =           "esp-hw-offload",
     109                 :            :         [NETIF_F_HW_ESP_TX_CSUM_BIT] =   "esp-tx-csum-hw-offload",
     110                 :            :         [NETIF_F_RX_UDP_TUNNEL_PORT_BIT] =       "rx-udp_tunnel-port-offload",
     111                 :            :         [NETIF_F_HW_TLS_RECORD_BIT] =   "tls-hw-record",
     112                 :            :         [NETIF_F_HW_TLS_TX_BIT] =        "tls-hw-tx-offload",
     113                 :            :         [NETIF_F_HW_TLS_RX_BIT] =        "tls-hw-rx-offload",
     114                 :            : };
     115                 :            : 
     116                 :            : static const char
     117                 :            : rss_hash_func_strings[ETH_RSS_HASH_FUNCS_COUNT][ETH_GSTRING_LEN] = {
     118                 :            :         [ETH_RSS_HASH_TOP_BIT] =        "toeplitz",
     119                 :            :         [ETH_RSS_HASH_XOR_BIT] =        "xor",
     120                 :            :         [ETH_RSS_HASH_CRC32_BIT] =      "crc32",
     121                 :            : };
     122                 :            : 
     123                 :            : static const char
     124                 :            : tunable_strings[__ETHTOOL_TUNABLE_COUNT][ETH_GSTRING_LEN] = {
     125                 :            :         [ETHTOOL_ID_UNSPEC]     = "Unspec",
     126                 :            :         [ETHTOOL_RX_COPYBREAK]  = "rx-copybreak",
     127                 :            :         [ETHTOOL_TX_COPYBREAK]  = "tx-copybreak",
     128                 :            :         [ETHTOOL_PFC_PREVENTION_TOUT] = "pfc-prevention-tout",
     129                 :            : };
     130                 :            : 
     131                 :            : static const char
     132                 :            : phy_tunable_strings[__ETHTOOL_PHY_TUNABLE_COUNT][ETH_GSTRING_LEN] = {
     133                 :            :         [ETHTOOL_ID_UNSPEC]     = "Unspec",
     134                 :            :         [ETHTOOL_PHY_DOWNSHIFT] = "phy-downshift",
     135                 :            :         [ETHTOOL_PHY_FAST_LINK_DOWN] = "phy-fast-link-down",
     136                 :            :         [ETHTOOL_PHY_EDPD]      = "phy-energy-detect-power-down",
     137                 :            : };
     138                 :            : 
     139                 :          0 : static int ethtool_get_features(struct net_device *dev, void __user *useraddr)
     140                 :            : {
     141                 :          0 :         struct ethtool_gfeatures cmd = {
     142                 :            :                 .cmd = ETHTOOL_GFEATURES,
     143                 :            :                 .size = ETHTOOL_DEV_FEATURE_WORDS,
     144                 :            :         };
     145                 :            :         struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS];
     146                 :            :         u32 __user *sizeaddr;
     147                 :            :         u32 copy_size;
     148                 :            :         int i;
     149                 :            : 
     150                 :            :         /* in case feature bits run out again */
     151                 :            :         BUILD_BUG_ON(ETHTOOL_DEV_FEATURE_WORDS * sizeof(u32) > sizeof(netdev_features_t));
     152                 :            : 
     153                 :          0 :         for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; ++i) {
     154                 :          0 :                 features[i].available = (u32)(dev->hw_features >> (32 * i));
     155                 :          0 :                 features[i].requested = (u32)(dev->wanted_features >> (32 * i));
     156                 :          0 :                 features[i].active = (u32)(dev->features >> (32 * i));
     157                 :          0 :                 features[i].never_changed =
     158                 :          0 :                         (u32)(NETIF_F_NEVER_CHANGE >> (32 * i));
     159                 :            :         }
     160                 :            : 
     161                 :          0 :         sizeaddr = useraddr + offsetof(struct ethtool_gfeatures, size);
     162                 :          0 :         if (get_user(copy_size, sizeaddr))
     163                 :            :                 return -EFAULT;
     164                 :            : 
     165                 :          0 :         if (copy_size > ETHTOOL_DEV_FEATURE_WORDS)
     166                 :            :                 copy_size = ETHTOOL_DEV_FEATURE_WORDS;
     167                 :            : 
     168                 :          0 :         if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
     169                 :            :                 return -EFAULT;
     170                 :          0 :         useraddr += sizeof(cmd);
     171                 :          0 :         if (copy_to_user(useraddr, features, copy_size * sizeof(*features)))
     172                 :            :                 return -EFAULT;
     173                 :            : 
     174                 :          0 :         return 0;
     175                 :            : }
     176                 :            : 
     177                 :          0 : static int ethtool_set_features(struct net_device *dev, void __user *useraddr)
     178                 :            : {
     179                 :            :         struct ethtool_sfeatures cmd;
     180                 :            :         struct ethtool_set_features_block features[ETHTOOL_DEV_FEATURE_WORDS];
     181                 :            :         netdev_features_t wanted = 0, valid = 0;
     182                 :            :         int i, ret = 0;
     183                 :            : 
     184                 :          0 :         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
     185                 :            :                 return -EFAULT;
     186                 :          0 :         useraddr += sizeof(cmd);
     187                 :            : 
     188                 :          0 :         if (cmd.size != ETHTOOL_DEV_FEATURE_WORDS)
     189                 :            :                 return -EINVAL;
     190                 :            : 
     191                 :          0 :         if (copy_from_user(features, useraddr, sizeof(features)))
     192                 :            :                 return -EFAULT;
     193                 :            : 
     194                 :          0 :         for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; ++i) {
     195                 :          0 :                 valid |= (netdev_features_t)features[i].valid << (32 * i);
     196                 :          0 :                 wanted |= (netdev_features_t)features[i].requested << (32 * i);
     197                 :            :         }
     198                 :            : 
     199                 :          0 :         if (valid & ~NETIF_F_ETHTOOL_BITS)
     200                 :            :                 return -EINVAL;
     201                 :            : 
     202                 :          0 :         if (valid & ~dev->hw_features) {
     203                 :          0 :                 valid &= dev->hw_features;
     204                 :            :                 ret |= ETHTOOL_F_UNSUPPORTED;
     205                 :            :         }
     206                 :            : 
     207                 :          0 :         dev->wanted_features &= ~valid;
     208                 :          0 :         dev->wanted_features |= wanted & valid;
     209                 :          0 :         __netdev_update_features(dev);
     210                 :            : 
     211                 :          0 :         if ((dev->wanted_features ^ dev->features) & valid)
     212                 :          0 :                 ret |= ETHTOOL_F_WISH;
     213                 :            : 
     214                 :          0 :         return ret;
     215                 :            : }
     216                 :            : 
     217                 :          0 : static int __ethtool_get_sset_count(struct net_device *dev, int sset)
     218                 :            : {
     219                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
     220                 :            : 
     221                 :          0 :         if (sset == ETH_SS_FEATURES)
     222                 :            :                 return ARRAY_SIZE(netdev_features_strings);
     223                 :            : 
     224                 :          0 :         if (sset == ETH_SS_RSS_HASH_FUNCS)
     225                 :            :                 return ARRAY_SIZE(rss_hash_func_strings);
     226                 :            : 
     227                 :          0 :         if (sset == ETH_SS_TUNABLES)
     228                 :            :                 return ARRAY_SIZE(tunable_strings);
     229                 :            : 
     230                 :          0 :         if (sset == ETH_SS_PHY_TUNABLES)
     231                 :            :                 return ARRAY_SIZE(phy_tunable_strings);
     232                 :            : 
     233                 :          0 :         if (sset == ETH_SS_PHY_STATS && dev->phydev &&
     234                 :          0 :             !ops->get_ethtool_phy_stats)
     235                 :          0 :                 return phy_ethtool_get_sset_count(dev->phydev);
     236                 :            : 
     237                 :          0 :         if (ops->get_sset_count && ops->get_strings)
     238                 :          0 :                 return ops->get_sset_count(dev, sset);
     239                 :            :         else
     240                 :            :                 return -EOPNOTSUPP;
     241                 :            : }
     242                 :            : 
     243                 :          0 : static void __ethtool_get_strings(struct net_device *dev,
     244                 :            :         u32 stringset, u8 *data)
     245                 :            : {
     246                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
     247                 :            : 
     248                 :          0 :         if (stringset == ETH_SS_FEATURES)
     249                 :          0 :                 memcpy(data, netdev_features_strings,
     250                 :            :                         sizeof(netdev_features_strings));
     251                 :          0 :         else if (stringset == ETH_SS_RSS_HASH_FUNCS)
     252                 :          0 :                 memcpy(data, rss_hash_func_strings,
     253                 :            :                        sizeof(rss_hash_func_strings));
     254                 :          0 :         else if (stringset == ETH_SS_TUNABLES)
     255                 :          0 :                 memcpy(data, tunable_strings, sizeof(tunable_strings));
     256                 :          0 :         else if (stringset == ETH_SS_PHY_TUNABLES)
     257                 :          0 :                 memcpy(data, phy_tunable_strings, sizeof(phy_tunable_strings));
     258                 :          0 :         else if (stringset == ETH_SS_PHY_STATS && dev->phydev &&
     259                 :          0 :                  !ops->get_ethtool_phy_stats)
     260                 :          0 :                 phy_ethtool_get_strings(dev->phydev, data);
     261                 :            :         else
     262                 :            :                 /* ops->get_strings is valid because checked earlier */
     263                 :          0 :                 ops->get_strings(dev, stringset, data);
     264                 :          0 : }
     265                 :            : 
     266                 :          0 : static netdev_features_t ethtool_get_feature_mask(u32 eth_cmd)
     267                 :            : {
     268                 :            :         /* feature masks of legacy discrete ethtool ops */
     269                 :            : 
     270                 :          0 :         switch (eth_cmd) {
     271                 :            :         case ETHTOOL_GTXCSUM:
     272                 :            :         case ETHTOOL_STXCSUM:
     273                 :            :                 return NETIF_F_CSUM_MASK | NETIF_F_SCTP_CRC;
     274                 :            :         case ETHTOOL_GRXCSUM:
     275                 :            :         case ETHTOOL_SRXCSUM:
     276                 :          0 :                 return NETIF_F_RXCSUM;
     277                 :            :         case ETHTOOL_GSG:
     278                 :            :         case ETHTOOL_SSG:
     279                 :          0 :                 return NETIF_F_SG;
     280                 :            :         case ETHTOOL_GTSO:
     281                 :            :         case ETHTOOL_STSO:
     282                 :          0 :                 return NETIF_F_ALL_TSO;
     283                 :            :         case ETHTOOL_GGSO:
     284                 :            :         case ETHTOOL_SGSO:
     285                 :          0 :                 return NETIF_F_GSO;
     286                 :            :         case ETHTOOL_GGRO:
     287                 :            :         case ETHTOOL_SGRO:
     288                 :          0 :                 return NETIF_F_GRO;
     289                 :            :         default:
     290                 :          0 :                 BUG();
     291                 :            :         }
     292                 :            : }
     293                 :            : 
     294                 :          0 : static int ethtool_get_one_feature(struct net_device *dev,
     295                 :            :         char __user *useraddr, u32 ethcmd)
     296                 :            : {
     297                 :          0 :         netdev_features_t mask = ethtool_get_feature_mask(ethcmd);
     298                 :          0 :         struct ethtool_value edata = {
     299                 :            :                 .cmd = ethcmd,
     300                 :          0 :                 .data = !!(dev->features & mask),
     301                 :            :         };
     302                 :            : 
     303                 :          0 :         if (copy_to_user(useraddr, &edata, sizeof(edata)))
     304                 :            :                 return -EFAULT;
     305                 :          0 :         return 0;
     306                 :            : }
     307                 :            : 
     308                 :          0 : static int ethtool_set_one_feature(struct net_device *dev,
     309                 :            :         void __user *useraddr, u32 ethcmd)
     310                 :            : {
     311                 :            :         struct ethtool_value edata;
     312                 :            :         netdev_features_t mask;
     313                 :            : 
     314                 :          0 :         if (copy_from_user(&edata, useraddr, sizeof(edata)))
     315                 :            :                 return -EFAULT;
     316                 :            : 
     317                 :          0 :         mask = ethtool_get_feature_mask(ethcmd);
     318                 :          0 :         mask &= dev->hw_features;
     319                 :          0 :         if (!mask)
     320                 :            :                 return -EOPNOTSUPP;
     321                 :            : 
     322                 :          0 :         if (edata.data)
     323                 :          0 :                 dev->wanted_features |= mask;
     324                 :            :         else
     325                 :          0 :                 dev->wanted_features &= ~mask;
     326                 :            : 
     327                 :          0 :         __netdev_update_features(dev);
     328                 :            : 
     329                 :          0 :         return 0;
     330                 :            : }
     331                 :            : 
     332                 :            : #define ETH_ALL_FLAGS    (ETH_FLAG_LRO | ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN | \
     333                 :            :                           ETH_FLAG_NTUPLE | ETH_FLAG_RXHASH)
     334                 :            : #define ETH_ALL_FEATURES (NETIF_F_LRO | NETIF_F_HW_VLAN_CTAG_RX | \
     335                 :            :                           NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_NTUPLE | \
     336                 :            :                           NETIF_F_RXHASH)
     337                 :            : 
     338                 :          0 : static u32 __ethtool_get_flags(struct net_device *dev)
     339                 :            : {
     340                 :            :         u32 flags = 0;
     341                 :            : 
     342                 :          0 :         if (dev->features & NETIF_F_LRO)
     343                 :            :                 flags |= ETH_FLAG_LRO;
     344                 :          0 :         if (dev->features & NETIF_F_HW_VLAN_CTAG_RX)
     345                 :          0 :                 flags |= ETH_FLAG_RXVLAN;
     346                 :          0 :         if (dev->features & NETIF_F_HW_VLAN_CTAG_TX)
     347                 :          0 :                 flags |= ETH_FLAG_TXVLAN;
     348                 :          0 :         if (dev->features & NETIF_F_NTUPLE)
     349                 :          0 :                 flags |= ETH_FLAG_NTUPLE;
     350                 :          0 :         if (dev->features & NETIF_F_RXHASH)
     351                 :          0 :                 flags |= ETH_FLAG_RXHASH;
     352                 :            : 
     353                 :          0 :         return flags;
     354                 :            : }
     355                 :            : 
     356                 :          0 : static int __ethtool_set_flags(struct net_device *dev, u32 data)
     357                 :            : {
     358                 :            :         netdev_features_t features = 0, changed;
     359                 :            : 
     360                 :          0 :         if (data & ~ETH_ALL_FLAGS)
     361                 :            :                 return -EINVAL;
     362                 :            : 
     363                 :          0 :         if (data & ETH_FLAG_LRO)
     364                 :            :                 features |= NETIF_F_LRO;
     365                 :          0 :         if (data & ETH_FLAG_RXVLAN)
     366                 :          0 :                 features |= NETIF_F_HW_VLAN_CTAG_RX;
     367                 :          0 :         if (data & ETH_FLAG_TXVLAN)
     368                 :          0 :                 features |= NETIF_F_HW_VLAN_CTAG_TX;
     369                 :          0 :         if (data & ETH_FLAG_NTUPLE)
     370                 :          0 :                 features |= NETIF_F_NTUPLE;
     371                 :          0 :         if (data & ETH_FLAG_RXHASH)
     372                 :          0 :                 features |= NETIF_F_RXHASH;
     373                 :            : 
     374                 :            :         /* allow changing only bits set in hw_features */
     375                 :          0 :         changed = (features ^ dev->features) & ETH_ALL_FEATURES;
     376                 :          0 :         if (changed & ~dev->hw_features)
     377                 :          0 :                 return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP;
     378                 :            : 
     379                 :          0 :         dev->wanted_features =
     380                 :          0 :                 (dev->wanted_features & ~changed) | (features & changed);
     381                 :            : 
     382                 :          0 :         __netdev_update_features(dev);
     383                 :            : 
     384                 :          0 :         return 0;
     385                 :            : }
     386                 :            : 
     387                 :            : /* Given two link masks, AND them together and save the result in dst. */
     388                 :          0 : void ethtool_intersect_link_masks(struct ethtool_link_ksettings *dst,
     389                 :            :                                   struct ethtool_link_ksettings *src)
     390                 :            : {
     391                 :            :         unsigned int size = BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS);
     392                 :            :         unsigned int idx = 0;
     393                 :            : 
     394                 :          0 :         for (; idx < size; idx++) {
     395                 :          0 :                 dst->link_modes.supported[idx] &=
     396                 :          0 :                         src->link_modes.supported[idx];
     397                 :          0 :                 dst->link_modes.advertising[idx] &=
     398                 :          0 :                         src->link_modes.advertising[idx];
     399                 :            :         }
     400                 :          0 : }
     401                 :            : EXPORT_SYMBOL(ethtool_intersect_link_masks);
     402                 :            : 
     403                 :          0 : void ethtool_convert_legacy_u32_to_link_mode(unsigned long *dst,
     404                 :            :                                              u32 legacy_u32)
     405                 :            : {
     406                 :            :         bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);
     407                 :          0 :         dst[0] = legacy_u32;
     408                 :          0 : }
     409                 :            : EXPORT_SYMBOL(ethtool_convert_legacy_u32_to_link_mode);
     410                 :            : 
     411                 :            : /* return false if src had higher bits set. lower bits always updated. */
     412                 :          0 : bool ethtool_convert_link_mode_to_legacy_u32(u32 *legacy_u32,
     413                 :            :                                              const unsigned long *src)
     414                 :            : {
     415                 :            :         bool retval = true;
     416                 :            : 
     417                 :            :         /* TODO: following test will soon always be true */
     418                 :            :         if (__ETHTOOL_LINK_MODE_MASK_NBITS > 32) {
     419                 :            :                 __ETHTOOL_DECLARE_LINK_MODE_MASK(ext);
     420                 :            : 
     421                 :            :                 bitmap_zero(ext, __ETHTOOL_LINK_MODE_MASK_NBITS);
     422                 :            :                 bitmap_fill(ext, 32);
     423                 :          0 :                 bitmap_complement(ext, ext, __ETHTOOL_LINK_MODE_MASK_NBITS);
     424                 :          0 :                 if (bitmap_intersects(ext, src,
     425                 :            :                                       __ETHTOOL_LINK_MODE_MASK_NBITS)) {
     426                 :            :                         /* src mask goes beyond bit 31 */
     427                 :            :                         retval = false;
     428                 :            :                 }
     429                 :            :         }
     430                 :          0 :         *legacy_u32 = src[0];
     431                 :          0 :         return retval;
     432                 :            : }
     433                 :            : EXPORT_SYMBOL(ethtool_convert_link_mode_to_legacy_u32);
     434                 :            : 
     435                 :            : /* return false if legacy contained non-0 deprecated fields
     436                 :            :  * maxtxpkt/maxrxpkt. rest of ksettings always updated
     437                 :            :  */
     438                 :            : static bool
     439                 :          0 : convert_legacy_settings_to_link_ksettings(
     440                 :            :         struct ethtool_link_ksettings *link_ksettings,
     441                 :            :         const struct ethtool_cmd *legacy_settings)
     442                 :            : {
     443                 :            :         bool retval = true;
     444                 :            : 
     445                 :          0 :         memset(link_ksettings, 0, sizeof(*link_ksettings));
     446                 :            : 
     447                 :            :         /* This is used to tell users that driver is still using these
     448                 :            :          * deprecated legacy fields, and they should not use
     449                 :            :          * %ETHTOOL_GLINKSETTINGS/%ETHTOOL_SLINKSETTINGS
     450                 :            :          */
     451                 :          0 :         if (legacy_settings->maxtxpkt ||
     452                 :          0 :             legacy_settings->maxrxpkt)
     453                 :            :                 retval = false;
     454                 :            : 
     455                 :          0 :         ethtool_convert_legacy_u32_to_link_mode(
     456                 :          0 :                 link_ksettings->link_modes.supported,
     457                 :            :                 legacy_settings->supported);
     458                 :          0 :         ethtool_convert_legacy_u32_to_link_mode(
     459                 :          0 :                 link_ksettings->link_modes.advertising,
     460                 :            :                 legacy_settings->advertising);
     461                 :          0 :         ethtool_convert_legacy_u32_to_link_mode(
     462                 :          0 :                 link_ksettings->link_modes.lp_advertising,
     463                 :            :                 legacy_settings->lp_advertising);
     464                 :            :         link_ksettings->base.speed
     465                 :          0 :                 = ethtool_cmd_speed(legacy_settings);
     466                 :            :         link_ksettings->base.duplex
     467                 :          0 :                 = legacy_settings->duplex;
     468                 :            :         link_ksettings->base.port
     469                 :          0 :                 = legacy_settings->port;
     470                 :            :         link_ksettings->base.phy_address
     471                 :          0 :                 = legacy_settings->phy_address;
     472                 :            :         link_ksettings->base.autoneg
     473                 :          0 :                 = legacy_settings->autoneg;
     474                 :            :         link_ksettings->base.mdio_support
     475                 :          0 :                 = legacy_settings->mdio_support;
     476                 :            :         link_ksettings->base.eth_tp_mdix
     477                 :          0 :                 = legacy_settings->eth_tp_mdix;
     478                 :            :         link_ksettings->base.eth_tp_mdix_ctrl
     479                 :          0 :                 = legacy_settings->eth_tp_mdix_ctrl;
     480                 :          0 :         return retval;
     481                 :            : }
     482                 :            : 
     483                 :            : /* return false if ksettings link modes had higher bits
     484                 :            :  * set. legacy_settings always updated (best effort)
     485                 :            :  */
     486                 :            : static bool
     487                 :          0 : convert_link_ksettings_to_legacy_settings(
     488                 :            :         struct ethtool_cmd *legacy_settings,
     489                 :            :         const struct ethtool_link_ksettings *link_ksettings)
     490                 :            : {
     491                 :            :         bool retval = true;
     492                 :            : 
     493                 :          0 :         memset(legacy_settings, 0, sizeof(*legacy_settings));
     494                 :            :         /* this also clears the deprecated fields in legacy structure:
     495                 :            :          * __u8         transceiver;
     496                 :            :          * __u32        maxtxpkt;
     497                 :            :          * __u32        maxrxpkt;
     498                 :            :          */
     499                 :            : 
     500                 :          0 :         retval &= ethtool_convert_link_mode_to_legacy_u32(
     501                 :          0 :                 &legacy_settings->supported,
     502                 :          0 :                 link_ksettings->link_modes.supported);
     503                 :          0 :         retval &= ethtool_convert_link_mode_to_legacy_u32(
     504                 :          0 :                 &legacy_settings->advertising,
     505                 :          0 :                 link_ksettings->link_modes.advertising);
     506                 :          0 :         retval &= ethtool_convert_link_mode_to_legacy_u32(
     507                 :          0 :                 &legacy_settings->lp_advertising,
     508                 :          0 :                 link_ksettings->link_modes.lp_advertising);
     509                 :          0 :         ethtool_cmd_speed_set(legacy_settings, link_ksettings->base.speed);
     510                 :            :         legacy_settings->duplex
     511                 :          0 :                 = link_ksettings->base.duplex;
     512                 :            :         legacy_settings->port
     513                 :          0 :                 = link_ksettings->base.port;
     514                 :            :         legacy_settings->phy_address
     515                 :          0 :                 = link_ksettings->base.phy_address;
     516                 :            :         legacy_settings->autoneg
     517                 :          0 :                 = link_ksettings->base.autoneg;
     518                 :            :         legacy_settings->mdio_support
     519                 :          0 :                 = link_ksettings->base.mdio_support;
     520                 :            :         legacy_settings->eth_tp_mdix
     521                 :          0 :                 = link_ksettings->base.eth_tp_mdix;
     522                 :            :         legacy_settings->eth_tp_mdix_ctrl
     523                 :          0 :                 = link_ksettings->base.eth_tp_mdix_ctrl;
     524                 :            :         legacy_settings->transceiver
     525                 :          0 :                 = link_ksettings->base.transceiver;
     526                 :          0 :         return retval;
     527                 :            : }
     528                 :            : 
     529                 :            : /* number of 32-bit words to store the user's link mode bitmaps */
     530                 :            : #define __ETHTOOL_LINK_MODE_MASK_NU32                   \
     531                 :            :         DIV_ROUND_UP(__ETHTOOL_LINK_MODE_MASK_NBITS, 32)
     532                 :            : 
     533                 :            : /* layout of the struct passed from/to userland */
     534                 :            : struct ethtool_link_usettings {
     535                 :            :         struct ethtool_link_settings base;
     536                 :            :         struct {
     537                 :            :                 __u32 supported[__ETHTOOL_LINK_MODE_MASK_NU32];
     538                 :            :                 __u32 advertising[__ETHTOOL_LINK_MODE_MASK_NU32];
     539                 :            :                 __u32 lp_advertising[__ETHTOOL_LINK_MODE_MASK_NU32];
     540                 :            :         } link_modes;
     541                 :            : };
     542                 :            : 
     543                 :            : /* Internal kernel helper to query a device ethtool_link_settings. */
     544                 :          0 : int __ethtool_get_link_ksettings(struct net_device *dev,
     545                 :            :                                  struct ethtool_link_ksettings *link_ksettings)
     546                 :            : {
     547                 :          0 :         ASSERT_RTNL();
     548                 :            : 
     549                 :          0 :         if (!dev->ethtool_ops->get_link_ksettings)
     550                 :            :                 return -EOPNOTSUPP;
     551                 :            : 
     552                 :          0 :         memset(link_ksettings, 0, sizeof(*link_ksettings));
     553                 :          0 :         return dev->ethtool_ops->get_link_ksettings(dev, link_ksettings);
     554                 :            : }
     555                 :            : EXPORT_SYMBOL(__ethtool_get_link_ksettings);
     556                 :            : 
     557                 :            : /* convert ethtool_link_usettings in user space to a kernel internal
     558                 :            :  * ethtool_link_ksettings. return 0 on success, errno on error.
     559                 :            :  */
     560                 :          0 : static int load_link_ksettings_from_user(struct ethtool_link_ksettings *to,
     561                 :            :                                          const void __user *from)
     562                 :            : {
     563                 :            :         struct ethtool_link_usettings link_usettings;
     564                 :            : 
     565                 :          0 :         if (copy_from_user(&link_usettings, from, sizeof(link_usettings)))
     566                 :            :                 return -EFAULT;
     567                 :            : 
     568                 :          0 :         memcpy(&to->base, &link_usettings.base, sizeof(to->base));
     569                 :          0 :         bitmap_from_arr32(to->link_modes.supported,
     570                 :            :                           link_usettings.link_modes.supported,
     571                 :            :                           __ETHTOOL_LINK_MODE_MASK_NBITS);
     572                 :          0 :         bitmap_from_arr32(to->link_modes.advertising,
     573                 :            :                           link_usettings.link_modes.advertising,
     574                 :            :                           __ETHTOOL_LINK_MODE_MASK_NBITS);
     575                 :          0 :         bitmap_from_arr32(to->link_modes.lp_advertising,
     576                 :            :                           link_usettings.link_modes.lp_advertising,
     577                 :            :                           __ETHTOOL_LINK_MODE_MASK_NBITS);
     578                 :            : 
     579                 :          0 :         return 0;
     580                 :            : }
     581                 :            : 
     582                 :            : /* convert a kernel internal ethtool_link_ksettings to
     583                 :            :  * ethtool_link_usettings in user space. return 0 on success, errno on
     584                 :            :  * error.
     585                 :            :  */
     586                 :            : static int
     587                 :          0 : store_link_ksettings_for_user(void __user *to,
     588                 :            :                               const struct ethtool_link_ksettings *from)
     589                 :            : {
     590                 :            :         struct ethtool_link_usettings link_usettings;
     591                 :            : 
     592                 :          0 :         memcpy(&link_usettings.base, &from->base, sizeof(link_usettings));
     593                 :          0 :         bitmap_to_arr32(link_usettings.link_modes.supported,
     594                 :            :                         from->link_modes.supported,
     595                 :            :                         __ETHTOOL_LINK_MODE_MASK_NBITS);
     596                 :          0 :         bitmap_to_arr32(link_usettings.link_modes.advertising,
     597                 :            :                         from->link_modes.advertising,
     598                 :            :                         __ETHTOOL_LINK_MODE_MASK_NBITS);
     599                 :          0 :         bitmap_to_arr32(link_usettings.link_modes.lp_advertising,
     600                 :            :                         from->link_modes.lp_advertising,
     601                 :            :                         __ETHTOOL_LINK_MODE_MASK_NBITS);
     602                 :            : 
     603                 :          0 :         if (copy_to_user(to, &link_usettings, sizeof(link_usettings)))
     604                 :            :                 return -EFAULT;
     605                 :            : 
     606                 :          0 :         return 0;
     607                 :            : }
     608                 :            : 
     609                 :            : /* Query device for its ethtool_link_settings. */
     610                 :          0 : static int ethtool_get_link_ksettings(struct net_device *dev,
     611                 :            :                                       void __user *useraddr)
     612                 :            : {
     613                 :            :         int err = 0;
     614                 :            :         struct ethtool_link_ksettings link_ksettings;
     615                 :            : 
     616                 :          0 :         ASSERT_RTNL();
     617                 :          0 :         if (!dev->ethtool_ops->get_link_ksettings)
     618                 :            :                 return -EOPNOTSUPP;
     619                 :            : 
     620                 :            :         /* handle bitmap nbits handshake */
     621                 :          0 :         if (copy_from_user(&link_ksettings.base, useraddr,
     622                 :            :                            sizeof(link_ksettings.base)))
     623                 :            :                 return -EFAULT;
     624                 :            : 
     625                 :          0 :         if (__ETHTOOL_LINK_MODE_MASK_NU32
     626                 :          0 :             != link_ksettings.base.link_mode_masks_nwords) {
     627                 :            :                 /* wrong link mode nbits requested */
     628                 :          0 :                 memset(&link_ksettings, 0, sizeof(link_ksettings));
     629                 :          0 :                 link_ksettings.base.cmd = ETHTOOL_GLINKSETTINGS;
     630                 :            :                 /* send back number of words required as negative val */
     631                 :            :                 compiletime_assert(__ETHTOOL_LINK_MODE_MASK_NU32 <= S8_MAX,
     632                 :            :                                    "need too many bits for link modes!");
     633                 :            :                 link_ksettings.base.link_mode_masks_nwords
     634                 :          0 :                         = -((s8)__ETHTOOL_LINK_MODE_MASK_NU32);
     635                 :            : 
     636                 :            :                 /* copy the base fields back to user, not the link
     637                 :            :                  * mode bitmaps
     638                 :            :                  */
     639                 :          0 :                 if (copy_to_user(useraddr, &link_ksettings.base,
     640                 :            :                                  sizeof(link_ksettings.base)))
     641                 :            :                         return -EFAULT;
     642                 :            : 
     643                 :          0 :                 return 0;
     644                 :            :         }
     645                 :            : 
     646                 :            :         /* handshake successful: user/kernel agree on
     647                 :            :          * link_mode_masks_nwords
     648                 :            :          */
     649                 :            : 
     650                 :          0 :         memset(&link_ksettings, 0, sizeof(link_ksettings));
     651                 :          0 :         err = dev->ethtool_ops->get_link_ksettings(dev, &link_ksettings);
     652                 :          0 :         if (err < 0)
     653                 :            :                 return err;
     654                 :            : 
     655                 :            :         /* make sure we tell the right values to user */
     656                 :          0 :         link_ksettings.base.cmd = ETHTOOL_GLINKSETTINGS;
     657                 :            :         link_ksettings.base.link_mode_masks_nwords
     658                 :          0 :                 = __ETHTOOL_LINK_MODE_MASK_NU32;
     659                 :            : 
     660                 :          0 :         return store_link_ksettings_for_user(useraddr, &link_ksettings);
     661                 :            : }
     662                 :            : 
     663                 :            : /* Update device ethtool_link_settings. */
     664                 :          0 : static int ethtool_set_link_ksettings(struct net_device *dev,
     665                 :            :                                       void __user *useraddr)
     666                 :            : {
     667                 :            :         int err;
     668                 :            :         struct ethtool_link_ksettings link_ksettings;
     669                 :            : 
     670                 :          0 :         ASSERT_RTNL();
     671                 :            : 
     672                 :          0 :         if (!dev->ethtool_ops->set_link_ksettings)
     673                 :            :                 return -EOPNOTSUPP;
     674                 :            : 
     675                 :            :         /* make sure nbits field has expected value */
     676                 :          0 :         if (copy_from_user(&link_ksettings.base, useraddr,
     677                 :            :                            sizeof(link_ksettings.base)))
     678                 :            :                 return -EFAULT;
     679                 :            : 
     680                 :          0 :         if (__ETHTOOL_LINK_MODE_MASK_NU32
     681                 :          0 :             != link_ksettings.base.link_mode_masks_nwords)
     682                 :            :                 return -EINVAL;
     683                 :            : 
     684                 :            :         /* copy the whole structure, now that we know it has expected
     685                 :            :          * format
     686                 :            :          */
     687                 :          0 :         err = load_link_ksettings_from_user(&link_ksettings, useraddr);
     688                 :          0 :         if (err)
     689                 :            :                 return err;
     690                 :            : 
     691                 :            :         /* re-check nwords field, just in case */
     692                 :          0 :         if (__ETHTOOL_LINK_MODE_MASK_NU32
     693                 :          0 :             != link_ksettings.base.link_mode_masks_nwords)
     694                 :            :                 return -EINVAL;
     695                 :            : 
     696                 :          0 :         return dev->ethtool_ops->set_link_ksettings(dev, &link_ksettings);
     697                 :            : }
     698                 :            : 
     699                 :            : /* Query device for its ethtool_cmd settings.
     700                 :            :  *
     701                 :            :  * Backward compatibility note: for compatibility with legacy ethtool, this is
     702                 :            :  * now implemented via get_link_ksettings. When driver reports higher link mode
     703                 :            :  * bits, a kernel warning is logged once (with name of 1st driver/device) to
     704                 :            :  * recommend user to upgrade ethtool, but the command is successful (only the
     705                 :            :  * lower link mode bits reported back to user). Deprecated fields from
     706                 :            :  * ethtool_cmd (transceiver/maxrxpkt/maxtxpkt) are always set to zero.
     707                 :            :  */
     708                 :          1 : static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
     709                 :            : {
     710                 :            :         struct ethtool_link_ksettings link_ksettings;
     711                 :            :         struct ethtool_cmd cmd;
     712                 :            :         int err;
     713                 :            : 
     714                 :          1 :         ASSERT_RTNL();
     715                 :          1 :         if (!dev->ethtool_ops->get_link_ksettings)
     716                 :            :                 return -EOPNOTSUPP;
     717                 :            : 
     718                 :          1 :         memset(&link_ksettings, 0, sizeof(link_ksettings));
     719                 :          1 :         err = dev->ethtool_ops->get_link_ksettings(dev, &link_ksettings);
     720                 :          1 :         if (err < 0)
     721                 :            :                 return err;
     722                 :          0 :         convert_link_ksettings_to_legacy_settings(&cmd, &link_ksettings);
     723                 :            : 
     724                 :            :         /* send a sensible cmd tag back to user */
     725                 :          0 :         cmd.cmd = ETHTOOL_GSET;
     726                 :            : 
     727                 :          0 :         if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
     728                 :            :                 return -EFAULT;
     729                 :            : 
     730                 :          0 :         return 0;
     731                 :            : }
     732                 :            : 
     733                 :            : /* Update device link settings with given ethtool_cmd.
     734                 :            :  *
     735                 :            :  * Backward compatibility note: for compatibility with legacy ethtool, this is
     736                 :            :  * now always implemented via set_link_settings. When user's request updates
     737                 :            :  * deprecated ethtool_cmd fields (transceiver/maxrxpkt/maxtxpkt), a kernel
     738                 :            :  * warning is logged once (with name of 1st driver/device) to recommend user to
     739                 :            :  * upgrade ethtool, and the request is rejected.
     740                 :            :  */
     741                 :          0 : static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
     742                 :            : {
     743                 :            :         struct ethtool_link_ksettings link_ksettings;
     744                 :            :         struct ethtool_cmd cmd;
     745                 :            : 
     746                 :          0 :         ASSERT_RTNL();
     747                 :            : 
     748                 :          0 :         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
     749                 :            :                 return -EFAULT;
     750                 :          0 :         if (!dev->ethtool_ops->set_link_ksettings)
     751                 :            :                 return -EOPNOTSUPP;
     752                 :            : 
     753                 :          0 :         if (!convert_legacy_settings_to_link_ksettings(&link_ksettings, &cmd))
     754                 :            :                 return -EINVAL;
     755                 :          0 :         link_ksettings.base.link_mode_masks_nwords =
     756                 :            :                 __ETHTOOL_LINK_MODE_MASK_NU32;
     757                 :          0 :         return dev->ethtool_ops->set_link_ksettings(dev, &link_ksettings);
     758                 :            : }
     759                 :            : 
     760                 :          3 : static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
     761                 :            :                                                   void __user *useraddr)
     762                 :            : {
     763                 :            :         struct ethtool_drvinfo info;
     764                 :          3 :         const struct ethtool_ops *ops = dev->ethtool_ops;
     765                 :            : 
     766                 :          3 :         memset(&info, 0, sizeof(info));
     767                 :          3 :         info.cmd = ETHTOOL_GDRVINFO;
     768                 :          3 :         if (ops->get_drvinfo) {
     769                 :          3 :                 ops->get_drvinfo(dev, &info);
     770                 :          3 :         } else if (dev->dev.parent && dev->dev.parent->driver) {
     771                 :          0 :                 strlcpy(info.bus_info, dev_name(dev->dev.parent),
     772                 :            :                         sizeof(info.bus_info));
     773                 :          0 :                 strlcpy(info.driver, dev->dev.parent->driver->name,
     774                 :            :                         sizeof(info.driver));
     775                 :            :         } else {
     776                 :            :                 return -EOPNOTSUPP;
     777                 :            :         }
     778                 :            : 
     779                 :            :         /*
     780                 :            :          * this method of obtaining string set info is deprecated;
     781                 :            :          * Use ETHTOOL_GSSET_INFO instead.
     782                 :            :          */
     783                 :          3 :         if (ops->get_sset_count) {
     784                 :            :                 int rc;
     785                 :            : 
     786                 :          0 :                 rc = ops->get_sset_count(dev, ETH_SS_TEST);
     787                 :          0 :                 if (rc >= 0)
     788                 :          0 :                         info.testinfo_len = rc;
     789                 :          0 :                 rc = ops->get_sset_count(dev, ETH_SS_STATS);
     790                 :          0 :                 if (rc >= 0)
     791                 :          0 :                         info.n_stats = rc;
     792                 :          0 :                 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
     793                 :          0 :                 if (rc >= 0)
     794                 :          0 :                         info.n_priv_flags = rc;
     795                 :            :         }
     796                 :          3 :         if (ops->get_regs_len) {
     797                 :          2 :                 int ret = ops->get_regs_len(dev);
     798                 :            : 
     799                 :          2 :                 if (ret > 0)
     800                 :          2 :                         info.regdump_len = ret;
     801                 :            :         }
     802                 :            : 
     803                 :          3 :         if (ops->get_eeprom_len)
     804                 :          2 :                 info.eedump_len = ops->get_eeprom_len(dev);
     805                 :            : 
     806                 :            :         if (!info.fw_version[0])
     807                 :            :                 devlink_compat_running_version(dev, info.fw_version,
     808                 :            :                                                sizeof(info.fw_version));
     809                 :            : 
     810                 :          3 :         if (copy_to_user(useraddr, &info, sizeof(info)))
     811                 :            :                 return -EFAULT;
     812                 :          3 :         return 0;
     813                 :            : }
     814                 :            : 
     815                 :          0 : static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
     816                 :            :                                                     void __user *useraddr)
     817                 :            : {
     818                 :            :         struct ethtool_sset_info info;
     819                 :            :         u64 sset_mask;
     820                 :            :         int i, idx = 0, n_bits = 0, ret, rc;
     821                 :            :         u32 *info_buf = NULL;
     822                 :            : 
     823                 :          0 :         if (copy_from_user(&info, useraddr, sizeof(info)))
     824                 :            :                 return -EFAULT;
     825                 :            : 
     826                 :            :         /* store copy of mask, because we zero struct later on */
     827                 :          0 :         sset_mask = info.sset_mask;
     828                 :          0 :         if (!sset_mask)
     829                 :            :                 return 0;
     830                 :            : 
     831                 :            :         /* calculate size of return buffer */
     832                 :          0 :         n_bits = hweight64(sset_mask);
     833                 :            : 
     834                 :          0 :         memset(&info, 0, sizeof(info));
     835                 :          0 :         info.cmd = ETHTOOL_GSSET_INFO;
     836                 :            : 
     837                 :          0 :         info_buf = kcalloc(n_bits, sizeof(u32), GFP_USER);
     838                 :          0 :         if (!info_buf)
     839                 :            :                 return -ENOMEM;
     840                 :            : 
     841                 :            :         /*
     842                 :            :          * fill return buffer based on input bitmask and successful
     843                 :            :          * get_sset_count return
     844                 :            :          */
     845                 :          0 :         for (i = 0; i < 64; i++) {
     846                 :          0 :                 if (!(sset_mask & (1ULL << i)))
     847                 :          0 :                         continue;
     848                 :            : 
     849                 :          0 :                 rc = __ethtool_get_sset_count(dev, i);
     850                 :          0 :                 if (rc >= 0) {
     851                 :          0 :                         info.sset_mask |= (1ULL << i);
     852                 :          0 :                         info_buf[idx++] = rc;
     853                 :            :                 }
     854                 :            :         }
     855                 :            : 
     856                 :            :         ret = -EFAULT;
     857                 :          0 :         if (copy_to_user(useraddr, &info, sizeof(info)))
     858                 :            :                 goto out;
     859                 :            : 
     860                 :          0 :         useraddr += offsetof(struct ethtool_sset_info, data);
     861                 :          0 :         if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
     862                 :            :                 goto out;
     863                 :            : 
     864                 :            :         ret = 0;
     865                 :            : 
     866                 :            : out:
     867                 :          0 :         kfree(info_buf);
     868                 :          0 :         return ret;
     869                 :            : }
     870                 :            : 
     871                 :          0 : static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
     872                 :            :                                                 u32 cmd, void __user *useraddr)
     873                 :            : {
     874                 :            :         struct ethtool_rxnfc info;
     875                 :            :         size_t info_size = sizeof(info);
     876                 :            :         int rc;
     877                 :            : 
     878                 :          0 :         if (!dev->ethtool_ops->set_rxnfc)
     879                 :            :                 return -EOPNOTSUPP;
     880                 :            : 
     881                 :            :         /* struct ethtool_rxnfc was originally defined for
     882                 :            :          * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
     883                 :            :          * members.  User-space might still be using that
     884                 :            :          * definition. */
     885                 :          0 :         if (cmd == ETHTOOL_SRXFH)
     886                 :            :                 info_size = (offsetof(struct ethtool_rxnfc, data) +
     887                 :            :                              sizeof(info.data));
     888                 :            : 
     889                 :          0 :         if (copy_from_user(&info, useraddr, info_size))
     890                 :            :                 return -EFAULT;
     891                 :            : 
     892                 :          0 :         rc = dev->ethtool_ops->set_rxnfc(dev, &info);
     893                 :          0 :         if (rc)
     894                 :            :                 return rc;
     895                 :            : 
     896                 :          0 :         if (cmd == ETHTOOL_SRXCLSRLINS &&
     897                 :            :             copy_to_user(useraddr, &info, info_size))
     898                 :            :                 return -EFAULT;
     899                 :            : 
     900                 :            :         return 0;
     901                 :            : }
     902                 :            : 
     903                 :          0 : static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
     904                 :            :                                                 u32 cmd, void __user *useraddr)
     905                 :            : {
     906                 :            :         struct ethtool_rxnfc info;
     907                 :            :         size_t info_size = sizeof(info);
     908                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
     909                 :            :         int ret;
     910                 :            :         void *rule_buf = NULL;
     911                 :            : 
     912                 :          0 :         if (!ops->get_rxnfc)
     913                 :            :                 return -EOPNOTSUPP;
     914                 :            : 
     915                 :            :         /* struct ethtool_rxnfc was originally defined for
     916                 :            :          * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
     917                 :            :          * members.  User-space might still be using that
     918                 :            :          * definition. */
     919                 :          0 :         if (cmd == ETHTOOL_GRXFH)
     920                 :            :                 info_size = (offsetof(struct ethtool_rxnfc, data) +
     921                 :            :                              sizeof(info.data));
     922                 :            : 
     923                 :          0 :         if (copy_from_user(&info, useraddr, info_size))
     924                 :            :                 return -EFAULT;
     925                 :            : 
     926                 :            :         /* If FLOW_RSS was requested then user-space must be using the
     927                 :            :          * new definition, as FLOW_RSS is newer.
     928                 :            :          */
     929                 :          0 :         if (cmd == ETHTOOL_GRXFH && info.flow_type & FLOW_RSS) {
     930                 :            :                 info_size = sizeof(info);
     931                 :          0 :                 if (copy_from_user(&info, useraddr, info_size))
     932                 :            :                         return -EFAULT;
     933                 :            :                 /* Since malicious users may modify the original data,
     934                 :            :                  * we need to check whether FLOW_RSS is still requested.
     935                 :            :                  */
     936                 :          0 :                 if (!(info.flow_type & FLOW_RSS))
     937                 :            :                         return -EINVAL;
     938                 :            :         }
     939                 :            : 
     940                 :          0 :         if (info.cmd != cmd)
     941                 :            :                 return -EINVAL;
     942                 :            : 
     943                 :          0 :         if (info.cmd == ETHTOOL_GRXCLSRLALL) {
     944                 :          0 :                 if (info.rule_cnt > 0) {
     945                 :          0 :                         if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
     946                 :            :                                 rule_buf = kcalloc(info.rule_cnt, sizeof(u32),
     947                 :            :                                                    GFP_USER);
     948                 :          0 :                         if (!rule_buf)
     949                 :            :                                 return -ENOMEM;
     950                 :            :                 }
     951                 :            :         }
     952                 :            : 
     953                 :          0 :         ret = ops->get_rxnfc(dev, &info, rule_buf);
     954                 :          0 :         if (ret < 0)
     955                 :            :                 goto err_out;
     956                 :            : 
     957                 :            :         ret = -EFAULT;
     958                 :          0 :         if (copy_to_user(useraddr, &info, info_size))
     959                 :            :                 goto err_out;
     960                 :            : 
     961                 :          0 :         if (rule_buf) {
     962                 :          0 :                 useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
     963                 :          0 :                 if (copy_to_user(useraddr, rule_buf,
     964                 :          0 :                                  info.rule_cnt * sizeof(u32)))
     965                 :            :                         goto err_out;
     966                 :            :         }
     967                 :            :         ret = 0;
     968                 :            : 
     969                 :            : err_out:
     970                 :          0 :         kfree(rule_buf);
     971                 :            : 
     972                 :          0 :         return ret;
     973                 :            : }
     974                 :            : 
     975                 :          0 : static int ethtool_copy_validate_indir(u32 *indir, void __user *useraddr,
     976                 :            :                                         struct ethtool_rxnfc *rx_rings,
     977                 :            :                                         u32 size)
     978                 :            : {
     979                 :            :         int i;
     980                 :            : 
     981                 :          0 :         if (copy_from_user(indir, useraddr, size * sizeof(indir[0])))
     982                 :            :                 return -EFAULT;
     983                 :            : 
     984                 :            :         /* Validate ring indices */
     985                 :          0 :         for (i = 0; i < size; i++)
     986                 :          0 :                 if (indir[i] >= rx_rings->data)
     987                 :            :                         return -EINVAL;
     988                 :            : 
     989                 :            :         return 0;
     990                 :            : }
     991                 :            : 
     992                 :            : u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
     993                 :            : 
     994                 :          0 : void netdev_rss_key_fill(void *buffer, size_t len)
     995                 :            : {
     996                 :          0 :         BUG_ON(len > sizeof(netdev_rss_key));
     997                 :          0 :         net_get_random_once(netdev_rss_key, sizeof(netdev_rss_key));
     998                 :          0 :         memcpy(buffer, netdev_rss_key, len);
     999                 :          0 : }
    1000                 :            : EXPORT_SYMBOL(netdev_rss_key_fill);
    1001                 :            : 
    1002                 :          0 : static int ethtool_get_max_rxfh_channel(struct net_device *dev, u32 *max)
    1003                 :            : {
    1004                 :            :         u32 dev_size, current_max = 0;
    1005                 :            :         u32 *indir;
    1006                 :            :         int ret;
    1007                 :            : 
    1008                 :          0 :         if (!dev->ethtool_ops->get_rxfh_indir_size ||
    1009                 :          0 :             !dev->ethtool_ops->get_rxfh)
    1010                 :            :                 return -EOPNOTSUPP;
    1011                 :          0 :         dev_size = dev->ethtool_ops->get_rxfh_indir_size(dev);
    1012                 :          0 :         if (dev_size == 0)
    1013                 :            :                 return -EOPNOTSUPP;
    1014                 :            : 
    1015                 :            :         indir = kcalloc(dev_size, sizeof(indir[0]), GFP_USER);
    1016                 :          0 :         if (!indir)
    1017                 :            :                 return -ENOMEM;
    1018                 :            : 
    1019                 :          0 :         ret = dev->ethtool_ops->get_rxfh(dev, indir, NULL, NULL);
    1020                 :          0 :         if (ret)
    1021                 :            :                 goto out;
    1022                 :            : 
    1023                 :          0 :         while (dev_size--)
    1024                 :          0 :                 current_max = max(current_max, indir[dev_size]);
    1025                 :            : 
    1026                 :          0 :         *max = current_max;
    1027                 :            : 
    1028                 :            : out:
    1029                 :          0 :         kfree(indir);
    1030                 :          0 :         return ret;
    1031                 :            : }
    1032                 :            : 
    1033                 :          0 : static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,
    1034                 :            :                                                      void __user *useraddr)
    1035                 :            : {
    1036                 :            :         u32 user_size, dev_size;
    1037                 :            :         u32 *indir;
    1038                 :            :         int ret;
    1039                 :            : 
    1040                 :          0 :         if (!dev->ethtool_ops->get_rxfh_indir_size ||
    1041                 :          0 :             !dev->ethtool_ops->get_rxfh)
    1042                 :            :                 return -EOPNOTSUPP;
    1043                 :          0 :         dev_size = dev->ethtool_ops->get_rxfh_indir_size(dev);
    1044                 :          0 :         if (dev_size == 0)
    1045                 :            :                 return -EOPNOTSUPP;
    1046                 :            : 
    1047                 :          0 :         if (copy_from_user(&user_size,
    1048                 :            :                            useraddr + offsetof(struct ethtool_rxfh_indir, size),
    1049                 :            :                            sizeof(user_size)))
    1050                 :            :                 return -EFAULT;
    1051                 :            : 
    1052                 :          0 :         if (copy_to_user(useraddr + offsetof(struct ethtool_rxfh_indir, size),
    1053                 :            :                          &dev_size, sizeof(dev_size)))
    1054                 :            :                 return -EFAULT;
    1055                 :            : 
    1056                 :            :         /* If the user buffer size is 0, this is just a query for the
    1057                 :            :          * device table size.  Otherwise, if it's smaller than the
    1058                 :            :          * device table size it's an error.
    1059                 :            :          */
    1060                 :          0 :         if (user_size < dev_size)
    1061                 :          0 :                 return user_size == 0 ? 0 : -EINVAL;
    1062                 :            : 
    1063                 :            :         indir = kcalloc(dev_size, sizeof(indir[0]), GFP_USER);
    1064                 :          0 :         if (!indir)
    1065                 :            :                 return -ENOMEM;
    1066                 :            : 
    1067                 :          0 :         ret = dev->ethtool_ops->get_rxfh(dev, indir, NULL, NULL);
    1068                 :          0 :         if (ret)
    1069                 :            :                 goto out;
    1070                 :            : 
    1071                 :          0 :         if (copy_to_user(useraddr +
    1072                 :            :                          offsetof(struct ethtool_rxfh_indir, ring_index[0]),
    1073                 :          0 :                          indir, dev_size * sizeof(indir[0])))
    1074                 :            :                 ret = -EFAULT;
    1075                 :            : 
    1076                 :            : out:
    1077                 :          0 :         kfree(indir);
    1078                 :          0 :         return ret;
    1079                 :            : }
    1080                 :            : 
    1081                 :          0 : static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,
    1082                 :            :                                                      void __user *useraddr)
    1083                 :            : {
    1084                 :            :         struct ethtool_rxnfc rx_rings;
    1085                 :            :         u32 user_size, dev_size, i;
    1086                 :            :         u32 *indir;
    1087                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1088                 :            :         int ret;
    1089                 :            :         u32 ringidx_offset = offsetof(struct ethtool_rxfh_indir, ring_index[0]);
    1090                 :            : 
    1091                 :          0 :         if (!ops->get_rxfh_indir_size || !ops->set_rxfh ||
    1092                 :          0 :             !ops->get_rxnfc)
    1093                 :            :                 return -EOPNOTSUPP;
    1094                 :            : 
    1095                 :          0 :         dev_size = ops->get_rxfh_indir_size(dev);
    1096                 :          0 :         if (dev_size == 0)
    1097                 :            :                 return -EOPNOTSUPP;
    1098                 :            : 
    1099                 :          0 :         if (copy_from_user(&user_size,
    1100                 :            :                            useraddr + offsetof(struct ethtool_rxfh_indir, size),
    1101                 :            :                            sizeof(user_size)))
    1102                 :            :                 return -EFAULT;
    1103                 :            : 
    1104                 :          0 :         if (user_size != 0 && user_size != dev_size)
    1105                 :            :                 return -EINVAL;
    1106                 :            : 
    1107                 :            :         indir = kcalloc(dev_size, sizeof(indir[0]), GFP_USER);
    1108                 :          0 :         if (!indir)
    1109                 :            :                 return -ENOMEM;
    1110                 :            : 
    1111                 :          0 :         rx_rings.cmd = ETHTOOL_GRXRINGS;
    1112                 :          0 :         ret = ops->get_rxnfc(dev, &rx_rings, NULL);
    1113                 :          0 :         if (ret)
    1114                 :            :                 goto out;
    1115                 :            : 
    1116                 :          0 :         if (user_size == 0) {
    1117                 :          0 :                 for (i = 0; i < dev_size; i++)
    1118                 :          0 :                         indir[i] = ethtool_rxfh_indir_default(i, rx_rings.data);
    1119                 :            :         } else {
    1120                 :          0 :                 ret = ethtool_copy_validate_indir(indir,
    1121                 :            :                                                   useraddr + ringidx_offset,
    1122                 :            :                                                   &rx_rings,
    1123                 :            :                                                   dev_size);
    1124                 :          0 :                 if (ret)
    1125                 :            :                         goto out;
    1126                 :            :         }
    1127                 :            : 
    1128                 :          0 :         ret = ops->set_rxfh(dev, indir, NULL, ETH_RSS_HASH_NO_CHANGE);
    1129                 :          0 :         if (ret)
    1130                 :            :                 goto out;
    1131                 :            : 
    1132                 :            :         /* indicate whether rxfh was set to default */
    1133                 :          0 :         if (user_size == 0)
    1134                 :          0 :                 dev->priv_flags &= ~IFF_RXFH_CONFIGURED;
    1135                 :            :         else
    1136                 :          0 :                 dev->priv_flags |= IFF_RXFH_CONFIGURED;
    1137                 :            : 
    1138                 :            : out:
    1139                 :          0 :         kfree(indir);
    1140                 :          0 :         return ret;
    1141                 :            : }
    1142                 :            : 
    1143                 :          0 : static noinline_for_stack int ethtool_get_rxfh(struct net_device *dev,
    1144                 :            :                                                void __user *useraddr)
    1145                 :            : {
    1146                 :            :         int ret;
    1147                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1148                 :            :         u32 user_indir_size, user_key_size;
    1149                 :            :         u32 dev_indir_size = 0, dev_key_size = 0;
    1150                 :            :         struct ethtool_rxfh rxfh;
    1151                 :            :         u32 total_size;
    1152                 :            :         u32 indir_bytes;
    1153                 :            :         u32 *indir = NULL;
    1154                 :          0 :         u8 dev_hfunc = 0;
    1155                 :            :         u8 *hkey = NULL;
    1156                 :            :         u8 *rss_config;
    1157                 :            : 
    1158                 :          0 :         if (!ops->get_rxfh)
    1159                 :            :                 return -EOPNOTSUPP;
    1160                 :            : 
    1161                 :          0 :         if (ops->get_rxfh_indir_size)
    1162                 :          0 :                 dev_indir_size = ops->get_rxfh_indir_size(dev);
    1163                 :          0 :         if (ops->get_rxfh_key_size)
    1164                 :          0 :                 dev_key_size = ops->get_rxfh_key_size(dev);
    1165                 :            : 
    1166                 :          0 :         if (copy_from_user(&rxfh, useraddr, sizeof(rxfh)))
    1167                 :            :                 return -EFAULT;
    1168                 :          0 :         user_indir_size = rxfh.indir_size;
    1169                 :          0 :         user_key_size = rxfh.key_size;
    1170                 :            : 
    1171                 :            :         /* Check that reserved fields are 0 for now */
    1172                 :          0 :         if (rxfh.rsvd8[0] || rxfh.rsvd8[1] || rxfh.rsvd8[2] || rxfh.rsvd32)
    1173                 :            :                 return -EINVAL;
    1174                 :            :         /* Most drivers don't handle rss_context, check it's 0 as well */
    1175                 :          0 :         if (rxfh.rss_context && !ops->get_rxfh_context)
    1176                 :            :                 return -EOPNOTSUPP;
    1177                 :            : 
    1178                 :          0 :         rxfh.indir_size = dev_indir_size;
    1179                 :          0 :         rxfh.key_size = dev_key_size;
    1180                 :          0 :         if (copy_to_user(useraddr, &rxfh, sizeof(rxfh)))
    1181                 :            :                 return -EFAULT;
    1182                 :            : 
    1183                 :          0 :         if ((user_indir_size && (user_indir_size != dev_indir_size)) ||
    1184                 :          0 :             (user_key_size && (user_key_size != dev_key_size)))
    1185                 :            :                 return -EINVAL;
    1186                 :            : 
    1187                 :          0 :         indir_bytes = user_indir_size * sizeof(indir[0]);
    1188                 :          0 :         total_size = indir_bytes + user_key_size;
    1189                 :          0 :         rss_config = kzalloc(total_size, GFP_USER);
    1190                 :          0 :         if (!rss_config)
    1191                 :            :                 return -ENOMEM;
    1192                 :            : 
    1193                 :          0 :         if (user_indir_size)
    1194                 :            :                 indir = (u32 *)rss_config;
    1195                 :            : 
    1196                 :          0 :         if (user_key_size)
    1197                 :          0 :                 hkey = rss_config + indir_bytes;
    1198                 :            : 
    1199                 :          0 :         if (rxfh.rss_context)
    1200                 :          0 :                 ret = dev->ethtool_ops->get_rxfh_context(dev, indir, hkey,
    1201                 :            :                                                          &dev_hfunc,
    1202                 :            :                                                          rxfh.rss_context);
    1203                 :            :         else
    1204                 :          0 :                 ret = dev->ethtool_ops->get_rxfh(dev, indir, hkey, &dev_hfunc);
    1205                 :          0 :         if (ret)
    1206                 :            :                 goto out;
    1207                 :            : 
    1208                 :          0 :         if (copy_to_user(useraddr + offsetof(struct ethtool_rxfh, hfunc),
    1209                 :            :                          &dev_hfunc, sizeof(rxfh.hfunc))) {
    1210                 :            :                 ret = -EFAULT;
    1211                 :          0 :         } else if (copy_to_user(useraddr +
    1212                 :            :                               offsetof(struct ethtool_rxfh, rss_config[0]),
    1213                 :            :                               rss_config, total_size)) {
    1214                 :            :                 ret = -EFAULT;
    1215                 :            :         }
    1216                 :            : out:
    1217                 :          0 :         kfree(rss_config);
    1218                 :            : 
    1219                 :          0 :         return ret;
    1220                 :            : }
    1221                 :            : 
    1222                 :          0 : static noinline_for_stack int ethtool_set_rxfh(struct net_device *dev,
    1223                 :            :                                                void __user *useraddr)
    1224                 :            : {
    1225                 :            :         int ret;
    1226                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1227                 :            :         struct ethtool_rxnfc rx_rings;
    1228                 :            :         struct ethtool_rxfh rxfh;
    1229                 :            :         u32 dev_indir_size = 0, dev_key_size = 0, i;
    1230                 :            :         u32 *indir = NULL, indir_bytes = 0;
    1231                 :            :         u8 *hkey = NULL;
    1232                 :            :         u8 *rss_config;
    1233                 :            :         u32 rss_cfg_offset = offsetof(struct ethtool_rxfh, rss_config[0]);
    1234                 :            :         bool delete = false;
    1235                 :            : 
    1236                 :          0 :         if (!ops->get_rxnfc || !ops->set_rxfh)
    1237                 :            :                 return -EOPNOTSUPP;
    1238                 :            : 
    1239                 :          0 :         if (ops->get_rxfh_indir_size)
    1240                 :          0 :                 dev_indir_size = ops->get_rxfh_indir_size(dev);
    1241                 :          0 :         if (ops->get_rxfh_key_size)
    1242                 :          0 :                 dev_key_size = ops->get_rxfh_key_size(dev);
    1243                 :            : 
    1244                 :          0 :         if (copy_from_user(&rxfh, useraddr, sizeof(rxfh)))
    1245                 :            :                 return -EFAULT;
    1246                 :            : 
    1247                 :            :         /* Check that reserved fields are 0 for now */
    1248                 :          0 :         if (rxfh.rsvd8[0] || rxfh.rsvd8[1] || rxfh.rsvd8[2] || rxfh.rsvd32)
    1249                 :            :                 return -EINVAL;
    1250                 :            :         /* Most drivers don't handle rss_context, check it's 0 as well */
    1251                 :          0 :         if (rxfh.rss_context && !ops->set_rxfh_context)
    1252                 :            :                 return -EOPNOTSUPP;
    1253                 :            : 
    1254                 :            :         /* If either indir, hash key or function is valid, proceed further.
    1255                 :            :          * Must request at least one change: indir size, hash key or function.
    1256                 :            :          */
    1257                 :          0 :         if ((rxfh.indir_size &&
    1258                 :          0 :              rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE &&
    1259                 :          0 :              rxfh.indir_size != dev_indir_size) ||
    1260                 :          0 :             (rxfh.key_size && (rxfh.key_size != dev_key_size)) ||
    1261                 :          0 :             (rxfh.indir_size == ETH_RXFH_INDIR_NO_CHANGE &&
    1262                 :          0 :              rxfh.key_size == 0 && rxfh.hfunc == ETH_RSS_HASH_NO_CHANGE))
    1263                 :            :                 return -EINVAL;
    1264                 :            : 
    1265                 :          0 :         if (rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE)
    1266                 :          0 :                 indir_bytes = dev_indir_size * sizeof(indir[0]);
    1267                 :            : 
    1268                 :          0 :         rss_config = kzalloc(indir_bytes + rxfh.key_size, GFP_USER);
    1269                 :          0 :         if (!rss_config)
    1270                 :            :                 return -ENOMEM;
    1271                 :            : 
    1272                 :          0 :         rx_rings.cmd = ETHTOOL_GRXRINGS;
    1273                 :          0 :         ret = ops->get_rxnfc(dev, &rx_rings, NULL);
    1274                 :          0 :         if (ret)
    1275                 :            :                 goto out;
    1276                 :            : 
    1277                 :            :         /* rxfh.indir_size == 0 means reset the indir table to default (master
    1278                 :            :          * context) or delete the context (other RSS contexts).
    1279                 :            :          * rxfh.indir_size == ETH_RXFH_INDIR_NO_CHANGE means leave it unchanged.
    1280                 :            :          */
    1281                 :          0 :         if (rxfh.indir_size &&
    1282                 :            :             rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE) {
    1283                 :            :                 indir = (u32 *)rss_config;
    1284                 :          0 :                 ret = ethtool_copy_validate_indir(indir,
    1285                 :            :                                                   useraddr + rss_cfg_offset,
    1286                 :            :                                                   &rx_rings,
    1287                 :            :                                                   rxfh.indir_size);
    1288                 :          0 :                 if (ret)
    1289                 :            :                         goto out;
    1290                 :          0 :         } else if (rxfh.indir_size == 0) {
    1291                 :          0 :                 if (rxfh.rss_context == 0) {
    1292                 :            :                         indir = (u32 *)rss_config;
    1293                 :          0 :                         for (i = 0; i < dev_indir_size; i++)
    1294                 :          0 :                                 indir[i] = ethtool_rxfh_indir_default(i, rx_rings.data);
    1295                 :            :                 } else {
    1296                 :            :                         delete = true;
    1297                 :            :                 }
    1298                 :            :         }
    1299                 :            : 
    1300                 :          0 :         if (rxfh.key_size) {
    1301                 :          0 :                 hkey = rss_config + indir_bytes;
    1302                 :          0 :                 if (copy_from_user(hkey,
    1303                 :          0 :                                    useraddr + rss_cfg_offset + indir_bytes,
    1304                 :            :                                    rxfh.key_size)) {
    1305                 :            :                         ret = -EFAULT;
    1306                 :            :                         goto out;
    1307                 :            :                 }
    1308                 :            :         }
    1309                 :            : 
    1310                 :          0 :         if (rxfh.rss_context)
    1311                 :          0 :                 ret = ops->set_rxfh_context(dev, indir, hkey, rxfh.hfunc,
    1312                 :            :                                             &rxfh.rss_context, delete);
    1313                 :            :         else
    1314                 :          0 :                 ret = ops->set_rxfh(dev, indir, hkey, rxfh.hfunc);
    1315                 :          0 :         if (ret)
    1316                 :            :                 goto out;
    1317                 :            : 
    1318                 :          0 :         if (copy_to_user(useraddr + offsetof(struct ethtool_rxfh, rss_context),
    1319                 :            :                          &rxfh.rss_context, sizeof(rxfh.rss_context)))
    1320                 :            :                 ret = -EFAULT;
    1321                 :            : 
    1322                 :          0 :         if (!rxfh.rss_context) {
    1323                 :            :                 /* indicate whether rxfh was set to default */
    1324                 :          0 :                 if (rxfh.indir_size == 0)
    1325                 :          0 :                         dev->priv_flags &= ~IFF_RXFH_CONFIGURED;
    1326                 :          0 :                 else if (rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE)
    1327                 :          0 :                         dev->priv_flags |= IFF_RXFH_CONFIGURED;
    1328                 :            :         }
    1329                 :            : 
    1330                 :            : out:
    1331                 :          0 :         kfree(rss_config);
    1332                 :          0 :         return ret;
    1333                 :            : }
    1334                 :            : 
    1335                 :          0 : static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
    1336                 :            : {
    1337                 :            :         struct ethtool_regs regs;
    1338                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1339                 :            :         void *regbuf;
    1340                 :            :         int reglen, ret;
    1341                 :            : 
    1342                 :          0 :         if (!ops->get_regs || !ops->get_regs_len)
    1343                 :            :                 return -EOPNOTSUPP;
    1344                 :            : 
    1345                 :          0 :         if (copy_from_user(&regs, useraddr, sizeof(regs)))
    1346                 :            :                 return -EFAULT;
    1347                 :            : 
    1348                 :          0 :         reglen = ops->get_regs_len(dev);
    1349                 :          0 :         if (reglen <= 0)
    1350                 :            :                 return reglen;
    1351                 :            : 
    1352                 :          0 :         if (regs.len > reglen)
    1353                 :          0 :                 regs.len = reglen;
    1354                 :            : 
    1355                 :          0 :         regbuf = vzalloc(reglen);
    1356                 :          0 :         if (!regbuf)
    1357                 :            :                 return -ENOMEM;
    1358                 :            : 
    1359                 :          0 :         if (regs.len < reglen)
    1360                 :          0 :                 reglen = regs.len;
    1361                 :            : 
    1362                 :          0 :         ops->get_regs(dev, &regs, regbuf);
    1363                 :            : 
    1364                 :            :         ret = -EFAULT;
    1365                 :          0 :         if (copy_to_user(useraddr, &regs, sizeof(regs)))
    1366                 :            :                 goto out;
    1367                 :          0 :         useraddr += offsetof(struct ethtool_regs, data);
    1368                 :          0 :         if (copy_to_user(useraddr, regbuf, reglen))
    1369                 :            :                 goto out;
    1370                 :            :         ret = 0;
    1371                 :            : 
    1372                 :            :  out:
    1373                 :          0 :         vfree(regbuf);
    1374                 :          0 :         return ret;
    1375                 :            : }
    1376                 :            : 
    1377                 :          0 : static int ethtool_reset(struct net_device *dev, char __user *useraddr)
    1378                 :            : {
    1379                 :            :         struct ethtool_value reset;
    1380                 :            :         int ret;
    1381                 :            : 
    1382                 :          0 :         if (!dev->ethtool_ops->reset)
    1383                 :            :                 return -EOPNOTSUPP;
    1384                 :            : 
    1385                 :          0 :         if (copy_from_user(&reset, useraddr, sizeof(reset)))
    1386                 :            :                 return -EFAULT;
    1387                 :            : 
    1388                 :          0 :         ret = dev->ethtool_ops->reset(dev, &reset.data);
    1389                 :          0 :         if (ret)
    1390                 :            :                 return ret;
    1391                 :            : 
    1392                 :          0 :         if (copy_to_user(useraddr, &reset, sizeof(reset)))
    1393                 :            :                 return -EFAULT;
    1394                 :          0 :         return 0;
    1395                 :            : }
    1396                 :            : 
    1397                 :          0 : static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
    1398                 :            : {
    1399                 :            :         struct ethtool_wolinfo wol;
    1400                 :            : 
    1401                 :          0 :         if (!dev->ethtool_ops->get_wol)
    1402                 :            :                 return -EOPNOTSUPP;
    1403                 :            : 
    1404                 :          0 :         memset(&wol, 0, sizeof(struct ethtool_wolinfo));
    1405                 :          0 :         wol.cmd = ETHTOOL_GWOL;
    1406                 :          0 :         dev->ethtool_ops->get_wol(dev, &wol);
    1407                 :            : 
    1408                 :          0 :         if (copy_to_user(useraddr, &wol, sizeof(wol)))
    1409                 :            :                 return -EFAULT;
    1410                 :          0 :         return 0;
    1411                 :            : }
    1412                 :            : 
    1413                 :          0 : static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
    1414                 :            : {
    1415                 :            :         struct ethtool_wolinfo wol;
    1416                 :            :         int ret;
    1417                 :            : 
    1418                 :          0 :         if (!dev->ethtool_ops->set_wol)
    1419                 :            :                 return -EOPNOTSUPP;
    1420                 :            : 
    1421                 :          0 :         if (copy_from_user(&wol, useraddr, sizeof(wol)))
    1422                 :            :                 return -EFAULT;
    1423                 :            : 
    1424                 :          0 :         ret = dev->ethtool_ops->set_wol(dev, &wol);
    1425                 :          0 :         if (ret)
    1426                 :            :                 return ret;
    1427                 :            : 
    1428                 :          0 :         dev->wol_enabled = !!wol.wolopts;
    1429                 :            : 
    1430                 :          0 :         return 0;
    1431                 :            : }
    1432                 :            : 
    1433                 :          0 : static int ethtool_get_eee(struct net_device *dev, char __user *useraddr)
    1434                 :            : {
    1435                 :            :         struct ethtool_eee edata;
    1436                 :            :         int rc;
    1437                 :            : 
    1438                 :          0 :         if (!dev->ethtool_ops->get_eee)
    1439                 :            :                 return -EOPNOTSUPP;
    1440                 :            : 
    1441                 :          0 :         memset(&edata, 0, sizeof(struct ethtool_eee));
    1442                 :          0 :         edata.cmd = ETHTOOL_GEEE;
    1443                 :          0 :         rc = dev->ethtool_ops->get_eee(dev, &edata);
    1444                 :            : 
    1445                 :          0 :         if (rc)
    1446                 :            :                 return rc;
    1447                 :            : 
    1448                 :          0 :         if (copy_to_user(useraddr, &edata, sizeof(edata)))
    1449                 :            :                 return -EFAULT;
    1450                 :            : 
    1451                 :          0 :         return 0;
    1452                 :            : }
    1453                 :            : 
    1454                 :          0 : static int ethtool_set_eee(struct net_device *dev, char __user *useraddr)
    1455                 :            : {
    1456                 :            :         struct ethtool_eee edata;
    1457                 :            : 
    1458                 :          0 :         if (!dev->ethtool_ops->set_eee)
    1459                 :            :                 return -EOPNOTSUPP;
    1460                 :            : 
    1461                 :          0 :         if (copy_from_user(&edata, useraddr, sizeof(edata)))
    1462                 :            :                 return -EFAULT;
    1463                 :            : 
    1464                 :          0 :         return dev->ethtool_ops->set_eee(dev, &edata);
    1465                 :            : }
    1466                 :            : 
    1467                 :            : static int ethtool_nway_reset(struct net_device *dev)
    1468                 :            : {
    1469                 :          0 :         if (!dev->ethtool_ops->nway_reset)
    1470                 :            :                 return -EOPNOTSUPP;
    1471                 :            : 
    1472                 :          0 :         return dev->ethtool_ops->nway_reset(dev);
    1473                 :            : }
    1474                 :            : 
    1475                 :          0 : static int ethtool_get_link(struct net_device *dev, char __user *useraddr)
    1476                 :            : {
    1477                 :          0 :         struct ethtool_value edata = { .cmd = ETHTOOL_GLINK };
    1478                 :            : 
    1479                 :          0 :         if (!dev->ethtool_ops->get_link)
    1480                 :            :                 return -EOPNOTSUPP;
    1481                 :            : 
    1482                 :          0 :         edata.data = netif_running(dev) && dev->ethtool_ops->get_link(dev);
    1483                 :            : 
    1484                 :          0 :         if (copy_to_user(useraddr, &edata, sizeof(edata)))
    1485                 :            :                 return -EFAULT;
    1486                 :          0 :         return 0;
    1487                 :            : }
    1488                 :            : 
    1489                 :          0 : static int ethtool_get_any_eeprom(struct net_device *dev, void __user *useraddr,
    1490                 :            :                                   int (*getter)(struct net_device *,
    1491                 :            :                                                 struct ethtool_eeprom *, u8 *),
    1492                 :            :                                   u32 total_len)
    1493                 :            : {
    1494                 :            :         struct ethtool_eeprom eeprom;
    1495                 :          0 :         void __user *userbuf = useraddr + sizeof(eeprom);
    1496                 :            :         u32 bytes_remaining;
    1497                 :            :         u8 *data;
    1498                 :            :         int ret = 0;
    1499                 :            : 
    1500                 :          0 :         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
    1501                 :            :                 return -EFAULT;
    1502                 :            : 
    1503                 :            :         /* Check for wrap and zero */
    1504                 :          0 :         if (eeprom.offset + eeprom.len <= eeprom.offset)
    1505                 :            :                 return -EINVAL;
    1506                 :            : 
    1507                 :            :         /* Check for exceeding total eeprom len */
    1508                 :          0 :         if (eeprom.offset + eeprom.len > total_len)
    1509                 :            :                 return -EINVAL;
    1510                 :            : 
    1511                 :            :         data = kmalloc(PAGE_SIZE, GFP_USER);
    1512                 :          0 :         if (!data)
    1513                 :            :                 return -ENOMEM;
    1514                 :            : 
    1515                 :          0 :         bytes_remaining = eeprom.len;
    1516                 :          0 :         while (bytes_remaining > 0) {
    1517                 :          0 :                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
    1518                 :            : 
    1519                 :          0 :                 ret = getter(dev, &eeprom, data);
    1520                 :          0 :                 if (ret)
    1521                 :            :                         break;
    1522                 :          0 :                 if (copy_to_user(userbuf, data, eeprom.len)) {
    1523                 :            :                         ret = -EFAULT;
    1524                 :            :                         break;
    1525                 :            :                 }
    1526                 :          0 :                 userbuf += eeprom.len;
    1527                 :          0 :                 eeprom.offset += eeprom.len;
    1528                 :          0 :                 bytes_remaining -= eeprom.len;
    1529                 :            :         }
    1530                 :            : 
    1531                 :          0 :         eeprom.len = userbuf - (useraddr + sizeof(eeprom));
    1532                 :          0 :         eeprom.offset -= eeprom.len;
    1533                 :          0 :         if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
    1534                 :            :                 ret = -EFAULT;
    1535                 :            : 
    1536                 :          0 :         kfree(data);
    1537                 :          0 :         return ret;
    1538                 :            : }
    1539                 :            : 
    1540                 :          0 : static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
    1541                 :            : {
    1542                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1543                 :            : 
    1544                 :          0 :         if (!ops->get_eeprom || !ops->get_eeprom_len ||
    1545                 :          0 :             !ops->get_eeprom_len(dev))
    1546                 :            :                 return -EOPNOTSUPP;
    1547                 :            : 
    1548                 :          0 :         return ethtool_get_any_eeprom(dev, useraddr, ops->get_eeprom,
    1549                 :          0 :                                       ops->get_eeprom_len(dev));
    1550                 :            : }
    1551                 :            : 
    1552                 :          0 : static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
    1553                 :            : {
    1554                 :            :         struct ethtool_eeprom eeprom;
    1555                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1556                 :          0 :         void __user *userbuf = useraddr + sizeof(eeprom);
    1557                 :            :         u32 bytes_remaining;
    1558                 :            :         u8 *data;
    1559                 :            :         int ret = 0;
    1560                 :            : 
    1561                 :          0 :         if (!ops->set_eeprom || !ops->get_eeprom_len ||
    1562                 :          0 :             !ops->get_eeprom_len(dev))
    1563                 :            :                 return -EOPNOTSUPP;
    1564                 :            : 
    1565                 :          0 :         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
    1566                 :            :                 return -EFAULT;
    1567                 :            : 
    1568                 :            :         /* Check for wrap and zero */
    1569                 :          0 :         if (eeprom.offset + eeprom.len <= eeprom.offset)
    1570                 :            :                 return -EINVAL;
    1571                 :            : 
    1572                 :            :         /* Check for exceeding total eeprom len */
    1573                 :          0 :         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
    1574                 :            :                 return -EINVAL;
    1575                 :            : 
    1576                 :            :         data = kmalloc(PAGE_SIZE, GFP_USER);
    1577                 :          0 :         if (!data)
    1578                 :            :                 return -ENOMEM;
    1579                 :            : 
    1580                 :          0 :         bytes_remaining = eeprom.len;
    1581                 :          0 :         while (bytes_remaining > 0) {
    1582                 :          0 :                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
    1583                 :            : 
    1584                 :          0 :                 if (copy_from_user(data, userbuf, eeprom.len)) {
    1585                 :            :                         ret = -EFAULT;
    1586                 :            :                         break;
    1587                 :            :                 }
    1588                 :          0 :                 ret = ops->set_eeprom(dev, &eeprom, data);
    1589                 :          0 :                 if (ret)
    1590                 :            :                         break;
    1591                 :          0 :                 userbuf += eeprom.len;
    1592                 :          0 :                 eeprom.offset += eeprom.len;
    1593                 :          0 :                 bytes_remaining -= eeprom.len;
    1594                 :            :         }
    1595                 :            : 
    1596                 :          0 :         kfree(data);
    1597                 :          0 :         return ret;
    1598                 :            : }
    1599                 :            : 
    1600                 :          0 : static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
    1601                 :            :                                                    void __user *useraddr)
    1602                 :            : {
    1603                 :          0 :         struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
    1604                 :            : 
    1605                 :          0 :         if (!dev->ethtool_ops->get_coalesce)
    1606                 :            :                 return -EOPNOTSUPP;
    1607                 :            : 
    1608                 :          0 :         dev->ethtool_ops->get_coalesce(dev, &coalesce);
    1609                 :            : 
    1610                 :          0 :         if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
    1611                 :            :                 return -EFAULT;
    1612                 :          0 :         return 0;
    1613                 :            : }
    1614                 :            : 
    1615                 :          0 : static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
    1616                 :            :                                                    void __user *useraddr)
    1617                 :            : {
    1618                 :            :         struct ethtool_coalesce coalesce;
    1619                 :            : 
    1620                 :          0 :         if (!dev->ethtool_ops->set_coalesce)
    1621                 :            :                 return -EOPNOTSUPP;
    1622                 :            : 
    1623                 :          0 :         if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
    1624                 :            :                 return -EFAULT;
    1625                 :            : 
    1626                 :          0 :         return dev->ethtool_ops->set_coalesce(dev, &coalesce);
    1627                 :            : }
    1628                 :            : 
    1629                 :          0 : static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
    1630                 :            : {
    1631                 :          0 :         struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
    1632                 :            : 
    1633                 :          0 :         if (!dev->ethtool_ops->get_ringparam)
    1634                 :            :                 return -EOPNOTSUPP;
    1635                 :            : 
    1636                 :          0 :         dev->ethtool_ops->get_ringparam(dev, &ringparam);
    1637                 :            : 
    1638                 :          0 :         if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
    1639                 :            :                 return -EFAULT;
    1640                 :          0 :         return 0;
    1641                 :            : }
    1642                 :            : 
    1643                 :          0 : static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
    1644                 :            : {
    1645                 :          0 :         struct ethtool_ringparam ringparam, max = { .cmd = ETHTOOL_GRINGPARAM };
    1646                 :            : 
    1647                 :          0 :         if (!dev->ethtool_ops->set_ringparam || !dev->ethtool_ops->get_ringparam)
    1648                 :            :                 return -EOPNOTSUPP;
    1649                 :            : 
    1650                 :          0 :         if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
    1651                 :            :                 return -EFAULT;
    1652                 :            : 
    1653                 :          0 :         dev->ethtool_ops->get_ringparam(dev, &max);
    1654                 :            : 
    1655                 :            :         /* ensure new ring parameters are within the maximums */
    1656                 :          0 :         if (ringparam.rx_pending > max.rx_max_pending ||
    1657                 :          0 :             ringparam.rx_mini_pending > max.rx_mini_max_pending ||
    1658                 :          0 :             ringparam.rx_jumbo_pending > max.rx_jumbo_max_pending ||
    1659                 :          0 :             ringparam.tx_pending > max.tx_max_pending)
    1660                 :            :                 return -EINVAL;
    1661                 :            : 
    1662                 :          0 :         return dev->ethtool_ops->set_ringparam(dev, &ringparam);
    1663                 :            : }
    1664                 :            : 
    1665                 :          0 : static noinline_for_stack int ethtool_get_channels(struct net_device *dev,
    1666                 :            :                                                    void __user *useraddr)
    1667                 :            : {
    1668                 :          0 :         struct ethtool_channels channels = { .cmd = ETHTOOL_GCHANNELS };
    1669                 :            : 
    1670                 :          0 :         if (!dev->ethtool_ops->get_channels)
    1671                 :            :                 return -EOPNOTSUPP;
    1672                 :            : 
    1673                 :          0 :         dev->ethtool_ops->get_channels(dev, &channels);
    1674                 :            : 
    1675                 :          0 :         if (copy_to_user(useraddr, &channels, sizeof(channels)))
    1676                 :            :                 return -EFAULT;
    1677                 :          0 :         return 0;
    1678                 :            : }
    1679                 :            : 
    1680                 :          0 : static noinline_for_stack int ethtool_set_channels(struct net_device *dev,
    1681                 :            :                                                    void __user *useraddr)
    1682                 :            : {
    1683                 :          0 :         struct ethtool_channels channels, curr = { .cmd = ETHTOOL_GCHANNELS };
    1684                 :            :         u16 from_channel, to_channel;
    1685                 :          0 :         u32 max_rx_in_use = 0;
    1686                 :            :         unsigned int i;
    1687                 :            : 
    1688                 :          0 :         if (!dev->ethtool_ops->set_channels || !dev->ethtool_ops->get_channels)
    1689                 :            :                 return -EOPNOTSUPP;
    1690                 :            : 
    1691                 :          0 :         if (copy_from_user(&channels, useraddr, sizeof(channels)))
    1692                 :            :                 return -EFAULT;
    1693                 :            : 
    1694                 :          0 :         dev->ethtool_ops->get_channels(dev, &curr);
    1695                 :            : 
    1696                 :            :         /* ensure new counts are within the maximums */
    1697                 :          0 :         if (channels.rx_count > curr.max_rx ||
    1698                 :          0 :             channels.tx_count > curr.max_tx ||
    1699                 :          0 :             channels.combined_count > curr.max_combined ||
    1700                 :          0 :             channels.other_count > curr.max_other)
    1701                 :            :                 return -EINVAL;
    1702                 :            : 
    1703                 :            :         /* ensure the new Rx count fits within the configured Rx flow
    1704                 :            :          * indirection table settings */
    1705                 :          0 :         if (netif_is_rxfh_configured(dev) &&
    1706                 :          0 :             !ethtool_get_max_rxfh_channel(dev, &max_rx_in_use) &&
    1707                 :          0 :             (channels.combined_count + channels.rx_count) <= max_rx_in_use)
    1708                 :            :             return -EINVAL;
    1709                 :            : 
    1710                 :            :         /* Disabling channels, query zero-copy AF_XDP sockets */
    1711                 :            :         from_channel = channels.combined_count +
    1712                 :            :                 min(channels.rx_count, channels.tx_count);
    1713                 :            :         to_channel = curr.combined_count + max(curr.rx_count, curr.tx_count);
    1714                 :            :         for (i = from_channel; i < to_channel; i++)
    1715                 :            :                 if (xdp_get_umem_from_qid(dev, i))
    1716                 :            :                         return -EINVAL;
    1717                 :            : 
    1718                 :          0 :         return dev->ethtool_ops->set_channels(dev, &channels);
    1719                 :            : }
    1720                 :            : 
    1721                 :          0 : static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
    1722                 :            : {
    1723                 :          0 :         struct ethtool_pauseparam pauseparam = { .cmd = ETHTOOL_GPAUSEPARAM };
    1724                 :            : 
    1725                 :          0 :         if (!dev->ethtool_ops->get_pauseparam)
    1726                 :            :                 return -EOPNOTSUPP;
    1727                 :            : 
    1728                 :          0 :         dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
    1729                 :            : 
    1730                 :          0 :         if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
    1731                 :            :                 return -EFAULT;
    1732                 :          0 :         return 0;
    1733                 :            : }
    1734                 :            : 
    1735                 :          0 : static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
    1736                 :            : {
    1737                 :            :         struct ethtool_pauseparam pauseparam;
    1738                 :            : 
    1739                 :          0 :         if (!dev->ethtool_ops->set_pauseparam)
    1740                 :            :                 return -EOPNOTSUPP;
    1741                 :            : 
    1742                 :          0 :         if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
    1743                 :            :                 return -EFAULT;
    1744                 :            : 
    1745                 :          0 :         return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
    1746                 :            : }
    1747                 :            : 
    1748                 :          0 : static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
    1749                 :            : {
    1750                 :            :         struct ethtool_test test;
    1751                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1752                 :            :         u64 *data;
    1753                 :            :         int ret, test_len;
    1754                 :            : 
    1755                 :          0 :         if (!ops->self_test || !ops->get_sset_count)
    1756                 :            :                 return -EOPNOTSUPP;
    1757                 :            : 
    1758                 :          0 :         test_len = ops->get_sset_count(dev, ETH_SS_TEST);
    1759                 :          0 :         if (test_len < 0)
    1760                 :            :                 return test_len;
    1761                 :          0 :         WARN_ON(test_len == 0);
    1762                 :            : 
    1763                 :          0 :         if (copy_from_user(&test, useraddr, sizeof(test)))
    1764                 :            :                 return -EFAULT;
    1765                 :            : 
    1766                 :          0 :         test.len = test_len;
    1767                 :          0 :         data = kmalloc_array(test_len, sizeof(u64), GFP_USER);
    1768                 :          0 :         if (!data)
    1769                 :            :                 return -ENOMEM;
    1770                 :            : 
    1771                 :          0 :         ops->self_test(dev, &test, data);
    1772                 :            : 
    1773                 :            :         ret = -EFAULT;
    1774                 :          0 :         if (copy_to_user(useraddr, &test, sizeof(test)))
    1775                 :            :                 goto out;
    1776                 :          0 :         useraddr += sizeof(test);
    1777                 :          0 :         if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
    1778                 :            :                 goto out;
    1779                 :            :         ret = 0;
    1780                 :            : 
    1781                 :            :  out:
    1782                 :          0 :         kfree(data);
    1783                 :          0 :         return ret;
    1784                 :            : }
    1785                 :            : 
    1786                 :          0 : static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
    1787                 :            : {
    1788                 :            :         struct ethtool_gstrings gstrings;
    1789                 :            :         u8 *data;
    1790                 :            :         int ret;
    1791                 :            : 
    1792                 :          0 :         if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
    1793                 :            :                 return -EFAULT;
    1794                 :            : 
    1795                 :          0 :         ret = __ethtool_get_sset_count(dev, gstrings.string_set);
    1796                 :          0 :         if (ret < 0)
    1797                 :            :                 return ret;
    1798                 :          0 :         if (ret > S32_MAX / ETH_GSTRING_LEN)
    1799                 :            :                 return -ENOMEM;
    1800                 :          0 :         WARN_ON_ONCE(!ret);
    1801                 :            : 
    1802                 :          0 :         gstrings.len = ret;
    1803                 :            : 
    1804                 :          0 :         if (gstrings.len) {
    1805                 :          0 :                 data = vzalloc(array_size(gstrings.len, ETH_GSTRING_LEN));
    1806                 :          0 :                 if (!data)
    1807                 :            :                         return -ENOMEM;
    1808                 :            : 
    1809                 :          0 :                 __ethtool_get_strings(dev, gstrings.string_set, data);
    1810                 :            :         } else {
    1811                 :            :                 data = NULL;
    1812                 :            :         }
    1813                 :            : 
    1814                 :            :         ret = -EFAULT;
    1815                 :          0 :         if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
    1816                 :            :                 goto out;
    1817                 :          0 :         useraddr += sizeof(gstrings);
    1818                 :          0 :         if (gstrings.len &&
    1819                 :          0 :             copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
    1820                 :            :                 goto out;
    1821                 :            :         ret = 0;
    1822                 :            : 
    1823                 :            : out:
    1824                 :          0 :         vfree(data);
    1825                 :          0 :         return ret;
    1826                 :            : }
    1827                 :            : 
    1828                 :          0 : static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
    1829                 :            : {
    1830                 :            :         struct ethtool_value id;
    1831                 :            :         static bool busy;
    1832                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1833                 :            :         int rc;
    1834                 :            : 
    1835                 :          0 :         if (!ops->set_phys_id)
    1836                 :            :                 return -EOPNOTSUPP;
    1837                 :            : 
    1838                 :          0 :         if (busy)
    1839                 :            :                 return -EBUSY;
    1840                 :            : 
    1841                 :          0 :         if (copy_from_user(&id, useraddr, sizeof(id)))
    1842                 :            :                 return -EFAULT;
    1843                 :            : 
    1844                 :          0 :         rc = ops->set_phys_id(dev, ETHTOOL_ID_ACTIVE);
    1845                 :          0 :         if (rc < 0)
    1846                 :            :                 return rc;
    1847                 :            : 
    1848                 :            :         /* Drop the RTNL lock while waiting, but prevent reentry or
    1849                 :            :          * removal of the device.
    1850                 :            :          */
    1851                 :          0 :         busy = true;
    1852                 :          0 :         dev_hold(dev);
    1853                 :          0 :         rtnl_unlock();
    1854                 :            : 
    1855                 :          0 :         if (rc == 0) {
    1856                 :            :                 /* Driver will handle this itself */
    1857                 :          0 :                 schedule_timeout_interruptible(
    1858                 :          0 :                         id.data ? (id.data * HZ) : MAX_SCHEDULE_TIMEOUT);
    1859                 :            :         } else {
    1860                 :            :                 /* Driver expects to be called at twice the frequency in rc */
    1861                 :          0 :                 int n = rc * 2, i, interval = HZ / n;
    1862                 :            : 
    1863                 :            :                 /* Count down seconds */
    1864                 :            :                 do {
    1865                 :            :                         /* Count down iterations per second */
    1866                 :            :                         i = n;
    1867                 :            :                         do {
    1868                 :          0 :                                 rtnl_lock();
    1869                 :          0 :                                 rc = ops->set_phys_id(dev,
    1870                 :          0 :                                     (i & 1) ? ETHTOOL_ID_OFF : ETHTOOL_ID_ON);
    1871                 :          0 :                                 rtnl_unlock();
    1872                 :          0 :                                 if (rc)
    1873                 :            :                                         break;
    1874                 :          0 :                                 schedule_timeout_interruptible(interval);
    1875                 :          0 :                         } while (!signal_pending(current) && --i != 0);
    1876                 :          0 :                 } while (!signal_pending(current) &&
    1877                 :          0 :                          (id.data == 0 || --id.data != 0));
    1878                 :            :         }
    1879                 :            : 
    1880                 :          0 :         rtnl_lock();
    1881                 :          0 :         dev_put(dev);
    1882                 :          0 :         busy = false;
    1883                 :            : 
    1884                 :          0 :         (void) ops->set_phys_id(dev, ETHTOOL_ID_INACTIVE);
    1885                 :          0 :         return rc;
    1886                 :            : }
    1887                 :            : 
    1888                 :          0 : static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
    1889                 :            : {
    1890                 :            :         struct ethtool_stats stats;
    1891                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1892                 :            :         u64 *data;
    1893                 :            :         int ret, n_stats;
    1894                 :            : 
    1895                 :          0 :         if (!ops->get_ethtool_stats || !ops->get_sset_count)
    1896                 :            :                 return -EOPNOTSUPP;
    1897                 :            : 
    1898                 :          0 :         n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
    1899                 :          0 :         if (n_stats < 0)
    1900                 :            :                 return n_stats;
    1901                 :          0 :         if (n_stats > S32_MAX / sizeof(u64))
    1902                 :            :                 return -ENOMEM;
    1903                 :          0 :         WARN_ON_ONCE(!n_stats);
    1904                 :          0 :         if (copy_from_user(&stats, useraddr, sizeof(stats)))
    1905                 :            :                 return -EFAULT;
    1906                 :            : 
    1907                 :          0 :         stats.n_stats = n_stats;
    1908                 :            : 
    1909                 :          0 :         if (n_stats) {
    1910                 :          0 :                 data = vzalloc(array_size(n_stats, sizeof(u64)));
    1911                 :          0 :                 if (!data)
    1912                 :            :                         return -ENOMEM;
    1913                 :          0 :                 ops->get_ethtool_stats(dev, &stats, data);
    1914                 :            :         } else {
    1915                 :            :                 data = NULL;
    1916                 :            :         }
    1917                 :            : 
    1918                 :            :         ret = -EFAULT;
    1919                 :          0 :         if (copy_to_user(useraddr, &stats, sizeof(stats)))
    1920                 :            :                 goto out;
    1921                 :          0 :         useraddr += sizeof(stats);
    1922                 :          0 :         if (n_stats && copy_to_user(useraddr, data, n_stats * sizeof(u64)))
    1923                 :            :                 goto out;
    1924                 :            :         ret = 0;
    1925                 :            : 
    1926                 :            :  out:
    1927                 :          0 :         vfree(data);
    1928                 :          0 :         return ret;
    1929                 :            : }
    1930                 :            : 
    1931                 :          0 : static int ethtool_get_phy_stats(struct net_device *dev, void __user *useraddr)
    1932                 :            : {
    1933                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    1934                 :          0 :         struct phy_device *phydev = dev->phydev;
    1935                 :            :         struct ethtool_stats stats;
    1936                 :            :         u64 *data;
    1937                 :            :         int ret, n_stats;
    1938                 :            : 
    1939                 :          0 :         if (!phydev && (!ops->get_ethtool_phy_stats || !ops->get_sset_count))
    1940                 :            :                 return -EOPNOTSUPP;
    1941                 :            : 
    1942                 :          0 :         if (dev->phydev && !ops->get_ethtool_phy_stats)
    1943                 :          0 :                 n_stats = phy_ethtool_get_sset_count(dev->phydev);
    1944                 :            :         else
    1945                 :          0 :                 n_stats = ops->get_sset_count(dev, ETH_SS_PHY_STATS);
    1946                 :          0 :         if (n_stats < 0)
    1947                 :            :                 return n_stats;
    1948                 :          0 :         if (n_stats > S32_MAX / sizeof(u64))
    1949                 :            :                 return -ENOMEM;
    1950                 :          0 :         WARN_ON_ONCE(!n_stats);
    1951                 :            : 
    1952                 :          0 :         if (copy_from_user(&stats, useraddr, sizeof(stats)))
    1953                 :            :                 return -EFAULT;
    1954                 :            : 
    1955                 :          0 :         stats.n_stats = n_stats;
    1956                 :            : 
    1957                 :          0 :         if (n_stats) {
    1958                 :          0 :                 data = vzalloc(array_size(n_stats, sizeof(u64)));
    1959                 :          0 :                 if (!data)
    1960                 :            :                         return -ENOMEM;
    1961                 :            : 
    1962                 :          0 :                 if (dev->phydev && !ops->get_ethtool_phy_stats) {
    1963                 :          0 :                         ret = phy_ethtool_get_stats(dev->phydev, &stats, data);
    1964                 :          0 :                         if (ret < 0)
    1965                 :            :                                 goto out;
    1966                 :            :                 } else {
    1967                 :          0 :                         ops->get_ethtool_phy_stats(dev, &stats, data);
    1968                 :            :                 }
    1969                 :            :         } else {
    1970                 :            :                 data = NULL;
    1971                 :            :         }
    1972                 :            : 
    1973                 :            :         ret = -EFAULT;
    1974                 :          0 :         if (copy_to_user(useraddr, &stats, sizeof(stats)))
    1975                 :            :                 goto out;
    1976                 :          0 :         useraddr += sizeof(stats);
    1977                 :          0 :         if (n_stats && copy_to_user(useraddr, data, n_stats * sizeof(u64)))
    1978                 :            :                 goto out;
    1979                 :            :         ret = 0;
    1980                 :            : 
    1981                 :            :  out:
    1982                 :          0 :         vfree(data);
    1983                 :          0 :         return ret;
    1984                 :            : }
    1985                 :            : 
    1986                 :          0 : static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
    1987                 :            : {
    1988                 :            :         struct ethtool_perm_addr epaddr;
    1989                 :            : 
    1990                 :          0 :         if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
    1991                 :            :                 return -EFAULT;
    1992                 :            : 
    1993                 :          0 :         if (epaddr.size < dev->addr_len)
    1994                 :            :                 return -ETOOSMALL;
    1995                 :          0 :         epaddr.size = dev->addr_len;
    1996                 :            : 
    1997                 :          0 :         if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
    1998                 :            :                 return -EFAULT;
    1999                 :          0 :         useraddr += sizeof(epaddr);
    2000                 :          0 :         if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
    2001                 :            :                 return -EFAULT;
    2002                 :          0 :         return 0;
    2003                 :            : }
    2004                 :            : 
    2005                 :          0 : static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
    2006                 :            :                              u32 cmd, u32 (*actor)(struct net_device *))
    2007                 :            : {
    2008                 :          0 :         struct ethtool_value edata = { .cmd = cmd };
    2009                 :            : 
    2010                 :          0 :         if (!actor)
    2011                 :            :                 return -EOPNOTSUPP;
    2012                 :            : 
    2013                 :          0 :         edata.data = actor(dev);
    2014                 :            : 
    2015                 :          0 :         if (copy_to_user(useraddr, &edata, sizeof(edata)))
    2016                 :            :                 return -EFAULT;
    2017                 :          0 :         return 0;
    2018                 :            : }
    2019                 :            : 
    2020                 :          0 : static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
    2021                 :            :                              void (*actor)(struct net_device *, u32))
    2022                 :            : {
    2023                 :            :         struct ethtool_value edata;
    2024                 :            : 
    2025                 :          0 :         if (!actor)
    2026                 :            :                 return -EOPNOTSUPP;
    2027                 :            : 
    2028                 :          0 :         if (copy_from_user(&edata, useraddr, sizeof(edata)))
    2029                 :            :                 return -EFAULT;
    2030                 :            : 
    2031                 :          0 :         actor(dev, edata.data);
    2032                 :          0 :         return 0;
    2033                 :            : }
    2034                 :            : 
    2035                 :          0 : static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
    2036                 :            :                              int (*actor)(struct net_device *, u32))
    2037                 :            : {
    2038                 :            :         struct ethtool_value edata;
    2039                 :            : 
    2040                 :          0 :         if (!actor)
    2041                 :            :                 return -EOPNOTSUPP;
    2042                 :            : 
    2043                 :          0 :         if (copy_from_user(&edata, useraddr, sizeof(edata)))
    2044                 :            :                 return -EFAULT;
    2045                 :            : 
    2046                 :          0 :         return actor(dev, edata.data);
    2047                 :            : }
    2048                 :            : 
    2049                 :          0 : static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
    2050                 :            :                                                    char __user *useraddr)
    2051                 :            : {
    2052                 :            :         struct ethtool_flash efl;
    2053                 :            : 
    2054                 :          0 :         if (copy_from_user(&efl, useraddr, sizeof(efl)))
    2055                 :            :                 return -EFAULT;
    2056                 :          0 :         efl.data[ETHTOOL_FLASH_MAX_FILENAME - 1] = 0;
    2057                 :            : 
    2058                 :          0 :         if (!dev->ethtool_ops->flash_device)
    2059                 :            :                 return devlink_compat_flash_update(dev, efl.data);
    2060                 :            : 
    2061                 :          0 :         return dev->ethtool_ops->flash_device(dev, &efl);
    2062                 :            : }
    2063                 :            : 
    2064                 :          0 : static int ethtool_set_dump(struct net_device *dev,
    2065                 :            :                         void __user *useraddr)
    2066                 :            : {
    2067                 :            :         struct ethtool_dump dump;
    2068                 :            : 
    2069                 :          0 :         if (!dev->ethtool_ops->set_dump)
    2070                 :            :                 return -EOPNOTSUPP;
    2071                 :            : 
    2072                 :          0 :         if (copy_from_user(&dump, useraddr, sizeof(dump)))
    2073                 :            :                 return -EFAULT;
    2074                 :            : 
    2075                 :          0 :         return dev->ethtool_ops->set_dump(dev, &dump);
    2076                 :            : }
    2077                 :            : 
    2078                 :          0 : static int ethtool_get_dump_flag(struct net_device *dev,
    2079                 :            :                                 void __user *useraddr)
    2080                 :            : {
    2081                 :            :         int ret;
    2082                 :            :         struct ethtool_dump dump;
    2083                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    2084                 :            : 
    2085                 :          0 :         if (!ops->get_dump_flag)
    2086                 :            :                 return -EOPNOTSUPP;
    2087                 :            : 
    2088                 :          0 :         if (copy_from_user(&dump, useraddr, sizeof(dump)))
    2089                 :            :                 return -EFAULT;
    2090                 :            : 
    2091                 :          0 :         ret = ops->get_dump_flag(dev, &dump);
    2092                 :          0 :         if (ret)
    2093                 :            :                 return ret;
    2094                 :            : 
    2095                 :          0 :         if (copy_to_user(useraddr, &dump, sizeof(dump)))
    2096                 :            :                 return -EFAULT;
    2097                 :          0 :         return 0;
    2098                 :            : }
    2099                 :            : 
    2100                 :          0 : static int ethtool_get_dump_data(struct net_device *dev,
    2101                 :            :                                 void __user *useraddr)
    2102                 :            : {
    2103                 :            :         int ret;
    2104                 :            :         __u32 len;
    2105                 :            :         struct ethtool_dump dump, tmp;
    2106                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    2107                 :            :         void *data = NULL;
    2108                 :            : 
    2109                 :          0 :         if (!ops->get_dump_data || !ops->get_dump_flag)
    2110                 :            :                 return -EOPNOTSUPP;
    2111                 :            : 
    2112                 :          0 :         if (copy_from_user(&dump, useraddr, sizeof(dump)))
    2113                 :            :                 return -EFAULT;
    2114                 :            : 
    2115                 :          0 :         memset(&tmp, 0, sizeof(tmp));
    2116                 :          0 :         tmp.cmd = ETHTOOL_GET_DUMP_FLAG;
    2117                 :          0 :         ret = ops->get_dump_flag(dev, &tmp);
    2118                 :          0 :         if (ret)
    2119                 :            :                 return ret;
    2120                 :            : 
    2121                 :          0 :         len = min(tmp.len, dump.len);
    2122                 :          0 :         if (!len)
    2123                 :            :                 return -EFAULT;
    2124                 :            : 
    2125                 :            :         /* Don't ever let the driver think there's more space available
    2126                 :            :          * than it requested with .get_dump_flag().
    2127                 :            :          */
    2128                 :          0 :         dump.len = len;
    2129                 :            : 
    2130                 :            :         /* Always allocate enough space to hold the whole thing so that the
    2131                 :            :          * driver does not need to check the length and bother with partial
    2132                 :            :          * dumping.
    2133                 :            :          */
    2134                 :          0 :         data = vzalloc(tmp.len);
    2135                 :          0 :         if (!data)
    2136                 :            :                 return -ENOMEM;
    2137                 :          0 :         ret = ops->get_dump_data(dev, &dump, data);
    2138                 :          0 :         if (ret)
    2139                 :            :                 goto out;
    2140                 :            : 
    2141                 :            :         /* There are two sane possibilities:
    2142                 :            :          * 1. The driver's .get_dump_data() does not touch dump.len.
    2143                 :            :          * 2. Or it may set dump.len to how much it really writes, which
    2144                 :            :          *    should be tmp.len (or len if it can do a partial dump).
    2145                 :            :          * In any case respond to userspace with the actual length of data
    2146                 :            :          * it's receiving.
    2147                 :            :          */
    2148                 :          0 :         WARN_ON(dump.len != len && dump.len != tmp.len);
    2149                 :          0 :         dump.len = len;
    2150                 :            : 
    2151                 :          0 :         if (copy_to_user(useraddr, &dump, sizeof(dump))) {
    2152                 :            :                 ret = -EFAULT;
    2153                 :            :                 goto out;
    2154                 :            :         }
    2155                 :          0 :         useraddr += offsetof(struct ethtool_dump, data);
    2156                 :          0 :         if (copy_to_user(useraddr, data, len))
    2157                 :            :                 ret = -EFAULT;
    2158                 :            : out:
    2159                 :          0 :         vfree(data);
    2160                 :          0 :         return ret;
    2161                 :            : }
    2162                 :            : 
    2163                 :          0 : static int ethtool_get_ts_info(struct net_device *dev, void __user *useraddr)
    2164                 :            : {
    2165                 :            :         int err = 0;
    2166                 :            :         struct ethtool_ts_info info;
    2167                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    2168                 :          0 :         struct phy_device *phydev = dev->phydev;
    2169                 :            : 
    2170                 :          0 :         memset(&info, 0, sizeof(info));
    2171                 :          0 :         info.cmd = ETHTOOL_GET_TS_INFO;
    2172                 :            : 
    2173                 :          0 :         if (phydev && phydev->drv && phydev->drv->ts_info) {
    2174                 :          0 :                 err = phydev->drv->ts_info(phydev, &info);
    2175                 :          0 :         } else if (ops->get_ts_info) {
    2176                 :          0 :                 err = ops->get_ts_info(dev, &info);
    2177                 :            :         } else {
    2178                 :          0 :                 info.so_timestamping =
    2179                 :            :                         SOF_TIMESTAMPING_RX_SOFTWARE |
    2180                 :            :                         SOF_TIMESTAMPING_SOFTWARE;
    2181                 :          0 :                 info.phc_index = -1;
    2182                 :            :         }
    2183                 :            : 
    2184                 :          0 :         if (err)
    2185                 :            :                 return err;
    2186                 :            : 
    2187                 :          0 :         if (copy_to_user(useraddr, &info, sizeof(info)))
    2188                 :            :                 err = -EFAULT;
    2189                 :            : 
    2190                 :          0 :         return err;
    2191                 :            : }
    2192                 :            : 
    2193                 :          0 : static int __ethtool_get_module_info(struct net_device *dev,
    2194                 :            :                                      struct ethtool_modinfo *modinfo)
    2195                 :            : {
    2196                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    2197                 :          0 :         struct phy_device *phydev = dev->phydev;
    2198                 :            : 
    2199                 :          0 :         if (dev->sfp_bus)
    2200                 :            :                 return sfp_get_module_info(dev->sfp_bus, modinfo);
    2201                 :            : 
    2202                 :          0 :         if (phydev && phydev->drv && phydev->drv->module_info)
    2203                 :          0 :                 return phydev->drv->module_info(phydev, modinfo);
    2204                 :            : 
    2205                 :          0 :         if (ops->get_module_info)
    2206                 :          0 :                 return ops->get_module_info(dev, modinfo);
    2207                 :            : 
    2208                 :            :         return -EOPNOTSUPP;
    2209                 :            : }
    2210                 :            : 
    2211                 :          0 : static int ethtool_get_module_info(struct net_device *dev,
    2212                 :            :                                    void __user *useraddr)
    2213                 :            : {
    2214                 :            :         int ret;
    2215                 :            :         struct ethtool_modinfo modinfo;
    2216                 :            : 
    2217                 :          0 :         if (copy_from_user(&modinfo, useraddr, sizeof(modinfo)))
    2218                 :            :                 return -EFAULT;
    2219                 :            : 
    2220                 :          0 :         ret = __ethtool_get_module_info(dev, &modinfo);
    2221                 :          0 :         if (ret)
    2222                 :            :                 return ret;
    2223                 :            : 
    2224                 :          0 :         if (copy_to_user(useraddr, &modinfo, sizeof(modinfo)))
    2225                 :            :                 return -EFAULT;
    2226                 :            : 
    2227                 :          0 :         return 0;
    2228                 :            : }
    2229                 :            : 
    2230                 :          0 : static int __ethtool_get_module_eeprom(struct net_device *dev,
    2231                 :            :                                        struct ethtool_eeprom *ee, u8 *data)
    2232                 :            : {
    2233                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    2234                 :          0 :         struct phy_device *phydev = dev->phydev;
    2235                 :            : 
    2236                 :          0 :         if (dev->sfp_bus)
    2237                 :            :                 return sfp_get_module_eeprom(dev->sfp_bus, ee, data);
    2238                 :            : 
    2239                 :          0 :         if (phydev && phydev->drv && phydev->drv->module_eeprom)
    2240                 :          0 :                 return phydev->drv->module_eeprom(phydev, ee, data);
    2241                 :            : 
    2242                 :          0 :         if (ops->get_module_eeprom)
    2243                 :          0 :                 return ops->get_module_eeprom(dev, ee, data);
    2244                 :            : 
    2245                 :            :         return -EOPNOTSUPP;
    2246                 :            : }
    2247                 :            : 
    2248                 :          0 : static int ethtool_get_module_eeprom(struct net_device *dev,
    2249                 :            :                                      void __user *useraddr)
    2250                 :            : {
    2251                 :            :         int ret;
    2252                 :            :         struct ethtool_modinfo modinfo;
    2253                 :            : 
    2254                 :          0 :         ret = __ethtool_get_module_info(dev, &modinfo);
    2255                 :          0 :         if (ret)
    2256                 :            :                 return ret;
    2257                 :            : 
    2258                 :          0 :         return ethtool_get_any_eeprom(dev, useraddr,
    2259                 :            :                                       __ethtool_get_module_eeprom,
    2260                 :            :                                       modinfo.eeprom_len);
    2261                 :            : }
    2262                 :            : 
    2263                 :          0 : static int ethtool_tunable_valid(const struct ethtool_tunable *tuna)
    2264                 :            : {
    2265                 :          0 :         switch (tuna->id) {
    2266                 :            :         case ETHTOOL_RX_COPYBREAK:
    2267                 :            :         case ETHTOOL_TX_COPYBREAK:
    2268                 :          0 :                 if (tuna->len != sizeof(u32) ||
    2269                 :          0 :                     tuna->type_id != ETHTOOL_TUNABLE_U32)
    2270                 :            :                         return -EINVAL;
    2271                 :            :                 break;
    2272                 :            :         case ETHTOOL_PFC_PREVENTION_TOUT:
    2273                 :          0 :                 if (tuna->len != sizeof(u16) ||
    2274                 :          0 :                     tuna->type_id != ETHTOOL_TUNABLE_U16)
    2275                 :            :                         return -EINVAL;
    2276                 :            :                 break;
    2277                 :            :         default:
    2278                 :            :                 return -EINVAL;
    2279                 :            :         }
    2280                 :            : 
    2281                 :          0 :         return 0;
    2282                 :            : }
    2283                 :            : 
    2284                 :          0 : static int ethtool_get_tunable(struct net_device *dev, void __user *useraddr)
    2285                 :            : {
    2286                 :            :         int ret;
    2287                 :            :         struct ethtool_tunable tuna;
    2288                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    2289                 :            :         void *data;
    2290                 :            : 
    2291                 :          0 :         if (!ops->get_tunable)
    2292                 :            :                 return -EOPNOTSUPP;
    2293                 :          0 :         if (copy_from_user(&tuna, useraddr, sizeof(tuna)))
    2294                 :            :                 return -EFAULT;
    2295                 :          0 :         ret = ethtool_tunable_valid(&tuna);
    2296                 :          0 :         if (ret)
    2297                 :            :                 return ret;
    2298                 :          0 :         data = kmalloc(tuna.len, GFP_USER);
    2299                 :          0 :         if (!data)
    2300                 :            :                 return -ENOMEM;
    2301                 :          0 :         ret = ops->get_tunable(dev, &tuna, data);
    2302                 :          0 :         if (ret)
    2303                 :            :                 goto out;
    2304                 :          0 :         useraddr += sizeof(tuna);
    2305                 :            :         ret = -EFAULT;
    2306                 :          0 :         if (copy_to_user(useraddr, data, tuna.len))
    2307                 :            :                 goto out;
    2308                 :            :         ret = 0;
    2309                 :            : 
    2310                 :            : out:
    2311                 :          0 :         kfree(data);
    2312                 :          0 :         return ret;
    2313                 :            : }
    2314                 :            : 
    2315                 :          0 : static int ethtool_set_tunable(struct net_device *dev, void __user *useraddr)
    2316                 :            : {
    2317                 :            :         int ret;
    2318                 :            :         struct ethtool_tunable tuna;
    2319                 :          0 :         const struct ethtool_ops *ops = dev->ethtool_ops;
    2320                 :            :         void *data;
    2321                 :            : 
    2322                 :          0 :         if (!ops->set_tunable)
    2323                 :            :                 return -EOPNOTSUPP;
    2324                 :          0 :         if (copy_from_user(&tuna, useraddr, sizeof(tuna)))
    2325                 :            :                 return -EFAULT;
    2326                 :          0 :         ret = ethtool_tunable_valid(&tuna);
    2327                 :          0 :         if (ret)
    2328                 :            :                 return ret;
    2329                 :          0 :         useraddr += sizeof(tuna);
    2330                 :          0 :         data = memdup_user(useraddr, tuna.len);
    2331                 :          0 :         if (IS_ERR(data))
    2332                 :          0 :                 return PTR_ERR(data);
    2333                 :          0 :         ret = ops->set_tunable(dev, &tuna, data);
    2334                 :            : 
    2335                 :          0 :         kfree(data);
    2336                 :          0 :         return ret;
    2337                 :            : }
    2338                 :            : 
    2339                 :            : static noinline_for_stack int
    2340                 :          0 : ethtool_get_per_queue_coalesce(struct net_device *dev,
    2341                 :            :                                void __user *useraddr,
    2342                 :            :                                struct ethtool_per_queue_op *per_queue_opt)
    2343                 :            : {
    2344                 :            :         u32 bit;
    2345                 :            :         int ret;
    2346                 :            :         DECLARE_BITMAP(queue_mask, MAX_NUM_QUEUE);
    2347                 :            : 
    2348                 :          0 :         if (!dev->ethtool_ops->get_per_queue_coalesce)
    2349                 :            :                 return -EOPNOTSUPP;
    2350                 :            : 
    2351                 :          0 :         useraddr += sizeof(*per_queue_opt);
    2352                 :            : 
    2353                 :          0 :         bitmap_from_arr32(queue_mask, per_queue_opt->queue_mask,
    2354                 :            :                           MAX_NUM_QUEUE);
    2355                 :            : 
    2356                 :          0 :         for_each_set_bit(bit, queue_mask, MAX_NUM_QUEUE) {
    2357                 :          0 :                 struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
    2358                 :            : 
    2359                 :          0 :                 ret = dev->ethtool_ops->get_per_queue_coalesce(dev, bit, &coalesce);
    2360                 :          0 :                 if (ret != 0)
    2361                 :          0 :                         return ret;
    2362                 :          0 :                 if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
    2363                 :            :                         return -EFAULT;
    2364                 :          0 :                 useraddr += sizeof(coalesce);
    2365                 :            :         }
    2366                 :            : 
    2367                 :            :         return 0;
    2368                 :            : }
    2369                 :            : 
    2370                 :            : static noinline_for_stack int
    2371                 :          0 : ethtool_set_per_queue_coalesce(struct net_device *dev,
    2372                 :            :                                void __user *useraddr,
    2373                 :            :                                struct ethtool_per_queue_op *per_queue_opt)
    2374                 :            : {
    2375                 :            :         u32 bit;
    2376                 :            :         int i, ret = 0;
    2377                 :            :         int n_queue;
    2378                 :            :         struct ethtool_coalesce *backup = NULL, *tmp = NULL;
    2379                 :            :         DECLARE_BITMAP(queue_mask, MAX_NUM_QUEUE);
    2380                 :            : 
    2381                 :          0 :         if ((!dev->ethtool_ops->set_per_queue_coalesce) ||
    2382                 :          0 :             (!dev->ethtool_ops->get_per_queue_coalesce))
    2383                 :            :                 return -EOPNOTSUPP;
    2384                 :            : 
    2385                 :          0 :         useraddr += sizeof(*per_queue_opt);
    2386                 :            : 
    2387                 :          0 :         bitmap_from_arr32(queue_mask, per_queue_opt->queue_mask, MAX_NUM_QUEUE);
    2388                 :            :         n_queue = bitmap_weight(queue_mask, MAX_NUM_QUEUE);
    2389                 :          0 :         tmp = backup = kmalloc_array(n_queue, sizeof(*backup), GFP_KERNEL);
    2390                 :          0 :         if (!backup)
    2391                 :            :                 return -ENOMEM;
    2392                 :            : 
    2393                 :          0 :         for_each_set_bit(bit, queue_mask, MAX_NUM_QUEUE) {
    2394                 :            :                 struct ethtool_coalesce coalesce;
    2395                 :            : 
    2396                 :          0 :                 ret = dev->ethtool_ops->get_per_queue_coalesce(dev, bit, tmp);
    2397                 :          0 :                 if (ret != 0)
    2398                 :            :                         goto roll_back;
    2399                 :            : 
    2400                 :          0 :                 tmp++;
    2401                 :            : 
    2402                 :          0 :                 if (copy_from_user(&coalesce, useraddr, sizeof(coalesce))) {
    2403                 :            :                         ret = -EFAULT;
    2404                 :            :                         goto roll_back;
    2405                 :            :                 }
    2406                 :            : 
    2407                 :          0 :                 ret = dev->ethtool_ops->set_per_queue_coalesce(dev, bit, &coalesce);
    2408                 :          0 :                 if (ret != 0)
    2409                 :            :                         goto roll_back;
    2410                 :            : 
    2411                 :          0 :                 useraddr += sizeof(coalesce);
    2412                 :            :         }
    2413                 :            : 
    2414                 :            : roll_back:
    2415                 :          0 :         if (ret != 0) {
    2416                 :            :                 tmp = backup;
    2417                 :          0 :                 for_each_set_bit(i, queue_mask, bit) {
    2418                 :          0 :                         dev->ethtool_ops->set_per_queue_coalesce(dev, i, tmp);
    2419                 :          0 :                         tmp++;
    2420                 :            :                 }
    2421                 :            :         }
    2422                 :          0 :         kfree(backup);
    2423                 :            : 
    2424                 :          0 :         return ret;
    2425                 :            : }
    2426                 :            : 
    2427                 :          0 : static int noinline_for_stack ethtool_set_per_queue(struct net_device *dev,
    2428                 :            :                                  void __user *useraddr, u32 sub_cmd)
    2429                 :            : {
    2430                 :            :         struct ethtool_per_queue_op per_queue_opt;
    2431                 :            : 
    2432                 :          0 :         if (copy_from_user(&per_queue_opt, useraddr, sizeof(per_queue_opt)))
    2433                 :            :                 return -EFAULT;
    2434                 :            : 
    2435                 :          0 :         if (per_queue_opt.sub_command != sub_cmd)
    2436                 :            :                 return -EINVAL;
    2437                 :            : 
    2438                 :          0 :         switch (per_queue_opt.sub_command) {
    2439                 :            :         case ETHTOOL_GCOALESCE:
    2440                 :          0 :                 return ethtool_get_per_queue_coalesce(dev, useraddr, &per_queue_opt);
    2441                 :            :         case ETHTOOL_SCOALESCE:
    2442                 :          0 :                 return ethtool_set_per_queue_coalesce(dev, useraddr, &per_queue_opt);
    2443                 :            :         default:
    2444                 :            :                 return -EOPNOTSUPP;
    2445                 :            :         };
    2446                 :            : }
    2447                 :            : 
    2448                 :          0 : static int ethtool_phy_tunable_valid(const struct ethtool_tunable *tuna)
    2449                 :            : {
    2450                 :          0 :         switch (tuna->id) {
    2451                 :            :         case ETHTOOL_PHY_DOWNSHIFT:
    2452                 :            :         case ETHTOOL_PHY_FAST_LINK_DOWN:
    2453                 :          0 :                 if (tuna->len != sizeof(u8) ||
    2454                 :          0 :                     tuna->type_id != ETHTOOL_TUNABLE_U8)
    2455                 :            :                         return -EINVAL;
    2456                 :            :                 break;
    2457                 :            :         case ETHTOOL_PHY_EDPD:
    2458                 :          0 :                 if (tuna->len != sizeof(u16) ||
    2459                 :          0 :                     tuna->type_id != ETHTOOL_TUNABLE_U16)
    2460                 :            :                         return -EINVAL;
    2461                 :            :                 break;
    2462                 :            :         default:
    2463                 :            :                 return -EINVAL;
    2464                 :            :         }
    2465                 :            : 
    2466                 :          0 :         return 0;
    2467                 :            : }
    2468                 :            : 
    2469                 :          0 : static int get_phy_tunable(struct net_device *dev, void __user *useraddr)
    2470                 :            : {
    2471                 :            :         int ret;
    2472                 :            :         struct ethtool_tunable tuna;
    2473                 :          0 :         struct phy_device *phydev = dev->phydev;
    2474                 :            :         void *data;
    2475                 :            : 
    2476                 :          0 :         if (!(phydev && phydev->drv && phydev->drv->get_tunable))
    2477                 :            :                 return -EOPNOTSUPP;
    2478                 :            : 
    2479                 :          0 :         if (copy_from_user(&tuna, useraddr, sizeof(tuna)))
    2480                 :            :                 return -EFAULT;
    2481                 :          0 :         ret = ethtool_phy_tunable_valid(&tuna);
    2482                 :          0 :         if (ret)
    2483                 :            :                 return ret;
    2484                 :          0 :         data = kmalloc(tuna.len, GFP_USER);
    2485                 :          0 :         if (!data)
    2486                 :            :                 return -ENOMEM;
    2487                 :          0 :         mutex_lock(&phydev->lock);
    2488                 :          0 :         ret = phydev->drv->get_tunable(phydev, &tuna, data);
    2489                 :          0 :         mutex_unlock(&phydev->lock);
    2490                 :          0 :         if (ret)
    2491                 :            :                 goto out;
    2492                 :          0 :         useraddr += sizeof(tuna);
    2493                 :            :         ret = -EFAULT;
    2494                 :          0 :         if (copy_to_user(useraddr, data, tuna.len))
    2495                 :            :                 goto out;
    2496                 :            :         ret = 0;
    2497                 :            : 
    2498                 :            : out:
    2499                 :          0 :         kfree(data);
    2500                 :          0 :         return ret;
    2501                 :            : }
    2502                 :            : 
    2503                 :          0 : static int set_phy_tunable(struct net_device *dev, void __user *useraddr)
    2504                 :            : {
    2505                 :            :         int ret;
    2506                 :            :         struct ethtool_tunable tuna;
    2507                 :          0 :         struct phy_device *phydev = dev->phydev;
    2508                 :            :         void *data;
    2509                 :            : 
    2510                 :          0 :         if (!(phydev && phydev->drv && phydev->drv->set_tunable))
    2511                 :            :                 return -EOPNOTSUPP;
    2512                 :          0 :         if (copy_from_user(&tuna, useraddr, sizeof(tuna)))
    2513                 :            :                 return -EFAULT;
    2514                 :          0 :         ret = ethtool_phy_tunable_valid(&tuna);
    2515                 :          0 :         if (ret)
    2516                 :            :                 return ret;
    2517                 :          0 :         useraddr += sizeof(tuna);
    2518                 :          0 :         data = memdup_user(useraddr, tuna.len);
    2519                 :          0 :         if (IS_ERR(data))
    2520                 :          0 :                 return PTR_ERR(data);
    2521                 :          0 :         mutex_lock(&phydev->lock);
    2522                 :          0 :         ret = phydev->drv->set_tunable(phydev, &tuna, data);
    2523                 :          0 :         mutex_unlock(&phydev->lock);
    2524                 :            : 
    2525                 :          0 :         kfree(data);
    2526                 :          0 :         return ret;
    2527                 :            : }
    2528                 :            : 
    2529                 :          0 : static int ethtool_get_fecparam(struct net_device *dev, void __user *useraddr)
    2530                 :            : {
    2531                 :          0 :         struct ethtool_fecparam fecparam = { .cmd = ETHTOOL_GFECPARAM };
    2532                 :            :         int rc;
    2533                 :            : 
    2534                 :          0 :         if (!dev->ethtool_ops->get_fecparam)
    2535                 :            :                 return -EOPNOTSUPP;
    2536                 :            : 
    2537                 :          0 :         rc = dev->ethtool_ops->get_fecparam(dev, &fecparam);
    2538                 :          0 :         if (rc)
    2539                 :            :                 return rc;
    2540                 :            : 
    2541                 :          0 :         if (copy_to_user(useraddr, &fecparam, sizeof(fecparam)))
    2542                 :            :                 return -EFAULT;
    2543                 :          0 :         return 0;
    2544                 :            : }
    2545                 :            : 
    2546                 :          0 : static int ethtool_set_fecparam(struct net_device *dev, void __user *useraddr)
    2547                 :            : {
    2548                 :            :         struct ethtool_fecparam fecparam;
    2549                 :            : 
    2550                 :          0 :         if (!dev->ethtool_ops->set_fecparam)
    2551                 :            :                 return -EOPNOTSUPP;
    2552                 :            : 
    2553                 :          0 :         if (copy_from_user(&fecparam, useraddr, sizeof(fecparam)))
    2554                 :            :                 return -EFAULT;
    2555                 :            : 
    2556                 :          0 :         return dev->ethtool_ops->set_fecparam(dev, &fecparam);
    2557                 :            : }
    2558                 :            : 
    2559                 :            : /* The main entry point in this file.  Called from net/core/dev_ioctl.c */
    2560                 :            : 
    2561                 :          3 : int dev_ethtool(struct net *net, struct ifreq *ifr)
    2562                 :            : {
    2563                 :          3 :         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
    2564                 :          3 :         void __user *useraddr = ifr->ifr_data;
    2565                 :            :         u32 ethcmd, sub_cmd;
    2566                 :            :         int rc;
    2567                 :            :         netdev_features_t old_features;
    2568                 :            : 
    2569                 :          3 :         if (!dev || !netif_device_present(dev))
    2570                 :            :                 return -ENODEV;
    2571                 :            : 
    2572                 :          3 :         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
    2573                 :            :                 return -EFAULT;
    2574                 :            : 
    2575                 :          3 :         if (ethcmd == ETHTOOL_PERQUEUE) {
    2576                 :          0 :                 if (copy_from_user(&sub_cmd, useraddr + sizeof(ethcmd), sizeof(sub_cmd)))
    2577                 :            :                         return -EFAULT;
    2578                 :            :         } else {
    2579                 :          3 :                 sub_cmd = ethcmd;
    2580                 :            :         }
    2581                 :            :         /* Allow some commands to be done by anyone */
    2582                 :          3 :         switch (sub_cmd) {
    2583                 :            :         case ETHTOOL_GSET:
    2584                 :            :         case ETHTOOL_GDRVINFO:
    2585                 :            :         case ETHTOOL_GMSGLVL:
    2586                 :            :         case ETHTOOL_GLINK:
    2587                 :            :         case ETHTOOL_GCOALESCE:
    2588                 :            :         case ETHTOOL_GRINGPARAM:
    2589                 :            :         case ETHTOOL_GPAUSEPARAM:
    2590                 :            :         case ETHTOOL_GRXCSUM:
    2591                 :            :         case ETHTOOL_GTXCSUM:
    2592                 :            :         case ETHTOOL_GSG:
    2593                 :            :         case ETHTOOL_GSSET_INFO:
    2594                 :            :         case ETHTOOL_GSTRINGS:
    2595                 :            :         case ETHTOOL_GSTATS:
    2596                 :            :         case ETHTOOL_GPHYSTATS:
    2597                 :            :         case ETHTOOL_GTSO:
    2598                 :            :         case ETHTOOL_GPERMADDR:
    2599                 :            :         case ETHTOOL_GUFO:
    2600                 :            :         case ETHTOOL_GGSO:
    2601                 :            :         case ETHTOOL_GGRO:
    2602                 :            :         case ETHTOOL_GFLAGS:
    2603                 :            :         case ETHTOOL_GPFLAGS:
    2604                 :            :         case ETHTOOL_GRXFH:
    2605                 :            :         case ETHTOOL_GRXRINGS:
    2606                 :            :         case ETHTOOL_GRXCLSRLCNT:
    2607                 :            :         case ETHTOOL_GRXCLSRULE:
    2608                 :            :         case ETHTOOL_GRXCLSRLALL:
    2609                 :            :         case ETHTOOL_GRXFHINDIR:
    2610                 :            :         case ETHTOOL_GRSSH:
    2611                 :            :         case ETHTOOL_GFEATURES:
    2612                 :            :         case ETHTOOL_GCHANNELS:
    2613                 :            :         case ETHTOOL_GET_TS_INFO:
    2614                 :            :         case ETHTOOL_GEEE:
    2615                 :            :         case ETHTOOL_GTUNABLE:
    2616                 :            :         case ETHTOOL_PHY_GTUNABLE:
    2617                 :            :         case ETHTOOL_GLINKSETTINGS:
    2618                 :            :         case ETHTOOL_GFECPARAM:
    2619                 :            :                 break;
    2620                 :            :         default:
    2621                 :          0 :                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
    2622                 :            :                         return -EPERM;
    2623                 :            :         }
    2624                 :            : 
    2625                 :          3 :         if (dev->ethtool_ops->begin) {
    2626                 :          0 :                 rc = dev->ethtool_ops->begin(dev);
    2627                 :          0 :                 if (rc  < 0)
    2628                 :            :                         return rc;
    2629                 :            :         }
    2630                 :          3 :         old_features = dev->features;
    2631                 :            : 
    2632                 :          3 :         switch (ethcmd) {
    2633                 :            :         case ETHTOOL_GSET:
    2634                 :          1 :                 rc = ethtool_get_settings(dev, useraddr);
    2635                 :          1 :                 break;
    2636                 :            :         case ETHTOOL_SSET:
    2637                 :          0 :                 rc = ethtool_set_settings(dev, useraddr);
    2638                 :          0 :                 break;
    2639                 :            :         case ETHTOOL_GDRVINFO:
    2640                 :          3 :                 rc = ethtool_get_drvinfo(dev, useraddr);
    2641                 :          3 :                 break;
    2642                 :            :         case ETHTOOL_GREGS:
    2643                 :          0 :                 rc = ethtool_get_regs(dev, useraddr);
    2644                 :          0 :                 break;
    2645                 :            :         case ETHTOOL_GWOL:
    2646                 :          0 :                 rc = ethtool_get_wol(dev, useraddr);
    2647                 :          0 :                 break;
    2648                 :            :         case ETHTOOL_SWOL:
    2649                 :          0 :                 rc = ethtool_set_wol(dev, useraddr);
    2650                 :          0 :                 break;
    2651                 :            :         case ETHTOOL_GMSGLVL:
    2652                 :          0 :                 rc = ethtool_get_value(dev, useraddr, ethcmd,
    2653                 :          0 :                                        dev->ethtool_ops->get_msglevel);
    2654                 :          0 :                 break;
    2655                 :            :         case ETHTOOL_SMSGLVL:
    2656                 :          0 :                 rc = ethtool_set_value_void(dev, useraddr,
    2657                 :          0 :                                        dev->ethtool_ops->set_msglevel);
    2658                 :          0 :                 break;
    2659                 :            :         case ETHTOOL_GEEE:
    2660                 :          0 :                 rc = ethtool_get_eee(dev, useraddr);
    2661                 :          0 :                 break;
    2662                 :            :         case ETHTOOL_SEEE:
    2663                 :          0 :                 rc = ethtool_set_eee(dev, useraddr);
    2664                 :          0 :                 break;
    2665                 :            :         case ETHTOOL_NWAY_RST:
    2666                 :            :                 rc = ethtool_nway_reset(dev);
    2667                 :          0 :                 break;
    2668                 :            :         case ETHTOOL_GLINK:
    2669                 :          0 :                 rc = ethtool_get_link(dev, useraddr);
    2670                 :          0 :                 break;
    2671                 :            :         case ETHTOOL_GEEPROM:
    2672                 :          0 :                 rc = ethtool_get_eeprom(dev, useraddr);
    2673                 :          0 :                 break;
    2674                 :            :         case ETHTOOL_SEEPROM:
    2675                 :          0 :                 rc = ethtool_set_eeprom(dev, useraddr);
    2676                 :          0 :                 break;
    2677                 :            :         case ETHTOOL_GCOALESCE:
    2678                 :          0 :                 rc = ethtool_get_coalesce(dev, useraddr);
    2679                 :          0 :                 break;
    2680                 :            :         case ETHTOOL_SCOALESCE:
    2681                 :          0 :                 rc = ethtool_set_coalesce(dev, useraddr);
    2682                 :          0 :                 break;
    2683                 :            :         case ETHTOOL_GRINGPARAM:
    2684                 :          0 :                 rc = ethtool_get_ringparam(dev, useraddr);
    2685                 :          0 :                 break;
    2686                 :            :         case ETHTOOL_SRINGPARAM:
    2687                 :          0 :                 rc = ethtool_set_ringparam(dev, useraddr);
    2688                 :          0 :                 break;
    2689                 :            :         case ETHTOOL_GPAUSEPARAM:
    2690                 :          0 :                 rc = ethtool_get_pauseparam(dev, useraddr);
    2691                 :          0 :                 break;
    2692                 :            :         case ETHTOOL_SPAUSEPARAM:
    2693                 :          0 :                 rc = ethtool_set_pauseparam(dev, useraddr);
    2694                 :          0 :                 break;
    2695                 :            :         case ETHTOOL_TEST:
    2696                 :          0 :                 rc = ethtool_self_test(dev, useraddr);
    2697                 :          0 :                 break;
    2698                 :            :         case ETHTOOL_GSTRINGS:
    2699                 :          0 :                 rc = ethtool_get_strings(dev, useraddr);
    2700                 :          0 :                 break;
    2701                 :            :         case ETHTOOL_PHYS_ID:
    2702                 :          0 :                 rc = ethtool_phys_id(dev, useraddr);
    2703                 :          0 :                 break;
    2704                 :            :         case ETHTOOL_GSTATS:
    2705                 :          0 :                 rc = ethtool_get_stats(dev, useraddr);
    2706                 :          0 :                 break;
    2707                 :            :         case ETHTOOL_GPERMADDR:
    2708                 :          0 :                 rc = ethtool_get_perm_addr(dev, useraddr);
    2709                 :          0 :                 break;
    2710                 :            :         case ETHTOOL_GFLAGS:
    2711                 :          0 :                 rc = ethtool_get_value(dev, useraddr, ethcmd,
    2712                 :            :                                         __ethtool_get_flags);
    2713                 :          0 :                 break;
    2714                 :            :         case ETHTOOL_SFLAGS:
    2715                 :          0 :                 rc = ethtool_set_value(dev, useraddr, __ethtool_set_flags);
    2716                 :          0 :                 break;
    2717                 :            :         case ETHTOOL_GPFLAGS:
    2718                 :          0 :                 rc = ethtool_get_value(dev, useraddr, ethcmd,
    2719                 :          0 :                                        dev->ethtool_ops->get_priv_flags);
    2720                 :          0 :                 break;
    2721                 :            :         case ETHTOOL_SPFLAGS:
    2722                 :          0 :                 rc = ethtool_set_value(dev, useraddr,
    2723                 :          0 :                                        dev->ethtool_ops->set_priv_flags);
    2724                 :          0 :                 break;
    2725                 :            :         case ETHTOOL_GRXFH:
    2726                 :            :         case ETHTOOL_GRXRINGS:
    2727                 :            :         case ETHTOOL_GRXCLSRLCNT:
    2728                 :            :         case ETHTOOL_GRXCLSRULE:
    2729                 :            :         case ETHTOOL_GRXCLSRLALL:
    2730                 :          0 :                 rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
    2731                 :          0 :                 break;
    2732                 :            :         case ETHTOOL_SRXFH:
    2733                 :            :         case ETHTOOL_SRXCLSRLDEL:
    2734                 :            :         case ETHTOOL_SRXCLSRLINS:
    2735                 :          0 :                 rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
    2736                 :          0 :                 break;
    2737                 :            :         case ETHTOOL_FLASHDEV:
    2738                 :          0 :                 rc = ethtool_flash_device(dev, useraddr);
    2739                 :          0 :                 break;
    2740                 :            :         case ETHTOOL_RESET:
    2741                 :          0 :                 rc = ethtool_reset(dev, useraddr);
    2742                 :          0 :                 break;
    2743                 :            :         case ETHTOOL_GSSET_INFO:
    2744                 :          0 :                 rc = ethtool_get_sset_info(dev, useraddr);
    2745                 :          0 :                 break;
    2746                 :            :         case ETHTOOL_GRXFHINDIR:
    2747                 :          0 :                 rc = ethtool_get_rxfh_indir(dev, useraddr);
    2748                 :          0 :                 break;
    2749                 :            :         case ETHTOOL_SRXFHINDIR:
    2750                 :          0 :                 rc = ethtool_set_rxfh_indir(dev, useraddr);
    2751                 :          0 :                 break;
    2752                 :            :         case ETHTOOL_GRSSH:
    2753                 :          0 :                 rc = ethtool_get_rxfh(dev, useraddr);
    2754                 :          0 :                 break;
    2755                 :            :         case ETHTOOL_SRSSH:
    2756                 :          0 :                 rc = ethtool_set_rxfh(dev, useraddr);
    2757                 :          0 :                 break;
    2758                 :            :         case ETHTOOL_GFEATURES:
    2759                 :          0 :                 rc = ethtool_get_features(dev, useraddr);
    2760                 :          0 :                 break;
    2761                 :            :         case ETHTOOL_SFEATURES:
    2762                 :          0 :                 rc = ethtool_set_features(dev, useraddr);
    2763                 :          0 :                 break;
    2764                 :            :         case ETHTOOL_GTXCSUM:
    2765                 :            :         case ETHTOOL_GRXCSUM:
    2766                 :            :         case ETHTOOL_GSG:
    2767                 :            :         case ETHTOOL_GTSO:
    2768                 :            :         case ETHTOOL_GGSO:
    2769                 :            :         case ETHTOOL_GGRO:
    2770                 :          0 :                 rc = ethtool_get_one_feature(dev, useraddr, ethcmd);
    2771                 :          0 :                 break;
    2772                 :            :         case ETHTOOL_STXCSUM:
    2773                 :            :         case ETHTOOL_SRXCSUM:
    2774                 :            :         case ETHTOOL_SSG:
    2775                 :            :         case ETHTOOL_STSO:
    2776                 :            :         case ETHTOOL_SGSO:
    2777                 :            :         case ETHTOOL_SGRO:
    2778                 :          0 :                 rc = ethtool_set_one_feature(dev, useraddr, ethcmd);
    2779                 :          0 :                 break;
    2780                 :            :         case ETHTOOL_GCHANNELS:
    2781                 :          0 :                 rc = ethtool_get_channels(dev, useraddr);
    2782                 :          0 :                 break;
    2783                 :            :         case ETHTOOL_SCHANNELS:
    2784                 :          0 :                 rc = ethtool_set_channels(dev, useraddr);
    2785                 :          0 :                 break;
    2786                 :            :         case ETHTOOL_SET_DUMP:
    2787                 :          0 :                 rc = ethtool_set_dump(dev, useraddr);
    2788                 :          0 :                 break;
    2789                 :            :         case ETHTOOL_GET_DUMP_FLAG:
    2790                 :          0 :                 rc = ethtool_get_dump_flag(dev, useraddr);
    2791                 :          0 :                 break;
    2792                 :            :         case ETHTOOL_GET_DUMP_DATA:
    2793                 :          0 :                 rc = ethtool_get_dump_data(dev, useraddr);
    2794                 :          0 :                 break;
    2795                 :            :         case ETHTOOL_GET_TS_INFO:
    2796                 :          0 :                 rc = ethtool_get_ts_info(dev, useraddr);
    2797                 :          0 :                 break;
    2798                 :            :         case ETHTOOL_GMODULEINFO:
    2799                 :          0 :                 rc = ethtool_get_module_info(dev, useraddr);
    2800                 :          0 :                 break;
    2801                 :            :         case ETHTOOL_GMODULEEEPROM:
    2802                 :          0 :                 rc = ethtool_get_module_eeprom(dev, useraddr);
    2803                 :          0 :                 break;
    2804                 :            :         case ETHTOOL_GTUNABLE:
    2805                 :          0 :                 rc = ethtool_get_tunable(dev, useraddr);
    2806                 :          0 :                 break;
    2807                 :            :         case ETHTOOL_STUNABLE:
    2808                 :          0 :                 rc = ethtool_set_tunable(dev, useraddr);
    2809                 :          0 :                 break;
    2810                 :            :         case ETHTOOL_GPHYSTATS:
    2811                 :          0 :                 rc = ethtool_get_phy_stats(dev, useraddr);
    2812                 :          0 :                 break;
    2813                 :            :         case ETHTOOL_PERQUEUE:
    2814                 :          0 :                 rc = ethtool_set_per_queue(dev, useraddr, sub_cmd);
    2815                 :          0 :                 break;
    2816                 :            :         case ETHTOOL_GLINKSETTINGS:
    2817                 :          0 :                 rc = ethtool_get_link_ksettings(dev, useraddr);
    2818                 :          0 :                 break;
    2819                 :            :         case ETHTOOL_SLINKSETTINGS:
    2820                 :          0 :                 rc = ethtool_set_link_ksettings(dev, useraddr);
    2821                 :          0 :                 break;
    2822                 :            :         case ETHTOOL_PHY_GTUNABLE:
    2823                 :          0 :                 rc = get_phy_tunable(dev, useraddr);
    2824                 :          0 :                 break;
    2825                 :            :         case ETHTOOL_PHY_STUNABLE:
    2826                 :          0 :                 rc = set_phy_tunable(dev, useraddr);
    2827                 :          0 :                 break;
    2828                 :            :         case ETHTOOL_GFECPARAM:
    2829                 :          0 :                 rc = ethtool_get_fecparam(dev, useraddr);
    2830                 :          0 :                 break;
    2831                 :            :         case ETHTOOL_SFECPARAM:
    2832                 :          0 :                 rc = ethtool_set_fecparam(dev, useraddr);
    2833                 :          0 :                 break;
    2834                 :            :         default:
    2835                 :            :                 rc = -EOPNOTSUPP;
    2836                 :            :         }
    2837                 :            : 
    2838                 :          3 :         if (dev->ethtool_ops->complete)
    2839                 :          0 :                 dev->ethtool_ops->complete(dev);
    2840                 :            : 
    2841                 :          3 :         if (old_features != dev->features)
    2842                 :          0 :                 netdev_features_change(dev);
    2843                 :            : 
    2844                 :          3 :         return rc;
    2845                 :            : }
    2846                 :            : 
    2847                 :            : struct ethtool_rx_flow_key {
    2848                 :            :         struct flow_dissector_key_basic                 basic;
    2849                 :            :         union {
    2850                 :            :                 struct flow_dissector_key_ipv4_addrs    ipv4;
    2851                 :            :                 struct flow_dissector_key_ipv6_addrs    ipv6;
    2852                 :            :         };
    2853                 :            :         struct flow_dissector_key_ports                 tp;
    2854                 :            :         struct flow_dissector_key_ip                    ip;
    2855                 :            :         struct flow_dissector_key_vlan                  vlan;
    2856                 :            :         struct flow_dissector_key_eth_addrs             eth_addrs;
    2857                 :            : } __aligned(BITS_PER_LONG / 8); /* Ensure that we can do comparisons as longs. */
    2858                 :            : 
    2859                 :            : struct ethtool_rx_flow_match {
    2860                 :            :         struct flow_dissector           dissector;
    2861                 :            :         struct ethtool_rx_flow_key      key;
    2862                 :            :         struct ethtool_rx_flow_key      mask;
    2863                 :            : };
    2864                 :            : 
    2865                 :            : struct ethtool_rx_flow_rule *
    2866                 :          0 : ethtool_rx_flow_rule_create(const struct ethtool_rx_flow_spec_input *input)
    2867                 :            : {
    2868                 :          0 :         const struct ethtool_rx_flow_spec *fs = input->fs;
    2869                 :            :         static struct in6_addr zero_addr = {};
    2870                 :            :         struct ethtool_rx_flow_match *match;
    2871                 :            :         struct ethtool_rx_flow_rule *flow;
    2872                 :            :         struct flow_action_entry *act;
    2873                 :            : 
    2874                 :          0 :         flow = kzalloc(sizeof(struct ethtool_rx_flow_rule) +
    2875                 :            :                        sizeof(struct ethtool_rx_flow_match), GFP_KERNEL);
    2876                 :          0 :         if (!flow)
    2877                 :            :                 return ERR_PTR(-ENOMEM);
    2878                 :            : 
    2879                 :            :         /* ethtool_rx supports only one single action per rule. */
    2880                 :          0 :         flow->rule = flow_rule_alloc(1);
    2881                 :          0 :         if (!flow->rule) {
    2882                 :          0 :                 kfree(flow);
    2883                 :          0 :                 return ERR_PTR(-ENOMEM);
    2884                 :            :         }
    2885                 :            : 
    2886                 :            :         match = (struct ethtool_rx_flow_match *)flow->priv;
    2887                 :          0 :         flow->rule->match.dissector       = &match->dissector;
    2888                 :          0 :         flow->rule->match.mask            = &match->mask;
    2889                 :          0 :         flow->rule->match.key             = &match->key;
    2890                 :            : 
    2891                 :          0 :         match->mask.basic.n_proto = htons(0xffff);
    2892                 :            : 
    2893                 :          0 :         switch (fs->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS)) {
    2894                 :            :         case ETHER_FLOW: {
    2895                 :            :                 const struct ethhdr *ether_spec, *ether_m_spec;
    2896                 :            : 
    2897                 :            :                 ether_spec = &fs->h_u.ether_spec;
    2898                 :            :                 ether_m_spec = &fs->m_u.ether_spec;
    2899                 :            : 
    2900                 :          0 :                 if (!is_zero_ether_addr(ether_m_spec->h_source)) {
    2901                 :            :                         ether_addr_copy(match->key.eth_addrs.src,
    2902                 :            :                                         ether_spec->h_source);
    2903                 :            :                         ether_addr_copy(match->mask.eth_addrs.src,
    2904                 :            :                                         ether_m_spec->h_source);
    2905                 :            :                 }
    2906                 :          0 :                 if (!is_zero_ether_addr(ether_m_spec->h_dest)) {
    2907                 :            :                         ether_addr_copy(match->key.eth_addrs.dst,
    2908                 :            :                                         ether_spec->h_dest);
    2909                 :            :                         ether_addr_copy(match->mask.eth_addrs.dst,
    2910                 :            :                                         ether_m_spec->h_dest);
    2911                 :            :                 }
    2912                 :          0 :                 if (ether_m_spec->h_proto) {
    2913                 :          0 :                         match->key.basic.n_proto = ether_spec->h_proto;
    2914                 :          0 :                         match->mask.basic.n_proto = ether_m_spec->h_proto;
    2915                 :            :                 }
    2916                 :            :                 }
    2917                 :            :                 break;
    2918                 :            :         case TCP_V4_FLOW:
    2919                 :            :         case UDP_V4_FLOW: {
    2920                 :            :                 const struct ethtool_tcpip4_spec *v4_spec, *v4_m_spec;
    2921                 :            : 
    2922                 :          0 :                 match->key.basic.n_proto = htons(ETH_P_IP);
    2923                 :            : 
    2924                 :            :                 v4_spec = &fs->h_u.tcp_ip4_spec;
    2925                 :            :                 v4_m_spec = &fs->m_u.tcp_ip4_spec;
    2926                 :            : 
    2927                 :          0 :                 if (v4_m_spec->ip4src) {
    2928                 :          0 :                         match->key.ipv4.src = v4_spec->ip4src;
    2929                 :          0 :                         match->mask.ipv4.src = v4_m_spec->ip4src;
    2930                 :            :                 }
    2931                 :          0 :                 if (v4_m_spec->ip4dst) {
    2932                 :          0 :                         match->key.ipv4.dst = v4_spec->ip4dst;
    2933                 :          0 :                         match->mask.ipv4.dst = v4_m_spec->ip4dst;
    2934                 :            :                 }
    2935                 :          0 :                 if (v4_m_spec->ip4src ||
    2936                 :          0 :                     v4_m_spec->ip4dst) {
    2937                 :          0 :                         match->dissector.used_keys |=
    2938                 :            :                                 BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS);
    2939                 :          0 :                         match->dissector.offset[FLOW_DISSECTOR_KEY_IPV4_ADDRS] =
    2940                 :            :                                 offsetof(struct ethtool_rx_flow_key, ipv4);
    2941                 :            :                 }
    2942                 :          0 :                 if (v4_m_spec->psrc) {
    2943                 :          0 :                         match->key.tp.src = v4_spec->psrc;
    2944                 :          0 :                         match->mask.tp.src = v4_m_spec->psrc;
    2945                 :            :                 }
    2946                 :          0 :                 if (v4_m_spec->pdst) {
    2947                 :          0 :                         match->key.tp.dst = v4_spec->pdst;
    2948                 :          0 :                         match->mask.tp.dst = v4_m_spec->pdst;
    2949                 :            :                 }
    2950                 :          0 :                 if (v4_m_spec->psrc ||
    2951                 :            :                     v4_m_spec->pdst) {
    2952                 :          0 :                         match->dissector.used_keys |=
    2953                 :            :                                 BIT(FLOW_DISSECTOR_KEY_PORTS);
    2954                 :          0 :                         match->dissector.offset[FLOW_DISSECTOR_KEY_PORTS] =
    2955                 :            :                                 offsetof(struct ethtool_rx_flow_key, tp);
    2956                 :            :                 }
    2957                 :          0 :                 if (v4_m_spec->tos) {
    2958                 :          0 :                         match->key.ip.tos = v4_spec->tos;
    2959                 :          0 :                         match->mask.ip.tos = v4_m_spec->tos;
    2960                 :          0 :                         match->dissector.used_keys |=
    2961                 :            :                                 BIT(FLOW_DISSECTOR_KEY_IP);
    2962                 :          0 :                         match->dissector.offset[FLOW_DISSECTOR_KEY_IP] =
    2963                 :            :                                 offsetof(struct ethtool_rx_flow_key, ip);
    2964                 :            :                 }
    2965                 :            :                 }
    2966                 :            :                 break;
    2967                 :            :         case TCP_V6_FLOW:
    2968                 :            :         case UDP_V6_FLOW: {
    2969                 :            :                 const struct ethtool_tcpip6_spec *v6_spec, *v6_m_spec;
    2970                 :            : 
    2971                 :          0 :                 match->key.basic.n_proto = htons(ETH_P_IPV6);
    2972                 :            : 
    2973                 :            :                 v6_spec = &fs->h_u.tcp_ip6_spec;
    2974                 :            :                 v6_m_spec = &fs->m_u.tcp_ip6_spec;
    2975                 :          0 :                 if (memcmp(v6_m_spec->ip6src, &zero_addr, sizeof(zero_addr))) {
    2976                 :          0 :                         memcpy(&match->key.ipv6.src, v6_spec->ip6src,
    2977                 :            :                                sizeof(match->key.ipv6.src));
    2978                 :          0 :                         memcpy(&match->mask.ipv6.src, v6_m_spec->ip6src,
    2979                 :            :                                sizeof(match->mask.ipv6.src));
    2980                 :            :                 }
    2981                 :          0 :                 if (memcmp(v6_m_spec->ip6dst, &zero_addr, sizeof(zero_addr))) {
    2982                 :          0 :                         memcpy(&match->key.ipv6.dst, v6_spec->ip6dst,
    2983                 :            :                                sizeof(match->key.ipv6.dst));
    2984                 :          0 :                         memcpy(&match->mask.ipv6.dst, v6_m_spec->ip6dst,
    2985                 :            :                                sizeof(match->mask.ipv6.dst));
    2986                 :            :                 }
    2987                 :          0 :                 if (memcmp(v6_m_spec->ip6src, &zero_addr, sizeof(zero_addr)) ||
    2988                 :            :                     memcmp(v6_m_spec->ip6src, &zero_addr, sizeof(zero_addr))) {
    2989                 :          0 :                         match->dissector.used_keys |=
    2990                 :            :                                 BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS);
    2991                 :          0 :                         match->dissector.offset[FLOW_DISSECTOR_KEY_IPV6_ADDRS] =
    2992                 :            :                                 offsetof(struct ethtool_rx_flow_key, ipv6);
    2993                 :            :                 }
    2994                 :          0 :                 if (v6_m_spec->psrc) {
    2995                 :          0 :                         match->key.tp.src = v6_spec->psrc;
    2996                 :          0 :                         match->mask.tp.src = v6_m_spec->psrc;
    2997                 :            :                 }
    2998                 :          0 :                 if (v6_m_spec->pdst) {
    2999                 :          0 :                         match->key.tp.dst = v6_spec->pdst;
    3000                 :          0 :                         match->mask.tp.dst = v6_m_spec->pdst;
    3001                 :            :                 }
    3002                 :          0 :                 if (v6_m_spec->psrc ||
    3003                 :            :                     v6_m_spec->pdst) {
    3004                 :          0 :                         match->dissector.used_keys |=
    3005                 :            :                                 BIT(FLOW_DISSECTOR_KEY_PORTS);
    3006                 :          0 :                         match->dissector.offset[FLOW_DISSECTOR_KEY_PORTS] =
    3007                 :            :                                 offsetof(struct ethtool_rx_flow_key, tp);
    3008                 :            :                 }
    3009                 :          0 :                 if (v6_m_spec->tclass) {
    3010                 :          0 :                         match->key.ip.tos = v6_spec->tclass;
    3011                 :          0 :                         match->mask.ip.tos = v6_m_spec->tclass;
    3012                 :          0 :                         match->dissector.used_keys |=
    3013                 :            :                                 BIT(FLOW_DISSECTOR_KEY_IP);
    3014                 :          0 :                         match->dissector.offset[FLOW_DISSECTOR_KEY_IP] =
    3015                 :            :                                 offsetof(struct ethtool_rx_flow_key, ip);
    3016                 :            :                 }
    3017                 :            :                 }
    3018                 :            :                 break;
    3019                 :            :         default:
    3020                 :            :                 ethtool_rx_flow_rule_destroy(flow);
    3021                 :          0 :                 return ERR_PTR(-EINVAL);
    3022                 :            :         }
    3023                 :            : 
    3024                 :          0 :         switch (fs->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS)) {
    3025                 :            :         case TCP_V4_FLOW:
    3026                 :            :         case TCP_V6_FLOW:
    3027                 :          0 :                 match->key.basic.ip_proto = IPPROTO_TCP;
    3028                 :          0 :                 break;
    3029                 :            :         case UDP_V4_FLOW:
    3030                 :            :         case UDP_V6_FLOW:
    3031                 :          0 :                 match->key.basic.ip_proto = IPPROTO_UDP;
    3032                 :          0 :                 break;
    3033                 :            :         }
    3034                 :          0 :         match->mask.basic.ip_proto = 0xff;
    3035                 :            : 
    3036                 :          0 :         match->dissector.used_keys |= BIT(FLOW_DISSECTOR_KEY_BASIC);
    3037                 :          0 :         match->dissector.offset[FLOW_DISSECTOR_KEY_BASIC] =
    3038                 :            :                 offsetof(struct ethtool_rx_flow_key, basic);
    3039                 :            : 
    3040                 :          0 :         if (fs->flow_type & FLOW_EXT) {
    3041                 :            :                 const struct ethtool_flow_ext *ext_h_spec = &fs->h_ext;
    3042                 :            :                 const struct ethtool_flow_ext *ext_m_spec = &fs->m_ext;
    3043                 :            : 
    3044                 :          0 :                 if (ext_m_spec->vlan_etype) {
    3045                 :          0 :                         match->key.vlan.vlan_tpid = ext_h_spec->vlan_etype;
    3046                 :          0 :                         match->mask.vlan.vlan_tpid = ext_m_spec->vlan_etype;
    3047                 :            :                 }
    3048                 :            : 
    3049                 :          0 :                 if (ext_m_spec->vlan_tci) {
    3050                 :          0 :                         match->key.vlan.vlan_id =
    3051                 :          0 :                                 ntohs(ext_h_spec->vlan_tci) & 0x0fff;
    3052                 :          0 :                         match->mask.vlan.vlan_id =
    3053                 :          0 :                                 ntohs(ext_m_spec->vlan_tci) & 0x0fff;
    3054                 :            : 
    3055                 :          0 :                         match->key.vlan.vlan_dei =
    3056                 :          0 :                                 !!(ext_h_spec->vlan_tci & htons(0x1000));
    3057                 :          0 :                         match->mask.vlan.vlan_dei =
    3058                 :          0 :                                 !!(ext_m_spec->vlan_tci & htons(0x1000));
    3059                 :            : 
    3060                 :          0 :                         match->key.vlan.vlan_priority =
    3061                 :          0 :                                 (ntohs(ext_h_spec->vlan_tci) & 0xe000) >> 13;
    3062                 :          0 :                         match->mask.vlan.vlan_priority =
    3063                 :          0 :                                 (ntohs(ext_m_spec->vlan_tci) & 0xe000) >> 13;
    3064                 :            :                 }
    3065                 :            : 
    3066                 :          0 :                 if (ext_m_spec->vlan_etype ||
    3067                 :            :                     ext_m_spec->vlan_tci) {
    3068                 :          0 :                         match->dissector.used_keys |=
    3069                 :            :                                 BIT(FLOW_DISSECTOR_KEY_VLAN);
    3070                 :          0 :                         match->dissector.offset[FLOW_DISSECTOR_KEY_VLAN] =
    3071                 :            :                                 offsetof(struct ethtool_rx_flow_key, vlan);
    3072                 :            :                 }
    3073                 :            :         }
    3074                 :          0 :         if (fs->flow_type & FLOW_MAC_EXT) {
    3075                 :            :                 const struct ethtool_flow_ext *ext_h_spec = &fs->h_ext;
    3076                 :            :                 const struct ethtool_flow_ext *ext_m_spec = &fs->m_ext;
    3077                 :            : 
    3078                 :          0 :                 memcpy(match->key.eth_addrs.dst, ext_h_spec->h_dest,
    3079                 :            :                        ETH_ALEN);
    3080                 :          0 :                 memcpy(match->mask.eth_addrs.dst, ext_m_spec->h_dest,
    3081                 :            :                        ETH_ALEN);
    3082                 :            : 
    3083                 :          0 :                 match->dissector.used_keys |=
    3084                 :            :                         BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS);
    3085                 :          0 :                 match->dissector.offset[FLOW_DISSECTOR_KEY_ETH_ADDRS] =
    3086                 :            :                         offsetof(struct ethtool_rx_flow_key, eth_addrs);
    3087                 :            :         }
    3088                 :            : 
    3089                 :          0 :         act = &flow->rule->action.entries[0];
    3090                 :          0 :         switch (fs->ring_cookie) {
    3091                 :            :         case RX_CLS_FLOW_DISC:
    3092                 :          0 :                 act->id = FLOW_ACTION_DROP;
    3093                 :          0 :                 break;
    3094                 :            :         case RX_CLS_FLOW_WAKE:
    3095                 :          0 :                 act->id = FLOW_ACTION_WAKE;
    3096                 :          0 :                 break;
    3097                 :            :         default:
    3098                 :          0 :                 act->id = FLOW_ACTION_QUEUE;
    3099                 :          0 :                 if (fs->flow_type & FLOW_RSS)
    3100                 :          0 :                         act->queue.ctx = input->rss_ctx;
    3101                 :            : 
    3102                 :          0 :                 act->queue.vf = ethtool_get_flow_spec_ring_vf(fs->ring_cookie);
    3103                 :          0 :                 act->queue.index = ethtool_get_flow_spec_ring(fs->ring_cookie);
    3104                 :          0 :                 break;
    3105                 :            :         }
    3106                 :            : 
    3107                 :          0 :         return flow;
    3108                 :            : }
    3109                 :            : EXPORT_SYMBOL(ethtool_rx_flow_rule_create);
    3110                 :            : 
    3111                 :          0 : void ethtool_rx_flow_rule_destroy(struct ethtool_rx_flow_rule *flow)
    3112                 :            : {
    3113                 :          0 :         kfree(flow->rule);
    3114                 :          0 :         kfree(flow);
    3115                 :          0 : }
    3116                 :            : EXPORT_SYMBOL(ethtool_rx_flow_rule_destroy);
    

Generated by: LCOV version 1.14