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