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/bitops.h>
  21 #include <linux/uaccess.h>
  22 #include <linux/vmalloc.h>
  23 #include <linux/slab.h>
  24 #include <linux/rtnetlink.h>
  25 #include <linux/sched.h>
  26
  27 /*
  28  * Some useful ethtool_ops methods that're device independent.
  29  * If we find that all drivers want to do the same thing here,
  30  * we can turn these into dev_() function calls.
  31  */
  32
  33 u32 ethtool_op_get_link(struct net_device *dev)
  34 {
  35         return netif_carrier_ok(dev) ? 1 : 0;
  36 }
  37 EXPORT_SYMBOL(ethtool_op_get_link);
  38
  39 u32 ethtool_op_get_tx_csum(struct net_device *dev)
  40 {
  41         return (dev->features & NETIF_F_ALL_CSUM) != 0;
  42 }
  43 EXPORT_SYMBOL(ethtool_op_get_tx_csum);
  44
  45 int ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
  46 {
  47         if (data)
  48                 dev->features |= NETIF_F_IP_CSUM;
  49         else
  50                 dev->features &= ~NETIF_F_IP_CSUM;
  51
  52         return 0;
  53 }
  54 EXPORT_SYMBOL(ethtool_op_set_tx_csum);
  55
  56 int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)
  57 {
  58         if (data)
  59                 dev->features |= NETIF_F_HW_CSUM;
  60         else
  61                 dev->features &= ~NETIF_F_HW_CSUM;
  62
  63         return 0;
  64 }
  65 EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
  66
  67 int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)
  68 {
  69         if (data)
  70                 dev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
  71         else
  72                 dev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
  73
  74         return 0;
  75 }
  76 EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
  77
  78 u32 ethtool_op_get_sg(struct net_device *dev)
  79 {
  80         return (dev->features & NETIF_F_SG) != 0;
  81 }
  82 EXPORT_SYMBOL(ethtool_op_get_sg);
  83
  84 int ethtool_op_set_sg(struct net_device *dev, u32 data)
  85 {
  86         if (data)
  87                 dev->features |= NETIF_F_SG;
  88         else
  89                 dev->features &= ~NETIF_F_SG;
  90
  91         return 0;
  92 }
  93 EXPORT_SYMBOL(ethtool_op_set_sg);
  94
  95 u32 ethtool_op_get_tso(struct net_device *dev)
  96 {
  97         return (dev->features & NETIF_F_TSO) != 0;
  98 }
  99 EXPORT_SYMBOL(ethtool_op_get_tso);
 100
 101 int ethtool_op_set_tso(struct net_device *dev, u32 data)
 102 {
 103         if (data)
 104                 dev->features |= NETIF_F_TSO;
 105         else
 106                 dev->features &= ~NETIF_F_TSO;
 107
 108         return 0;
 109 }
 110 EXPORT_SYMBOL(ethtool_op_set_tso);
 111
 112 u32 ethtool_op_get_ufo(struct net_device *dev)
 113 {
 114         return (dev->features & NETIF_F_UFO) != 0;
 115 }
 116 EXPORT_SYMBOL(ethtool_op_get_ufo);
 117
 118 int ethtool_op_set_ufo(struct net_device *dev, u32 data)
 119 {
 120         if (data)
 121                 dev->features |= NETIF_F_UFO;
 122         else
 123                 dev->features &= ~NETIF_F_UFO;
 124         return 0;
 125 }
 126 EXPORT_SYMBOL(ethtool_op_set_ufo);
 127
 128 /* the following list of flags are the same as their associated
 129  * NETIF_F_xxx values in include/linux/netdevice.h
 130  */
 131 static const u32 flags_dup_features =
 132         (ETH_FLAG_LRO | ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN | ETH_FLAG_NTUPLE |
 133          ETH_FLAG_RXHASH);
 134
 135 u32 ethtool_op_get_flags(struct net_device *dev)
 136 {
 137         /* in the future, this function will probably contain additional
 138          * handling for flags which are not so easily handled
 139          * by a simple masking operation
 140          */
 141
 142         return dev->features & flags_dup_features;
 143 }
 144 EXPORT_SYMBOL(ethtool_op_get_flags);
 145
 146 /* Check if device can enable (or disable) particular feature coded in "data"
 147  * argument. Flags "supported" describe features that can be toggled by device.
 148  * If feature can not be toggled, it state (enabled or disabled) must match
 149  * hardcoded device features state, otherwise flags are marked as invalid.
 150  */
 151 bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported)
 152 {
 153         u32 features = dev->features & flags_dup_features;
 154         /* "data" can contain only flags_dup_features bits,
 155          * see __ethtool_set_flags */
 156
 157         return (features & ~supported) != (data & ~supported);
 158 }
 159 EXPORT_SYMBOL(ethtool_invalid_flags);
 160
 161 int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported)
 162 {
 163         if (ethtool_invalid_flags(dev, data, supported))
 164                 return -EINVAL;
 165
 166         dev->features = ((dev->features & ~flags_dup_features) |
 167                          (data & flags_dup_features));
 168         return 0;
 169 }
 170 EXPORT_SYMBOL(ethtool_op_set_flags);
 171
 172 /* Handlers for each ethtool command */
 173
 174 #define ETHTOOL_DEV_FEATURE_WORDS       1
 175
 176 static void ethtool_get_features_compat(struct net_device *dev,
 177         struct ethtool_get_features_block *features)
 178 {
 179         if (!dev->ethtool_ops)
 180                 return;
 181
 182         /* getting RX checksum */
 183         if (dev->ethtool_ops->get_rx_csum)
 184                 if (dev->ethtool_ops->get_rx_csum(dev))
 185                         features[0].active |= NETIF_F_RXCSUM;
 186
 187         /* mark legacy-changeable features */
 188         if (dev->ethtool_ops->set_sg)
 189                 features[0].available |= NETIF_F_SG;
 190         if (dev->ethtool_ops->set_tx_csum)
 191                 features[0].available |= NETIF_F_ALL_CSUM;
 192         if (dev->ethtool_ops->set_tso)
 193                 features[0].available |= NETIF_F_ALL_TSO;
 194         if (dev->ethtool_ops->set_rx_csum)
 195                 features[0].available |= NETIF_F_RXCSUM;
 196         if (dev->ethtool_ops->set_flags)
 197                 features[0].available |= flags_dup_features;
 198 }
 199
 200 static int ethtool_set_feature_compat(struct net_device *dev,
 201         int (*legacy_set)(struct net_device *, u32),
 202         struct ethtool_set_features_block *features, u32 mask)
 203 {
 204         u32 do_set;
 205
 206         if (!legacy_set)
 207                 return 0;
 208
 209         if (!(features[0].valid & mask))
 210                 return 0;
 211
 212         features[0].valid &= ~mask;
 213
 214         do_set = !!(features[0].requested & mask);
 215
 216         if (legacy_set(dev, do_set) < 0)
 217                 netdev_info(dev,
 218                         "Legacy feature change (%s) failed for 0x%08x\n",
 219                         do_set ? "set" : "clear", mask);
 220
 221         return 1;
 222 }
 223
 224 static int ethtool_set_flags_compat(struct net_device *dev,
 225         int (*legacy_set)(struct net_device *, u32),
 226         struct ethtool_set_features_block *features, u32 mask)
 227 {
 228         u32 value;
 229
 230         if (!legacy_set)
 231                 return 0;
 232
 233         if (!(features[0].valid & mask))
 234                 return 0;
 235
 236         value = dev->features & ~features[0].valid;
 237         value |= features[0].requested;
 238
 239         features[0].valid &= ~mask;
 240
 241         if (legacy_set(dev, value & mask) < 0)
 242                 netdev_info(dev, "Legacy flags change failed\n");
 243
 244         return 1;
 245 }
 246
 247 static int ethtool_set_features_compat(struct net_device *dev,
 248         struct ethtool_set_features_block *features)
 249 {
 250         int compat;
 251
 252         if (!dev->ethtool_ops)
 253                 return 0;
 254
 255         compat  = ethtool_set_feature_compat(dev, dev->ethtool_ops->set_sg,
 256                 features, NETIF_F_SG);
 257         compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tx_csum,
 258                 features, NETIF_F_ALL_CSUM);
 259         compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tso,
 260                 features, NETIF_F_ALL_TSO);
 261         compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_rx_csum,
 262                 features, NETIF_F_RXCSUM);
 263         compat |= ethtool_set_flags_compat(dev, dev->ethtool_ops->set_flags,
 264                 features, flags_dup_features);
 265
 266         return compat;
 267 }
 268
 269 static int ethtool_get_features(struct net_device *dev, void __user *useraddr)
 270 {
 271         struct ethtool_gfeatures cmd = {
 272                 .cmd = ETHTOOL_GFEATURES,
 273                 .size = ETHTOOL_DEV_FEATURE_WORDS,
 274         };
 275         struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS] = {
 276                 {
 277                         .available = dev->hw_features,
 278                         .requested = dev->wanted_features,
 279                         .active = dev->features,
 280                         .never_changed = NETIF_F_NEVER_CHANGE,
 281                 },
 282         };
 283         u32 __user *sizeaddr;
 284         u32 copy_size;
 285
 286         ethtool_get_features_compat(dev, features);
 287
 288         sizeaddr = useraddr + offsetof(struct ethtool_gfeatures, size);
 289         if (get_user(copy_size, sizeaddr))
 290                 return -EFAULT;
 291
 292         if (copy_size > ETHTOOL_DEV_FEATURE_WORDS)
 293                 copy_size = ETHTOOL_DEV_FEATURE_WORDS;
 294
 295         if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
 296                 return -EFAULT;
 297         useraddr += sizeof(cmd);
 298         if (copy_to_user(useraddr, features, copy_size * sizeof(*features)))
 299                 return -EFAULT;
 300
 301         return 0;
 302 }
 303
 304 static int ethtool_set_features(struct net_device *dev, void __user *useraddr)
 305 {
 306         struct ethtool_sfeatures cmd;
 307         struct ethtool_set_features_block features[ETHTOOL_DEV_FEATURE_WORDS];
 308         int ret = 0;
 309
 310         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
 311                 return -EFAULT;
 312         useraddr += sizeof(cmd);
 313
 314         if (cmd.size != ETHTOOL_DEV_FEATURE_WORDS)
 315                 return -EINVAL;
 316
 317         if (copy_from_user(features, useraddr, sizeof(features)))
 318                 return -EFAULT;
 319
 320         if (features[0].valid & ~NETIF_F_ETHTOOL_BITS)
 321                 return -EINVAL;
 322
 323         if (ethtool_set_features_compat(dev, features))
 324                 ret |= ETHTOOL_F_COMPAT;
 325
 326         if (features[0].valid & ~dev->hw_features) {
 327                 features[0].valid &= dev->hw_features;
 328                 ret |= ETHTOOL_F_UNSUPPORTED;
 329         }
 330
 331         dev->wanted_features &= ~features[0].valid;
 332         dev->wanted_features |= features[0].valid & features[0].requested;
 333         __netdev_update_features(dev);
 334
 335         if ((dev->wanted_features ^ dev->features) & features[0].valid)
 336                 ret |= ETHTOOL_F_WISH;
 337
 338         return ret;
 339 }
 340
 341 static const char netdev_features_strings[ETHTOOL_DEV_FEATURE_WORDS * 32][ETH_GSTRING_LEN] = {
 342         /* NETIF_F_SG */              "tx-scatter-gather",
 343         /* NETIF_F_IP_CSUM */         "tx-checksum-ipv4",
 344         /* NETIF_F_NO_CSUM */         "tx-checksum-unneeded",
 345         /* NETIF_F_HW_CSUM */         "tx-checksum-ip-generic",
 346         /* NETIF_F_IPV6_CSUM */       "tx-checksum-ipv6",
 347         /* NETIF_F_HIGHDMA */         "highdma",
 348         /* NETIF_F_FRAGLIST */        "tx-scatter-gather-fraglist",
 349         /* NETIF_F_HW_VLAN_TX */      "tx-vlan-hw-insert",
 350
 351         /* NETIF_F_HW_VLAN_RX */      "rx-vlan-hw-parse",
 352         /* NETIF_F_HW_VLAN_FILTER */  "rx-vlan-filter",
 353         /* NETIF_F_VLAN_CHALLENGED */ "vlan-challenged",
 354         /* NETIF_F_GSO */             "tx-generic-segmentation",
 355         /* NETIF_F_LLTX */            "tx-lockless",
 356         /* NETIF_F_NETNS_LOCAL */     "netns-local",
 357         /* NETIF_F_GRO */             "rx-gro",
 358         /* NETIF_F_LRO */             "rx-lro",
 359
 360         /* NETIF_F_TSO */             "tx-tcp-segmentation",
 361         /* NETIF_F_UFO */             "tx-udp-fragmentation",
 362         /* NETIF_F_GSO_ROBUST */      "tx-gso-robust",
 363         /* NETIF_F_TSO_ECN */         "tx-tcp-ecn-segmentation",
 364         /* NETIF_F_TSO6 */            "tx-tcp6-segmentation",
 365         /* NETIF_F_FSO */             "tx-fcoe-segmentation",
 366         "",
 367         "",
 368
 369         /* NETIF_F_FCOE_CRC */        "tx-checksum-fcoe-crc",
 370         /* NETIF_F_SCTP_CSUM */       "tx-checksum-sctp",
 371         /* NETIF_F_FCOE_MTU */        "fcoe-mtu",
 372         /* NETIF_F_NTUPLE */          "rx-ntuple-filter",
 373         /* NETIF_F_RXHASH */          "rx-hashing",
 374         /* NETIF_F_RXCSUM */          "rx-checksum",
 375         /* NETIF_F_NOCACHE_COPY */    "tx-nocache-copy",
 376         /* NETIF_F_LOOPBACK */        "loopback",
 377 };
 378
 379 static int __ethtool_get_sset_count(struct net_device *dev, int sset)
 380 {
 381         const struct ethtool_ops *ops = dev->ethtool_ops;
 382
 383         if (sset == ETH_SS_FEATURES)
 384                 return ARRAY_SIZE(netdev_features_strings);
 385
 386         if (ops && ops->get_sset_count && ops->get_strings)
 387                 return ops->get_sset_count(dev, sset);
 388         else
 389                 return -EOPNOTSUPP;
 390 }
 391
 392 static void __ethtool_get_strings(struct net_device *dev,
 393         u32 stringset, u8 *data)
 394 {
 395         const struct ethtool_ops *ops = dev->ethtool_ops;
 396
 397         if (stringset == ETH_SS_FEATURES)
 398                 memcpy(data, netdev_features_strings,
 399                         sizeof(netdev_features_strings));
 400         else
 401                 /* ops->get_strings is valid because checked earlier */
 402                 ops->get_strings(dev, stringset, data);
 403 }
 404
 405 static u32 ethtool_get_feature_mask(u32 eth_cmd)
 406 {
 407         /* feature masks of legacy discrete ethtool ops */
 408
 409         switch (eth_cmd) {
 410         case ETHTOOL_GTXCSUM:
 411         case ETHTOOL_STXCSUM:
 412                 return NETIF_F_ALL_CSUM | NETIF_F_SCTP_CSUM;
 413         case ETHTOOL_GRXCSUM:
 414         case ETHTOOL_SRXCSUM:
 415                 return NETIF_F_RXCSUM;
 416         case ETHTOOL_GSG:
 417         case ETHTOOL_SSG:
 418                 return NETIF_F_SG;
 419         case ETHTOOL_GTSO:
 420         case ETHTOOL_STSO:
 421                 return NETIF_F_ALL_TSO;
 422         case ETHTOOL_GUFO:
 423         case ETHTOOL_SUFO:
 424                 return NETIF_F_UFO;
 425         case ETHTOOL_GGSO:
 426         case ETHTOOL_SGSO:
 427                 return NETIF_F_GSO;
 428         case ETHTOOL_GGRO:
 429         case ETHTOOL_SGRO:
 430                 return NETIF_F_GRO;
 431         default:
 432                 BUG();
 433         }
 434 }
 435
 436 static void *__ethtool_get_one_feature_actor(struct net_device *dev, u32 ethcmd)
 437 {
 438         const struct ethtool_ops *ops = dev->ethtool_ops;
 439
 440         if (!ops)
 441                 return NULL;
 442
 443         switch (ethcmd) {
 444         case ETHTOOL_GTXCSUM:
 445                 return ops->get_tx_csum;
 446         case ETHTOOL_GRXCSUM:
 447                 return ops->get_rx_csum;
 448         case ETHTOOL_SSG:
 449                 return ops->get_sg;
 450         case ETHTOOL_STSO:
 451                 return ops->get_tso;
 452         case ETHTOOL_SUFO:
 453                 return ops->get_ufo;
 454         default:
 455                 return NULL;
 456         }
 457 }
 458
 459 static u32 __ethtool_get_rx_csum_oldbug(struct net_device *dev)
 460 {
 461         return !!(dev->features & NETIF_F_ALL_CSUM);
 462 }
 463
 464 static int ethtool_get_one_feature(struct net_device *dev,
 465         char __user *useraddr, u32 ethcmd)
 466 {
 467         u32 mask = ethtool_get_feature_mask(ethcmd);
 468         struct ethtool_value edata = {
 469                 .cmd = ethcmd,
 470                 .data = !!(dev->features & mask),
 471         };
 472
 473         /* compatibility with discrete get_ ops */
 474         if (!(dev->hw_features & mask)) {
 475                 u32 (*actor)(struct net_device *);
 476
 477                 actor = __ethtool_get_one_feature_actor(dev, ethcmd);
 478
 479                 /* bug compatibility with old get_rx_csum */
 480                 if (ethcmd == ETHTOOL_GRXCSUM && !actor)
 481                         actor = __ethtool_get_rx_csum_oldbug;
 482
 483                 if (actor)
 484                         edata.data = actor(dev);
 485         }
 486
 487         if (copy_to_user(useraddr, &edata, sizeof(edata)))
 488                 return -EFAULT;
 489         return 0;
 490 }
 491
 492 static int __ethtool_set_tx_csum(struct net_device *dev, u32 data);
 493 static int __ethtool_set_rx_csum(struct net_device *dev, u32 data);
 494 static int __ethtool_set_sg(struct net_device *dev, u32 data);
 495 static int __ethtool_set_tso(struct net_device *dev, u32 data);
 496 static int __ethtool_set_ufo(struct net_device *dev, u32 data);
 497
 498 static int ethtool_set_one_feature(struct net_device *dev,
 499         void __user *useraddr, u32 ethcmd)
 500 {
 501         struct ethtool_value edata;
 502         u32 mask;
 503
 504         if (copy_from_user(&edata, useraddr, sizeof(edata)))
 505                 return -EFAULT;
 506
 507         mask = ethtool_get_feature_mask(ethcmd);
 508         mask &= dev->hw_features;
 509         if (mask) {
 510                 if (edata.data)
 511                         dev->wanted_features |= mask;
 512                 else
 513                         dev->wanted_features &= ~mask;
 514
 515                 __netdev_update_features(dev);
 516                 return 0;
 517         }
 518
 519         /* Driver is not converted to ndo_fix_features or does not
 520          * support changing this offload. In the latter case it won't
 521          * have corresponding ethtool_ops field set.
 522          *
 523          * Following part is to be removed after all drivers advertise
 524          * their changeable features in netdev->hw_features and stop
 525          * using discrete offload setting ops.
 526          */
 527
 528         switch (ethcmd) {
 529         case ETHTOOL_STXCSUM:
 530                 return __ethtool_set_tx_csum(dev, edata.data);
 531         case ETHTOOL_SRXCSUM:
 532                 return __ethtool_set_rx_csum(dev, edata.data);
 533         case ETHTOOL_SSG:
 534                 return __ethtool_set_sg(dev, edata.data);
 535         case ETHTOOL_STSO:
 536                 return __ethtool_set_tso(dev, edata.data);
 537         case ETHTOOL_SUFO:
 538                 return __ethtool_set_ufo(dev, edata.data);
 539         default:
 540                 return -EOPNOTSUPP;
 541         }
 542 }
 543
 544 int __ethtool_set_flags(struct net_device *dev, u32 data)
 545 {
 546         u32 changed;
 547
 548         if (data & ~flags_dup_features)
 549                 return -EINVAL;
 550
 551         /* legacy set_flags() op */
 552         if (dev->ethtool_ops->set_flags) {
 553                 if (unlikely(dev->hw_features & flags_dup_features))
 554                         netdev_warn(dev,
 555                                 "driver BUG: mixed hw_features and set_flags()\n");
 556                 return dev->ethtool_ops->set_flags(dev, data);
 557         }
 558
 559         /* allow changing only bits set in hw_features */
 560         changed = (data ^ dev->features) & flags_dup_features;
 561         if (changed & ~dev->hw_features)
 562                 return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP;
 563
 564         dev->wanted_features =
 565                 (dev->wanted_features & ~changed) | (data & dev->hw_features);
 566
 567         __netdev_update_features(dev);
 568
 569         return 0;
 570 }
 571
 572 int __ethtool_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 573 {
 574         ASSERT_RTNL();
 575
 576         if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
 577                 return -EOPNOTSUPP;
 578
 579         memset(cmd, 0, sizeof(struct ethtool_cmd));
 580         cmd->cmd = ETHTOOL_GSET;
 581         return dev->ethtool_ops->get_settings(dev, cmd);
 582 }
 583 EXPORT_SYMBOL(__ethtool_get_settings);
 584
 585 static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
 586 {
 587         int err;
 588         struct ethtool_cmd cmd;
 589
 590         err = __ethtool_get_settings(dev, &cmd);
 591         if (err < 0)
 592                 return err;
 593
 594         if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
 595                 return -EFAULT;
 596         return 0;
 597 }
 598
 599 static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
 600 {
 601         struct ethtool_cmd cmd;
 602
 603         if (!dev->ethtool_ops->set_settings)
 604                 return -EOPNOTSUPP;
 605
 606         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
 607                 return -EFAULT;
 608
 609         return dev->ethtool_ops->set_settings(dev, &cmd);
 610 }
 611
 612 static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
 613                                                   void __user *useraddr)
 614 {
 615         struct ethtool_drvinfo info;
 616         const struct ethtool_ops *ops = dev->ethtool_ops;
 617
 618         memset(&info, 0, sizeof(info));
 619         info.cmd = ETHTOOL_GDRVINFO;
 620         if (ops && ops->get_drvinfo) {
 621                 ops->get_drvinfo(dev, &info);
 622         } else if (dev->dev.parent && dev->dev.parent->driver) {
 623                 strlcpy(info.bus_info, dev_name(dev->dev.parent),
 624                         sizeof(info.bus_info));
 625                 strlcpy(info.driver, dev->dev.parent->driver->name,
 626                         sizeof(info.driver));
 627         } else {
 628                 return -EOPNOTSUPP;
 629         }
 630
 631         /*
 632          * this method of obtaining string set info is deprecated;
 633          * Use ETHTOOL_GSSET_INFO instead.
 634          */
 635         if (ops && ops->get_sset_count) {
 636                 int rc;
 637
 638                 rc = ops->get_sset_count(dev, ETH_SS_TEST);
 639                 if (rc >= 0)
 640                         info.testinfo_len = rc;
 641                 rc = ops->get_sset_count(dev, ETH_SS_STATS);
 642                 if (rc >= 0)
 643                         info.n_stats = rc;
 644                 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
 645                 if (rc >= 0)
 646                         info.n_priv_flags = rc;
 647         }
 648         if (ops && ops->get_regs_len)
 649                 info.regdump_len = ops->get_regs_len(dev);
 650         if (ops && ops->get_eeprom_len)
 651                 info.eedump_len = ops->get_eeprom_len(dev);
 652
 653         if (copy_to_user(useraddr, &info, sizeof(info)))
 654                 return -EFAULT;
 655         return 0;
 656 }
 657
 658 static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
 659                                                     void __user *useraddr)
 660 {
 661         struct ethtool_sset_info info;
 662         u64 sset_mask;
 663         int i, idx = 0, n_bits = 0, ret, rc;
 664         u32 *info_buf = NULL;
 665
 666         if (copy_from_user(&info, useraddr, sizeof(info)))
 667                 return -EFAULT;
 668
 669         /* store copy of mask, because we zero struct later on */
 670         sset_mask = info.sset_mask;
 671         if (!sset_mask)
 672                 return 0;
 673
 674         /* calculate size of return buffer */
 675         n_bits = hweight64(sset_mask);
 676
 677         memset(&info, 0, sizeof(info));
 678         info.cmd = ETHTOOL_GSSET_INFO;
 679
 680         info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
 681         if (!info_buf)
 682                 return -ENOMEM;
 683
 684         /*
 685          * fill return buffer based on input bitmask and successful
 686          * get_sset_count return
 687          */
 688         for (i = 0; i < 64; i++) {
 689                 if (!(sset_mask & (1ULL << i)))
 690                         continue;
 691
 692                 rc = __ethtool_get_sset_count(dev, i);
 693                 if (rc >= 0) {
 694                         info.sset_mask |= (1ULL << i);
 695                         info_buf[idx++] = rc;
 696                 }
 697         }
 698
 699         ret = -EFAULT;
 700         if (copy_to_user(useraddr, &info, sizeof(info)))
 701                 goto out;
 702
 703         useraddr += offsetof(struct ethtool_sset_info, data);
 704         if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
 705                 goto out;
 706
 707         ret = 0;
 708
 709 out:
 710         kfree(info_buf);
 711         return ret;
 712 }
 713
 714 static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
 715                                                 u32 cmd, void __user *useraddr)
 716 {
 717         struct ethtool_rxnfc info;
 718         size_t info_size = sizeof(info);
 719
 720         if (!dev->ethtool_ops->set_rxnfc)
 721                 return -EOPNOTSUPP;
 722
 723         /* struct ethtool_rxnfc was originally defined for
 724          * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
 725          * members.  User-space might still be using that
 726          * definition. */
 727         if (cmd == ETHTOOL_SRXFH)
 728                 info_size = (offsetof(struct ethtool_rxnfc, data) +
 729                              sizeof(info.data));
 730
 731         if (copy_from_user(&info, useraddr, info_size))
 732                 return -EFAULT;
 733
 734         return dev->ethtool_ops->set_rxnfc(dev, &info);
 735 }
 736
 737 static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
 738                                                 u32 cmd, void __user *useraddr)
 739 {
 740         struct ethtool_rxnfc info;
 741         size_t info_size = sizeof(info);
 742         const struct ethtool_ops *ops = dev->ethtool_ops;
 743         int ret;
 744         void *rule_buf = NULL;
 745
 746         if (!ops->get_rxnfc)
 747                 return -EOPNOTSUPP;
 748
 749         /* struct ethtool_rxnfc was originally defined for
 750          * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
 751          * members.  User-space might still be using that
 752          * definition. */
 753         if (cmd == ETHTOOL_GRXFH)
 754                 info_size = (offsetof(struct ethtool_rxnfc, data) +
 755                              sizeof(info.data));
 756
 757         if (copy_from_user(&info, useraddr, info_size))
 758                 return -EFAULT;
 759
 760         if (info.cmd == ETHTOOL_GRXCLSRLALL) {
 761                 if (info.rule_cnt > 0) {
 762                         if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
 763                                 rule_buf = kzalloc(info.rule_cnt * sizeof(u32),
 764                                                    GFP_USER);
 765                         if (!rule_buf)
 766                                 return -ENOMEM;
 767                 }
 768         }
 769
 770         ret = ops->get_rxnfc(dev, &info, rule_buf);
 771         if (ret < 0)
 772                 goto err_out;
 773
 774         ret = -EFAULT;
 775         if (copy_to_user(useraddr, &info, info_size))
 776                 goto err_out;
 777
 778         if (rule_buf) {
 779                 useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
 780                 if (copy_to_user(useraddr, rule_buf,
 781                                  info.rule_cnt * sizeof(u32)))
 782                         goto err_out;
 783         }
 784         ret = 0;
 785
 786 err_out:
 787         kfree(rule_buf);
 788
 789         return ret;
 790 }
 791
 792 static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,
 793                                                      void __user *useraddr)
 794 {
 795         struct ethtool_rxfh_indir *indir;
 796         u32 table_size;
 797         size_t full_size;
 798         int ret;
 799
 800         if (!dev->ethtool_ops->get_rxfh_indir)
 801                 return -EOPNOTSUPP;
 802
 803         if (copy_from_user(&table_size,
 804                            useraddr + offsetof(struct ethtool_rxfh_indir, size),
 805                            sizeof(table_size)))
 806                 return -EFAULT;
 807
 808         if (table_size >
 809             (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
 810                 return -ENOMEM;
 811         full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
 812         indir = kzalloc(full_size, GFP_USER);
 813         if (!indir)
 814                 return -ENOMEM;
 815
 816         indir->cmd = ETHTOOL_GRXFHINDIR;
 817         indir->size = table_size;
 818         ret = dev->ethtool_ops->get_rxfh_indir(dev, indir);
 819         if (ret)
 820                 goto out;
 821
 822         if (copy_to_user(useraddr, indir, full_size))
 823                 ret = -EFAULT;
 824
 825 out:
 826         kfree(indir);
 827         return ret;
 828 }
 829
 830 static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,
 831                                                      void __user *useraddr)
 832 {
 833         struct ethtool_rxfh_indir *indir;
 834         u32 table_size;
 835         size_t full_size;
 836         int ret;
 837
 838         if (!dev->ethtool_ops->set_rxfh_indir)
 839                 return -EOPNOTSUPP;
 840
 841         if (copy_from_user(&table_size,
 842                            useraddr + offsetof(struct ethtool_rxfh_indir, size),
 843                            sizeof(table_size)))
 844                 return -EFAULT;
 845
 846         if (table_size >
 847             (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
 848                 return -ENOMEM;
 849         full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
 850         indir = kmalloc(full_size, GFP_USER);
 851         if (!indir)
 852                 return -ENOMEM;
 853
 854         if (copy_from_user(indir, useraddr, full_size)) {
 855                 ret = -EFAULT;
 856                 goto out;
 857         }
 858
 859         ret = dev->ethtool_ops->set_rxfh_indir(dev, indir);
 860
 861 out:
 862         kfree(indir);
 863         return ret;
 864 }
 865
 866 /*
 867  * ethtool does not (or did not) set masks for flow parameters that are
 868  * not specified, so if both value and mask are 0 then this must be
 869  * treated as equivalent to a mask with all bits set.  Implement that
 870  * here rather than in drivers.
 871  */
 872 static void rx_ntuple_fix_masks(struct ethtool_rx_ntuple_flow_spec *fs)
 873 {
 874         struct ethtool_tcpip4_spec *entry = &fs->h_u.tcp_ip4_spec;
 875         struct ethtool_tcpip4_spec *mask = &fs->m_u.tcp_ip4_spec;
 876
 877         if (fs->flow_type != TCP_V4_FLOW &&
 878             fs->flow_type != UDP_V4_FLOW &&
 879             fs->flow_type != SCTP_V4_FLOW)
 880                 return;
 881
 882         if (!(entry->ip4src | mask->ip4src))
 883                 mask->ip4src = htonl(0xffffffff);
 884         if (!(entry->ip4dst | mask->ip4dst))
 885                 mask->ip4dst = htonl(0xffffffff);
 886         if (!(entry->psrc | mask->psrc))
 887                 mask->psrc = htons(0xffff);
 888         if (!(entry->pdst | mask->pdst))
 889                 mask->pdst = htons(0xffff);
 890         if (!(entry->tos | mask->tos))
 891                 mask->tos = 0xff;
 892         if (!(fs->vlan_tag | fs->vlan_tag_mask))
 893                 fs->vlan_tag_mask = 0xffff;
 894         if (!(fs->data | fs->data_mask))
 895                 fs->data_mask = 0xffffffffffffffffULL;
 896 }
 897
 898 static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
 899                                                     void __user *useraddr)
 900 {
 901         struct ethtool_rx_ntuple cmd;
 902         const struct ethtool_ops *ops = dev->ethtool_ops;
 903
 904         if (!ops->set_rx_ntuple)
 905                 return -EOPNOTSUPP;
 906
 907         if (!(dev->features & NETIF_F_NTUPLE))
 908                 return -EINVAL;
 909
 910         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
 911                 return -EFAULT;
 912
 913         rx_ntuple_fix_masks(&cmd.fs);
 914
 915         return ops->set_rx_ntuple(dev, &cmd);
 916 }
 917
 918 static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
 919 {
 920         struct ethtool_regs regs;
 921         const struct ethtool_ops *ops = dev->ethtool_ops;
 922         void *regbuf;
 923         int reglen, ret;
 924
 925         if (!ops->get_regs || !ops->get_regs_len)
 926                 return -EOPNOTSUPP;
 927
 928         if (copy_from_user(&regs, useraddr, sizeof(regs)))
 929                 return -EFAULT;
 930
 931         reglen = ops->get_regs_len(dev);
 932         if (regs.len > reglen)
 933                 regs.len = reglen;
 934
 935         regbuf = vzalloc(reglen);
 936         if (reglen && !regbuf)
 937                 return -ENOMEM;
 938
 939         ops->get_regs(dev, &regs, regbuf);
 940
 941         ret = -EFAULT;
 942         if (copy_to_user(useraddr, &regs, sizeof(regs)))
 943                 goto out;
 944         useraddr += offsetof(struct ethtool_regs, data);
 945         if (regbuf && copy_to_user(useraddr, regbuf, regs.len))
 946                 goto out;
 947         ret = 0;
 948
 949  out:
 950         vfree(regbuf);
 951         return ret;
 952 }
 953
 954 static int ethtool_reset(struct net_device *dev, char __user *useraddr)
 955 {
 956         struct ethtool_value reset;
 957         int ret;
 958
 959         if (!dev->ethtool_ops->reset)
 960                 return -EOPNOTSUPP;
 961
 962         if (copy_from_user(&reset, useraddr, sizeof(reset)))
 963                 return -EFAULT;
 964
 965         ret = dev->ethtool_ops->reset(dev, &reset.data);
 966         if (ret)
 967                 return ret;
 968
 969         if (copy_to_user(useraddr, &reset, sizeof(reset)))
 970                 return -EFAULT;
 971         return 0;
 972 }
 973
 974 static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
 975 {
 976         struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
 977
 978         if (!dev->ethtool_ops->get_wol)
 979                 return -EOPNOTSUPP;
 980
 981         dev->ethtool_ops->get_wol(dev, &wol);
 982
 983         if (copy_to_user(useraddr, &wol, sizeof(wol)))
 984                 return -EFAULT;
 985         return 0;
 986 }
 987
 988 static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
 989 {
 990         struct ethtool_wolinfo wol;
 991
 992         if (!dev->ethtool_ops->set_wol)
 993                 return -EOPNOTSUPP;
 994
 995         if (copy_from_user(&wol, useraddr, sizeof(wol)))
 996                 return -EFAULT;
 997
 998         return dev->ethtool_ops->set_wol(dev, &wol);
 999 }
1000
1001 static int ethtool_nway_reset(struct net_device *dev)
1002 {
1003         if (!dev->ethtool_ops->nway_reset)
1004                 return -EOPNOTSUPP;
1005
1006         return dev->ethtool_ops->nway_reset(dev);
1007 }
1008
1009 static int ethtool_get_link(struct net_device *dev, char __user *useraddr)
1010 {
1011         struct ethtool_value edata = { .cmd = ETHTOOL_GLINK };
1012
1013         if (!dev->ethtool_ops->get_link)
1014                 return -EOPNOTSUPP;
1015
1016         edata.data = netif_running(dev) && dev->ethtool_ops->get_link(dev);
1017
1018         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1019                 return -EFAULT;
1020         return 0;
1021 }
1022
1023 static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
1024 {
1025         struct ethtool_eeprom eeprom;
1026         const struct ethtool_ops *ops = dev->ethtool_ops;
1027         void __user *userbuf = useraddr + sizeof(eeprom);
1028         u32 bytes_remaining;
1029         u8 *data;
1030         int ret = 0;
1031
1032         if (!ops->get_eeprom || !ops->get_eeprom_len)
1033                 return -EOPNOTSUPP;
1034
1035         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1036                 return -EFAULT;
1037
1038         /* Check for wrap and zero */
1039         if (eeprom.offset + eeprom.len <= eeprom.offset)
1040                 return -EINVAL;
1041
1042         /* Check for exceeding total eeprom len */
1043         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1044                 return -EINVAL;
1045
1046         data = kmalloc(PAGE_SIZE, GFP_USER);
1047         if (!data)
1048                 return -ENOMEM;
1049
1050         bytes_remaining = eeprom.len;
1051         while (bytes_remaining > 0) {
1052                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
1053
1054                 ret = ops->get_eeprom(dev, &eeprom, data);
1055                 if (ret)
1056                         break;
1057                 if (copy_to_user(userbuf, data, eeprom.len)) {
1058                         ret = -EFAULT;
1059                         break;
1060                 }
1061                 userbuf += eeprom.len;
1062                 eeprom.offset += eeprom.len;
1063                 bytes_remaining -= eeprom.len;
1064         }
1065
1066         eeprom.len = userbuf - (useraddr + sizeof(eeprom));
1067         eeprom.offset -= eeprom.len;
1068         if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
1069                 ret = -EFAULT;
1070
1071         kfree(data);
1072         return ret;
1073 }
1074
1075 static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
1076 {
1077         struct ethtool_eeprom eeprom;
1078         const struct ethtool_ops *ops = dev->ethtool_ops;
1079         void __user *userbuf = useraddr + sizeof(eeprom);
1080         u32 bytes_remaining;
1081         u8 *data;
1082         int ret = 0;
1083
1084         if (!ops->set_eeprom || !ops->get_eeprom_len)
1085                 return -EOPNOTSUPP;
1086
1087         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1088                 return -EFAULT;
1089
1090         /* Check for wrap and zero */
1091         if (eeprom.offset + eeprom.len <= eeprom.offset)
1092                 return -EINVAL;
1093
1094         /* Check for exceeding total eeprom len */
1095         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1096                 return -EINVAL;
1097
1098         data = kmalloc(PAGE_SIZE, GFP_USER);
1099         if (!data)
1100                 return -ENOMEM;
1101
1102         bytes_remaining = eeprom.len;
1103         while (bytes_remaining > 0) {
1104                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
1105
1106                 if (copy_from_user(data, userbuf, eeprom.len)) {
1107                         ret = -EFAULT;
1108                         break;
1109                 }
1110                 ret = ops->set_eeprom(dev, &eeprom, data);
1111                 if (ret)
1112                         break;
1113                 userbuf += eeprom.len;
1114                 eeprom.offset += eeprom.len;
1115                 bytes_remaining -= eeprom.len;
1116         }
1117
1118         kfree(data);
1119         return ret;
1120 }
1121
1122 static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
1123                                                    void __user *useraddr)
1124 {
1125         struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
1126
1127         if (!dev->ethtool_ops->get_coalesce)
1128                 return -EOPNOTSUPP;
1129
1130         dev->ethtool_ops->get_coalesce(dev, &coalesce);
1131
1132         if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
1133                 return -EFAULT;
1134         return 0;
1135 }
1136
1137 static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
1138                                                    void __user *useraddr)
1139 {
1140         struct ethtool_coalesce coalesce;
1141
1142         if (!dev->ethtool_ops->set_coalesce)
1143                 return -EOPNOTSUPP;
1144
1145         if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
1146                 return -EFAULT;
1147
1148         return dev->ethtool_ops->set_coalesce(dev, &coalesce);
1149 }
1150
1151 static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
1152 {
1153         struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
1154
1155         if (!dev->ethtool_ops->get_ringparam)
1156                 return -EOPNOTSUPP;
1157
1158         dev->ethtool_ops->get_ringparam(dev, &ringparam);
1159
1160         if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
1161                 return -EFAULT;
1162         return 0;
1163 }
1164
1165 static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
1166 {
1167         struct ethtool_ringparam ringparam;
1168
1169         if (!dev->ethtool_ops->set_ringparam)
1170                 return -EOPNOTSUPP;
1171
1172         if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
1173                 return -EFAULT;
1174
1175         return dev->ethtool_ops->set_ringparam(dev, &ringparam);
1176 }
1177
1178 static noinline_for_stack int ethtool_get_channels(struct net_device *dev,
1179                                                    void __user *useraddr)
1180 {
1181         struct ethtool_channels channels = { .cmd = ETHTOOL_GCHANNELS };
1182
1183         if (!dev->ethtool_ops->get_channels)
1184                 return -EOPNOTSUPP;
1185
1186         dev->ethtool_ops->get_channels(dev, &channels);
1187
1188         if (copy_to_user(useraddr, &channels, sizeof(channels)))
1189                 return -EFAULT;
1190         return 0;
1191 }
1192
1193 static noinline_for_stack int ethtool_set_channels(struct net_device *dev,
1194                                                    void __user *useraddr)
1195 {
1196         struct ethtool_channels channels;
1197
1198         if (!dev->ethtool_ops->set_channels)
1199                 return -EOPNOTSUPP;
1200
1201         if (copy_from_user(&channels, useraddr, sizeof(channels)))
1202                 return -EFAULT;
1203
1204         return dev->ethtool_ops->set_channels(dev, &channels);
1205 }
1206
1207 static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
1208 {
1209         struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
1210
1211         if (!dev->ethtool_ops->get_pauseparam)
1212                 return -EOPNOTSUPP;
1213
1214         dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
1215
1216         if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
1217                 return -EFAULT;
1218         return 0;
1219 }
1220
1221 static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
1222 {
1223         struct ethtool_pauseparam pauseparam;
1224
1225         if (!dev->ethtool_ops->set_pauseparam)
1226                 return -EOPNOTSUPP;
1227
1228         if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
1229                 return -EFAULT;
1230
1231         return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
1232 }
1233
1234 static int __ethtool_set_sg(struct net_device *dev, u32 data)
1235 {
1236         int err;
1237
1238         if (!dev->ethtool_ops->set_sg)
1239                 return -EOPNOTSUPP;
1240
1241         if (data && !(dev->features & NETIF_F_ALL_CSUM))
1242                 return -EINVAL;
1243
1244         if (!data && dev->ethtool_ops->set_tso) {
1245                 err = dev->ethtool_ops->set_tso(dev, 0);
1246                 if (err)
1247                         return err;
1248         }
1249
1250         if (!data && dev->ethtool_ops->set_ufo) {
1251                 err = dev->ethtool_ops->set_ufo(dev, 0);
1252                 if (err)
1253                         return err;
1254         }
1255         return dev->ethtool_ops->set_sg(dev, data);
1256 }
1257
1258 static int __ethtool_set_tx_csum(struct net_device *dev, u32 data)
1259 {
1260         int err;
1261
1262         if (!dev->ethtool_ops->set_tx_csum)
1263                 return -EOPNOTSUPP;
1264
1265         if (!data && dev->ethtool_ops->set_sg) {
1266                 err = __ethtool_set_sg(dev, 0);
1267                 if (err)
1268                         return err;
1269         }
1270
1271         return dev->ethtool_ops->set_tx_csum(dev, data);
1272 }
1273
1274 static int __ethtool_set_rx_csum(struct net_device *dev, u32 data)
1275 {
1276         if (!dev->ethtool_ops->set_rx_csum)
1277                 return -EOPNOTSUPP;
1278
1279         if (!data)
1280                 dev->features &= ~NETIF_F_GRO;
1281
1282         return dev->ethtool_ops->set_rx_csum(dev, data);
1283 }
1284
1285 static int __ethtool_set_tso(struct net_device *dev, u32 data)
1286 {
1287         if (!dev->ethtool_ops->set_tso)
1288                 return -EOPNOTSUPP;
1289
1290         if (data && !(dev->features & NETIF_F_SG))
1291                 return -EINVAL;
1292
1293         return dev->ethtool_ops->set_tso(dev, data);
1294 }
1295
1296 static int __ethtool_set_ufo(struct net_device *dev, u32 data)
1297 {
1298         if (!dev->ethtool_ops->set_ufo)
1299                 return -EOPNOTSUPP;
1300         if (data && !(dev->features & NETIF_F_SG))
1301                 return -EINVAL;
1302         if (data && !((dev->features & NETIF_F_GEN_CSUM) ||
1303                 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))
1304                         == (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM)))
1305                 return -EINVAL;
1306         return dev->ethtool_ops->set_ufo(dev, data);
1307 }
1308
1309 static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
1310 {
1311         struct ethtool_test test;
1312         const struct ethtool_ops *ops = dev->ethtool_ops;
1313         u64 *data;
1314         int ret, test_len;
1315
1316         if (!ops->self_test || !ops->get_sset_count)
1317                 return -EOPNOTSUPP;
1318
1319         test_len = ops->get_sset_count(dev, ETH_SS_TEST);
1320         if (test_len < 0)
1321                 return test_len;
1322         WARN_ON(test_len == 0);
1323
1324         if (copy_from_user(&test, useraddr, sizeof(test)))
1325                 return -EFAULT;
1326
1327         test.len = test_len;
1328         data = kmalloc(test_len * sizeof(u64), GFP_USER);
1329         if (!data)
1330                 return -ENOMEM;
1331
1332         ops->self_test(dev, &test, data);
1333
1334         ret = -EFAULT;
1335         if (copy_to_user(useraddr, &test, sizeof(test)))
1336                 goto out;
1337         useraddr += sizeof(test);
1338         if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
1339                 goto out;
1340         ret = 0;
1341
1342  out:
1343         kfree(data);
1344         return ret;
1345 }
1346
1347 static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
1348 {
1349         struct ethtool_gstrings gstrings;
1350         u8 *data;
1351         int ret;
1352
1353         if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
1354                 return -EFAULT;
1355
1356         ret = __ethtool_get_sset_count(dev, gstrings.string_set);
1357         if (ret < 0)
1358                 return ret;
1359
1360         gstrings.len = ret;
1361
1362         data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
1363         if (!data)
1364                 return -ENOMEM;
1365
1366         __ethtool_get_strings(dev, gstrings.string_set, data);
1367
1368         ret = -EFAULT;
1369         if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1370                 goto out;
1371         useraddr += sizeof(gstrings);
1372         if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1373                 goto out;
1374         ret = 0;
1375
1376 out:
1377         kfree(data);
1378         return ret;
1379 }
1380
1381 static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
1382 {
1383         struct ethtool_value id;
1384         static bool busy;
1385         int rc;
1386
1387         if (!dev->ethtool_ops->set_phys_id)
1388                 return -EOPNOTSUPP;
1389
1390         if (busy)
1391                 return -EBUSY;
1392
1393         if (copy_from_user(&id, useraddr, sizeof(id)))
1394                 return -EFAULT;
1395
1396         rc = dev->ethtool_ops->set_phys_id(dev, ETHTOOL_ID_ACTIVE);
1397         if (rc < 0)
1398                 return rc;
1399
1400         /* Drop the RTNL lock while waiting, but prevent reentry or
1401          * removal of the device.
1402          */
1403         busy = true;
1404         dev_hold(dev);
1405         rtnl_unlock();
1406
1407         if (rc == 0) {
1408                 /* Driver will handle this itself */
1409                 schedule_timeout_interruptible(
1410                         id.data ? (id.data * HZ) : MAX_SCHEDULE_TIMEOUT);
1411         } else {
1412                 /* Driver expects to be called at twice the frequency in rc */
1413                 int n = rc * 2, i, interval = HZ / n;
1414
1415                 /* Count down seconds */
1416                 do {
1417                         /* Count down iterations per second */
1418                         i = n;
1419                         do {
1420                                 rtnl_lock();
1421                                 rc = dev->ethtool_ops->set_phys_id(dev,
1422                                     (i & 1) ? ETHTOOL_ID_OFF : ETHTOOL_ID_ON);
1423                                 rtnl_unlock();
1424                                 if (rc)
1425                                         break;
1426                                 schedule_timeout_interruptible(interval);
1427                         } while (!signal_pending(current) && --i != 0);
1428                 } while (!signal_pending(current) &&
1429                          (id.data == 0 || --id.data != 0));
1430         }
1431
1432         rtnl_lock();
1433         dev_put(dev);
1434         busy = false;
1435
1436         (void)dev->ethtool_ops->set_phys_id(dev, ETHTOOL_ID_INACTIVE);
1437         return rc;
1438 }
1439
1440 static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
1441 {
1442         struct ethtool_stats stats;
1443         const struct ethtool_ops *ops = dev->ethtool_ops;
1444         u64 *data;
1445         int ret, n_stats;
1446
1447         if (!ops->get_ethtool_stats || !ops->get_sset_count)
1448                 return -EOPNOTSUPP;
1449
1450         n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
1451         if (n_stats < 0)
1452                 return n_stats;
1453         WARN_ON(n_stats == 0);
1454
1455         if (copy_from_user(&stats, useraddr, sizeof(stats)))
1456                 return -EFAULT;
1457
1458         stats.n_stats = n_stats;
1459         data = kmalloc(n_stats * sizeof(u64), GFP_USER);
1460         if (!data)
1461                 return -ENOMEM;
1462
1463         ops->get_ethtool_stats(dev, &stats, data);
1464
1465         ret = -EFAULT;
1466         if (copy_to_user(useraddr, &stats, sizeof(stats)))
1467                 goto out;
1468         useraddr += sizeof(stats);
1469         if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
1470                 goto out;
1471         ret = 0;
1472
1473  out:
1474         kfree(data);
1475         return ret;
1476 }
1477
1478 static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
1479 {
1480         struct ethtool_perm_addr epaddr;
1481
1482         if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
1483                 return -EFAULT;
1484
1485         if (epaddr.size < dev->addr_len)
1486                 return -ETOOSMALL;
1487         epaddr.size = dev->addr_len;
1488
1489         if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
1490                 return -EFAULT;
1491         useraddr += sizeof(epaddr);
1492         if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
1493                 return -EFAULT;
1494         return 0;
1495 }
1496
1497 static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
1498                              u32 cmd, u32 (*actor)(struct net_device *))
1499 {
1500         struct ethtool_value edata = { .cmd = cmd };
1501
1502         if (!actor)
1503                 return -EOPNOTSUPP;
1504
1505         edata.data = actor(dev);
1506
1507         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1508                 return -EFAULT;
1509         return 0;
1510 }
1511
1512 static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
1513                              void (*actor)(struct net_device *, u32))
1514 {
1515         struct ethtool_value edata;
1516
1517         if (!actor)
1518                 return -EOPNOTSUPP;
1519
1520         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1521                 return -EFAULT;
1522
1523         actor(dev, edata.data);
1524         return 0;
1525 }
1526
1527 static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
1528                              int (*actor)(struct net_device *, u32))
1529 {
1530         struct ethtool_value edata;
1531
1532         if (!actor)
1533                 return -EOPNOTSUPP;
1534
1535         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1536                 return -EFAULT;
1537
1538         return actor(dev, edata.data);
1539 }
1540
1541 static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
1542                                                    char __user *useraddr)
1543 {
1544         struct ethtool_flash efl;
1545
1546         if (copy_from_user(&efl, useraddr, sizeof(efl)))
1547                 return -EFAULT;
1548
1549         if (!dev->ethtool_ops->flash_device)
1550                 return -EOPNOTSUPP;
1551
1552         return dev->ethtool_ops->flash_device(dev, &efl);
1553 }
1554
1555 static int ethtool_set_dump(struct net_device *dev,
1556                         void __user *useraddr)
1557 {
1558         struct ethtool_dump dump;
1559
1560         if (!dev->ethtool_ops->set_dump)
1561                 return -EOPNOTSUPP;
1562
1563         if (copy_from_user(&dump, useraddr, sizeof(dump)))
1564                 return -EFAULT;
1565
1566         return dev->ethtool_ops->set_dump(dev, &dump);
1567 }
1568
1569 static int ethtool_get_dump_flag(struct net_device *dev,
1570                                 void __user *useraddr)
1571 {
1572         int ret;
1573         struct ethtool_dump dump;
1574         const struct ethtool_ops *ops = dev->ethtool_ops;
1575
1576         if (!dev->ethtool_ops->get_dump_flag)
1577                 return -EOPNOTSUPP;
1578
1579         if (copy_from_user(&dump, useraddr, sizeof(dump)))
1580                 return -EFAULT;
1581
1582         ret = ops->get_dump_flag(dev, &dump);
1583         if (ret)
1584                 return ret;
1585
1586         if (copy_to_user(useraddr, &dump, sizeof(dump)))
1587                 return -EFAULT;
1588         return 0;
1589 }
1590
1591 static int ethtool_get_dump_data(struct net_device *dev,
1592                                 void __user *useraddr)
1593 {
1594         int ret;
1595         __u32 len;
1596         struct ethtool_dump dump, tmp;
1597         const struct ethtool_ops *ops = dev->ethtool_ops;
1598         void *data = NULL;
1599
1600         if (!dev->ethtool_ops->get_dump_data ||
1601                 !dev->ethtool_ops->get_dump_flag)
1602                 return -EOPNOTSUPP;
1603
1604         if (copy_from_user(&dump, useraddr, sizeof(dump)))
1605                 return -EFAULT;
1606
1607         memset(&tmp, 0, sizeof(tmp));
1608         tmp.cmd = ETHTOOL_GET_DUMP_FLAG;
1609         ret = ops->get_dump_flag(dev, &tmp);
1610         if (ret)
1611                 return ret;
1612
1613         len = (tmp.len > dump.len) ? dump.len : tmp.len;
1614         if (!len)
1615                 return -EFAULT;
1616
1617         data = vzalloc(tmp.len);
1618         if (!data)
1619                 return -ENOMEM;
1620         ret = ops->get_dump_data(dev, &dump, data);
1621         if (ret)
1622                 goto out;
1623
1624         if (copy_to_user(useraddr, &dump, sizeof(dump))) {
1625                 ret = -EFAULT;
1626                 goto out;
1627         }
1628         useraddr += offsetof(struct ethtool_dump, data);
1629         if (copy_to_user(useraddr, data, len))
1630                 ret = -EFAULT;
1631 out:
1632         vfree(data);
1633         return ret;
1634 }
1635
1636 /* The main entry point in this file.  Called from net/core/dev.c */
1637
1638 int dev_ethtool(struct net *net, struct ifreq *ifr)
1639 {
1640         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
1641         void __user *useraddr = ifr->ifr_data;
1642         u32 ethcmd;
1643         int rc;
1644         u32 old_features;
1645
1646         if (!dev || !netif_device_present(dev))
1647                 return -ENODEV;
1648
1649         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1650                 return -EFAULT;
1651
1652         if (!dev->ethtool_ops) {
1653                 /* ETHTOOL_GDRVINFO does not require any driver support.
1654                  * It is also unprivileged and does not change anything,
1655                  * so we can take a shortcut to it. */
1656                 if (ethcmd == ETHTOOL_GDRVINFO)
1657                         return ethtool_get_drvinfo(dev, useraddr);
1658                 else
1659                         return -EOPNOTSUPP;
1660         }
1661
1662         /* Allow some commands to be done by anyone */
1663         switch (ethcmd) {
1664         case ETHTOOL_GSET:
1665         case ETHTOOL_GDRVINFO:
1666         case ETHTOOL_GMSGLVL:
1667         case ETHTOOL_GCOALESCE:
1668         case ETHTOOL_GRINGPARAM:
1669         case ETHTOOL_GPAUSEPARAM:
1670         case ETHTOOL_GRXCSUM:
1671         case ETHTOOL_GTXCSUM:
1672         case ETHTOOL_GSG:
1673         case ETHTOOL_GSTRINGS:
1674         case ETHTOOL_GTSO:
1675         case ETHTOOL_GPERMADDR:
1676         case ETHTOOL_GUFO:
1677         case ETHTOOL_GGSO:
1678         case ETHTOOL_GGRO:
1679         case ETHTOOL_GFLAGS:
1680         case ETHTOOL_GPFLAGS:
1681         case ETHTOOL_GRXFH:
1682         case ETHTOOL_GRXRINGS:
1683         case ETHTOOL_GRXCLSRLCNT:
1684         case ETHTOOL_GRXCLSRULE:
1685         case ETHTOOL_GRXCLSRLALL:
1686         case ETHTOOL_GFEATURES:
1687                 break;
1688         default:
1689                 if (!capable(CAP_NET_ADMIN))
1690                         return -EPERM;
1691         }
1692
1693         if (dev->ethtool_ops->begin) {
1694                 rc = dev->ethtool_ops->begin(dev);
1695                 if (rc  < 0)
1696                         return rc;
1697         }
1698         old_features = dev->features;
1699
1700         switch (ethcmd) {
1701         case ETHTOOL_GSET:
1702                 rc = ethtool_get_settings(dev, useraddr);
1703                 break;
1704         case ETHTOOL_SSET:
1705                 rc = ethtool_set_settings(dev, useraddr);
1706                 break;
1707         case ETHTOOL_GDRVINFO:
1708                 rc = ethtool_get_drvinfo(dev, useraddr);
1709                 break;
1710         case ETHTOOL_GREGS:
1711                 rc = ethtool_get_regs(dev, useraddr);
1712                 break;
1713         case ETHTOOL_GWOL:
1714                 rc = ethtool_get_wol(dev, useraddr);
1715                 break;
1716         case ETHTOOL_SWOL:
1717                 rc = ethtool_set_wol(dev, useraddr);
1718                 break;
1719         case ETHTOOL_GMSGLVL:
1720                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1721                                        dev->ethtool_ops->get_msglevel);
1722                 break;
1723         case ETHTOOL_SMSGLVL:
1724                 rc = ethtool_set_value_void(dev, useraddr,
1725                                        dev->ethtool_ops->set_msglevel);
1726                 break;
1727         case ETHTOOL_NWAY_RST:
1728                 rc = ethtool_nway_reset(dev);
1729                 break;
1730         case ETHTOOL_GLINK:
1731                 rc = ethtool_get_link(dev, useraddr);
1732                 break;
1733         case ETHTOOL_GEEPROM:
1734                 rc = ethtool_get_eeprom(dev, useraddr);
1735                 break;
1736         case ETHTOOL_SEEPROM:
1737                 rc = ethtool_set_eeprom(dev, useraddr);
1738                 break;
1739         case ETHTOOL_GCOALESCE:
1740                 rc = ethtool_get_coalesce(dev, useraddr);
1741                 break;
1742         case ETHTOOL_SCOALESCE:
1743                 rc = ethtool_set_coalesce(dev, useraddr);
1744                 break;
1745         case ETHTOOL_GRINGPARAM:
1746                 rc = ethtool_get_ringparam(dev, useraddr);
1747                 break;
1748         case ETHTOOL_SRINGPARAM:
1749                 rc = ethtool_set_ringparam(dev, useraddr);
1750                 break;
1751         case ETHTOOL_GPAUSEPARAM:
1752                 rc = ethtool_get_pauseparam(dev, useraddr);
1753                 break;
1754         case ETHTOOL_SPAUSEPARAM:
1755                 rc = ethtool_set_pauseparam(dev, useraddr);
1756                 break;
1757         case ETHTOOL_TEST:
1758                 rc = ethtool_self_test(dev, useraddr);
1759                 break;
1760         case ETHTOOL_GSTRINGS:
1761                 rc = ethtool_get_strings(dev, useraddr);
1762                 break;
1763         case ETHTOOL_PHYS_ID:
1764                 rc = ethtool_phys_id(dev, useraddr);
1765                 break;
1766         case ETHTOOL_GSTATS:
1767                 rc = ethtool_get_stats(dev, useraddr);
1768                 break;
1769         case ETHTOOL_GPERMADDR:
1770                 rc = ethtool_get_perm_addr(dev, useraddr);
1771                 break;
1772         case ETHTOOL_GFLAGS:
1773                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1774                                        (dev->ethtool_ops->get_flags ?
1775                                         dev->ethtool_ops->get_flags :
1776                                         ethtool_op_get_flags));
1777                 break;
1778         case ETHTOOL_SFLAGS:
1779                 rc = ethtool_set_value(dev, useraddr, __ethtool_set_flags);
1780                 break;
1781         case ETHTOOL_GPFLAGS:
1782                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1783                                        dev->ethtool_ops->get_priv_flags);
1784                 break;
1785         case ETHTOOL_SPFLAGS:
1786                 rc = ethtool_set_value(dev, useraddr,
1787                                        dev->ethtool_ops->set_priv_flags);
1788                 break;
1789         case ETHTOOL_GRXFH:
1790         case ETHTOOL_GRXRINGS:
1791         case ETHTOOL_GRXCLSRLCNT:
1792         case ETHTOOL_GRXCLSRULE:
1793         case ETHTOOL_GRXCLSRLALL:
1794                 rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
1795                 break;
1796         case ETHTOOL_SRXFH:
1797         case ETHTOOL_SRXCLSRLDEL:
1798         case ETHTOOL_SRXCLSRLINS:
1799                 rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
1800                 break;
1801         case ETHTOOL_FLASHDEV:
1802                 rc = ethtool_flash_device(dev, useraddr);
1803                 break;
1804         case ETHTOOL_RESET:
1805                 rc = ethtool_reset(dev, useraddr);
1806                 break;
1807         case ETHTOOL_SRXNTUPLE:
1808                 rc = ethtool_set_rx_ntuple(dev, useraddr);
1809                 break;
1810         case ETHTOOL_GSSET_INFO:
1811                 rc = ethtool_get_sset_info(dev, useraddr);
1812                 break;
1813         case ETHTOOL_GRXFHINDIR:
1814                 rc = ethtool_get_rxfh_indir(dev, useraddr);
1815                 break;
1816         case ETHTOOL_SRXFHINDIR:
1817                 rc = ethtool_set_rxfh_indir(dev, useraddr);
1818                 break;
1819         case ETHTOOL_GFEATURES:
1820                 rc = ethtool_get_features(dev, useraddr);
1821                 break;
1822         case ETHTOOL_SFEATURES:
1823                 rc = ethtool_set_features(dev, useraddr);
1824                 break;
1825         case ETHTOOL_GTXCSUM:
1826         case ETHTOOL_GRXCSUM:
1827         case ETHTOOL_GSG:
1828         case ETHTOOL_GTSO:
1829         case ETHTOOL_GUFO:
1830         case ETHTOOL_GGSO:
1831         case ETHTOOL_GGRO:
1832                 rc = ethtool_get_one_feature(dev, useraddr, ethcmd);
1833                 break;
1834         case ETHTOOL_STXCSUM:
1835         case ETHTOOL_SRXCSUM:
1836         case ETHTOOL_SSG:
1837         case ETHTOOL_STSO:
1838         case ETHTOOL_SUFO:
1839         case ETHTOOL_SGSO:
1840         case ETHTOOL_SGRO:
1841                 rc = ethtool_set_one_feature(dev, useraddr, ethcmd);
1842                 break;
1843         case ETHTOOL_GCHANNELS:
1844                 rc = ethtool_get_channels(dev, useraddr);
1845                 break;
1846         case ETHTOOL_SCHANNELS:
1847                 rc = ethtool_set_channels(dev, useraddr);
1848                 break;
1849         case ETHTOOL_SET_DUMP:
1850                 rc = ethtool_set_dump(dev, useraddr);
1851                 break;
1852         case ETHTOOL_GET_DUMP_FLAG:
1853                 rc = ethtool_get_dump_flag(dev, useraddr);
1854                 break;
1855         case ETHTOOL_GET_DUMP_DATA:
1856                 rc = ethtool_get_dump_data(dev, useraddr);
1857                 break;
1858         default:
1859                 rc = -EOPNOTSUPP;
1860         }
1861
1862         if (dev->ethtool_ops->complete)
1863                 dev->ethtool_ops->complete(dev);
1864
1865         if (old_features != dev->features)
1866                 netdev_features_change(dev);
1867
1868         return rc;
1869 }