net/core/ethtool.c

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