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 static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
 573 {
 574         struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
 575         int err;
 576
 577         if (!dev->ethtool_ops->get_settings)
 578                 return -EOPNOTSUPP;
 579
 580         err = dev->ethtool_ops->get_settings(dev, &cmd);
 581         if (err < 0)
 582                 return err;
 583
 584         if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
 585                 return -EFAULT;
 586         return 0;
 587 }
 588
 589 static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
 590 {
 591         struct ethtool_cmd cmd;
 592
 593         if (!dev->ethtool_ops->set_settings)
 594                 return -EOPNOTSUPP;
 595
 596         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
 597                 return -EFAULT;
 598
 599         return dev->ethtool_ops->set_settings(dev, &cmd);
 600 }
 601
 602 static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
 603                                                   void __user *useraddr)
 604 {
 605         struct ethtool_drvinfo info;
 606         const struct ethtool_ops *ops = dev->ethtool_ops;
 607
 608         memset(&info, 0, sizeof(info));
 609         info.cmd = ETHTOOL_GDRVINFO;
 610         if (ops && ops->get_drvinfo) {
 611                 ops->get_drvinfo(dev, &info);
 612         } else if (dev->dev.parent && dev->dev.parent->driver) {
 613                 strlcpy(info.bus_info, dev_name(dev->dev.parent),
 614                         sizeof(info.bus_info));
 615                 strlcpy(info.driver, dev->dev.parent->driver->name,
 616                         sizeof(info.driver));
 617         } else {
 618                 return -EOPNOTSUPP;
 619         }
 620
 621         /*
 622          * this method of obtaining string set info is deprecated;
 623          * Use ETHTOOL_GSSET_INFO instead.
 624          */
 625         if (ops && ops->get_sset_count) {
 626                 int rc;
 627
 628                 rc = ops->get_sset_count(dev, ETH_SS_TEST);
 629                 if (rc >= 0)
 630                         info.testinfo_len = rc;
 631                 rc = ops->get_sset_count(dev, ETH_SS_STATS);
 632                 if (rc >= 0)
 633                         info.n_stats = rc;
 634                 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
 635                 if (rc >= 0)
 636                         info.n_priv_flags = rc;
 637         }
 638         if (ops && ops->get_regs_len)
 639                 info.regdump_len = ops->get_regs_len(dev);
 640         if (ops && ops->get_eeprom_len)
 641                 info.eedump_len = ops->get_eeprom_len(dev);
 642
 643         if (copy_to_user(useraddr, &info, sizeof(info)))
 644                 return -EFAULT;
 645         return 0;
 646 }
 647
 648 static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
 649                                                     void __user *useraddr)
 650 {
 651         struct ethtool_sset_info info;
 652         u64 sset_mask;
 653         int i, idx = 0, n_bits = 0, ret, rc;
 654         u32 *info_buf = NULL;
 655
 656         if (copy_from_user(&info, useraddr, sizeof(info)))
 657                 return -EFAULT;
 658
 659         /* store copy of mask, because we zero struct later on */
 660         sset_mask = info.sset_mask;
 661         if (!sset_mask)
 662                 return 0;
 663
 664         /* calculate size of return buffer */
 665         n_bits = hweight64(sset_mask);
 666
 667         memset(&info, 0, sizeof(info));
 668         info.cmd = ETHTOOL_GSSET_INFO;
 669
 670         info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
 671         if (!info_buf)
 672                 return -ENOMEM;
 673
 674         /*
 675          * fill return buffer based on input bitmask and successful
 676          * get_sset_count return
 677          */
 678         for (i = 0; i < 64; i++) {
 679                 if (!(sset_mask & (1ULL << i)))
 680                         continue;
 681
 682                 rc = __ethtool_get_sset_count(dev, i);
 683                 if (rc >= 0) {
 684                         info.sset_mask |= (1ULL << i);
 685                         info_buf[idx++] = rc;
 686                 }
 687         }
 688
 689         ret = -EFAULT;
 690         if (copy_to_user(useraddr, &info, sizeof(info)))
 691                 goto out;
 692
 693         useraddr += offsetof(struct ethtool_sset_info, data);
 694         if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
 695                 goto out;
 696
 697         ret = 0;
 698
 699 out:
 700         kfree(info_buf);
 701         return ret;
 702 }
 703
 704 static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
 705                                                 u32 cmd, void __user *useraddr)
 706 {
 707         struct ethtool_rxnfc info;
 708         size_t info_size = sizeof(info);
 709
 710         if (!dev->ethtool_ops->set_rxnfc)
 711                 return -EOPNOTSUPP;
 712
 713         /* struct ethtool_rxnfc was originally defined for
 714          * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
 715          * members.  User-space might still be using that
 716          * definition. */
 717         if (cmd == ETHTOOL_SRXFH)
 718                 info_size = (offsetof(struct ethtool_rxnfc, data) +
 719                              sizeof(info.data));
 720
 721         if (copy_from_user(&info, useraddr, info_size))
 722                 return -EFAULT;
 723
 724         return dev->ethtool_ops->set_rxnfc(dev, &info);
 725 }
 726
 727 static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
 728                                                 u32 cmd, void __user *useraddr)
 729 {
 730         struct ethtool_rxnfc info;
 731         size_t info_size = sizeof(info);
 732         const struct ethtool_ops *ops = dev->ethtool_ops;
 733         int ret;
 734         void *rule_buf = NULL;
 735
 736         if (!ops->get_rxnfc)
 737                 return -EOPNOTSUPP;
 738
 739         /* struct ethtool_rxnfc was originally defined for
 740          * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
 741          * members.  User-space might still be using that
 742          * definition. */
 743         if (cmd == ETHTOOL_GRXFH)
 744                 info_size = (offsetof(struct ethtool_rxnfc, data) +
 745                              sizeof(info.data));
 746
 747         if (copy_from_user(&info, useraddr, info_size))
 748                 return -EFAULT;
 749
 750         if (info.cmd == ETHTOOL_GRXCLSRLALL) {
 751                 if (info.rule_cnt > 0) {
 752                         if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
 753                                 rule_buf = kzalloc(info.rule_cnt * sizeof(u32),
 754                                                    GFP_USER);
 755                         if (!rule_buf)
 756                                 return -ENOMEM;
 757                 }
 758         }
 759
 760         ret = ops->get_rxnfc(dev, &info, rule_buf);
 761         if (ret < 0)
 762                 goto err_out;
 763
 764         ret = -EFAULT;
 765         if (copy_to_user(useraddr, &info, info_size))
 766                 goto err_out;
 767
 768         if (rule_buf) {
 769                 useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
 770                 if (copy_to_user(useraddr, rule_buf,
 771                                  info.rule_cnt * sizeof(u32)))
 772                         goto err_out;
 773         }
 774         ret = 0;
 775
 776 err_out:
 777         kfree(rule_buf);
 778
 779         return ret;
 780 }
 781
 782 static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,
 783                                                      void __user *useraddr)
 784 {
 785         struct ethtool_rxfh_indir *indir;
 786         u32 table_size;
 787         size_t full_size;
 788         int ret;
 789
 790         if (!dev->ethtool_ops->get_rxfh_indir)
 791                 return -EOPNOTSUPP;
 792
 793         if (copy_from_user(&table_size,
 794                            useraddr + offsetof(struct ethtool_rxfh_indir, size),
 795                            sizeof(table_size)))
 796                 return -EFAULT;
 797
 798         if (table_size >
 799             (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
 800                 return -ENOMEM;
 801         full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
 802         indir = kzalloc(full_size, GFP_USER);
 803         if (!indir)
 804                 return -ENOMEM;
 805
 806         indir->cmd = ETHTOOL_GRXFHINDIR;
 807         indir->size = table_size;
 808         ret = dev->ethtool_ops->get_rxfh_indir(dev, indir);
 809         if (ret)
 810                 goto out;
 811
 812         if (copy_to_user(useraddr, indir, full_size))
 813                 ret = -EFAULT;
 814
 815 out:
 816         kfree(indir);
 817         return ret;
 818 }
 819
 820 static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,
 821                                                      void __user *useraddr)
 822 {
 823         struct ethtool_rxfh_indir *indir;
 824         u32 table_size;
 825         size_t full_size;
 826         int ret;
 827
 828         if (!dev->ethtool_ops->set_rxfh_indir)
 829                 return -EOPNOTSUPP;
 830
 831         if (copy_from_user(&table_size,
 832                            useraddr + offsetof(struct ethtool_rxfh_indir, size),
 833                            sizeof(table_size)))
 834                 return -EFAULT;
 835
 836         if (table_size >
 837             (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
 838                 return -ENOMEM;
 839         full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
 840         indir = kmalloc(full_size, GFP_USER);
 841         if (!indir)
 842                 return -ENOMEM;
 843
 844         if (copy_from_user(indir, useraddr, full_size)) {
 845                 ret = -EFAULT;
 846                 goto out;
 847         }
 848
 849         ret = dev->ethtool_ops->set_rxfh_indir(dev, indir);
 850
 851 out:
 852         kfree(indir);
 853         return ret;
 854 }
 855
 856 /*
 857  * ethtool does not (or did not) set masks for flow parameters that are
 858  * not specified, so if both value and mask are 0 then this must be
 859  * treated as equivalent to a mask with all bits set.  Implement that
 860  * here rather than in drivers.
 861  */
 862 static void rx_ntuple_fix_masks(struct ethtool_rx_ntuple_flow_spec *fs)
 863 {
 864         struct ethtool_tcpip4_spec *entry = &fs->h_u.tcp_ip4_spec;
 865         struct ethtool_tcpip4_spec *mask = &fs->m_u.tcp_ip4_spec;
 866
 867         if (fs->flow_type != TCP_V4_FLOW &&
 868             fs->flow_type != UDP_V4_FLOW &&
 869             fs->flow_type != SCTP_V4_FLOW)
 870                 return;
 871
 872         if (!(entry->ip4src | mask->ip4src))
 873                 mask->ip4src = htonl(0xffffffff);
 874         if (!(entry->ip4dst | mask->ip4dst))
 875                 mask->ip4dst = htonl(0xffffffff);
 876         if (!(entry->psrc | mask->psrc))
 877                 mask->psrc = htons(0xffff);
 878         if (!(entry->pdst | mask->pdst))
 879                 mask->pdst = htons(0xffff);
 880         if (!(entry->tos | mask->tos))
 881                 mask->tos = 0xff;
 882         if (!(fs->vlan_tag | fs->vlan_tag_mask))
 883                 fs->vlan_tag_mask = 0xffff;
 884         if (!(fs->data | fs->data_mask))
 885                 fs->data_mask = 0xffffffffffffffffULL;
 886 }
 887
 888 static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
 889                                                     void __user *useraddr)
 890 {
 891         struct ethtool_rx_ntuple cmd;
 892         const struct ethtool_ops *ops = dev->ethtool_ops;
 893
 894         if (!ops->set_rx_ntuple)
 895                 return -EOPNOTSUPP;
 896
 897         if (!(dev->features & NETIF_F_NTUPLE))
 898                 return -EINVAL;
 899
 900         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
 901                 return -EFAULT;
 902
 903         rx_ntuple_fix_masks(&cmd.fs);
 904
 905         return ops->set_rx_ntuple(dev, &cmd);
 906 }
 907
 908 static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
 909 {
 910         struct ethtool_regs regs;
 911         const struct ethtool_ops *ops = dev->ethtool_ops;
 912         void *regbuf;
 913         int reglen, ret;
 914
 915         if (!ops->get_regs || !ops->get_regs_len)
 916                 return -EOPNOTSUPP;
 917
 918         if (copy_from_user(&regs, useraddr, sizeof(regs)))
 919                 return -EFAULT;
 920
 921         reglen = ops->get_regs_len(dev);
 922         if (regs.len > reglen)
 923                 regs.len = reglen;
 924
 925         regbuf = vzalloc(reglen);
 926         if (reglen && !regbuf)
 927                 return -ENOMEM;
 928
 929         ops->get_regs(dev, &regs, regbuf);
 930
 931         ret = -EFAULT;
 932         if (copy_to_user(useraddr, &regs, sizeof(regs)))
 933                 goto out;
 934         useraddr += offsetof(struct ethtool_regs, data);
 935         if (regbuf && copy_to_user(useraddr, regbuf, regs.len))
 936                 goto out;
 937         ret = 0;
 938
 939  out:
 940         vfree(regbuf);
 941         return ret;
 942 }
 943
 944 static int ethtool_reset(struct net_device *dev, char __user *useraddr)
 945 {
 946         struct ethtool_value reset;
 947         int ret;
 948
 949         if (!dev->ethtool_ops->reset)
 950                 return -EOPNOTSUPP;
 951
 952         if (copy_from_user(&reset, useraddr, sizeof(reset)))
 953                 return -EFAULT;
 954
 955         ret = dev->ethtool_ops->reset(dev, &reset.data);
 956         if (ret)
 957                 return ret;
 958
 959         if (copy_to_user(useraddr, &reset, sizeof(reset)))
 960                 return -EFAULT;
 961         return 0;
 962 }
 963
 964 static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
 965 {
 966         struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
 967
 968         if (!dev->ethtool_ops->get_wol)
 969                 return -EOPNOTSUPP;
 970
 971         dev->ethtool_ops->get_wol(dev, &wol);
 972
 973         if (copy_to_user(useraddr, &wol, sizeof(wol)))
 974                 return -EFAULT;
 975         return 0;
 976 }
 977
 978 static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
 979 {
 980         struct ethtool_wolinfo wol;
 981
 982         if (!dev->ethtool_ops->set_wol)
 983                 return -EOPNOTSUPP;
 984
 985         if (copy_from_user(&wol, useraddr, sizeof(wol)))
 986                 return -EFAULT;
 987
 988         return dev->ethtool_ops->set_wol(dev, &wol);
 989 }
 990
 991 static int ethtool_nway_reset(struct net_device *dev)
 992 {
 993         if (!dev->ethtool_ops->nway_reset)
 994                 return -EOPNOTSUPP;
 995
 996         return dev->ethtool_ops->nway_reset(dev);
 997 }
 998
 999 static int ethtool_get_link(struct net_device *dev, char __user *useraddr)
1000 {
1001         struct ethtool_value edata = { .cmd = ETHTOOL_GLINK };
1002
1003         if (!dev->ethtool_ops->get_link)
1004                 return -EOPNOTSUPP;
1005
1006         edata.data = netif_running(dev) && dev->ethtool_ops->get_link(dev);
1007
1008         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1009                 return -EFAULT;
1010         return 0;
1011 }
1012
1013 static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
1014 {
1015         struct ethtool_eeprom eeprom;
1016         const struct ethtool_ops *ops = dev->ethtool_ops;
1017         void __user *userbuf = useraddr + sizeof(eeprom);
1018         u32 bytes_remaining;
1019         u8 *data;
1020         int ret = 0;
1021
1022         if (!ops->get_eeprom || !ops->get_eeprom_len)
1023                 return -EOPNOTSUPP;
1024
1025         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1026                 return -EFAULT;
1027
1028         /* Check for wrap and zero */
1029         if (eeprom.offset + eeprom.len <= eeprom.offset)
1030                 return -EINVAL;
1031
1032         /* Check for exceeding total eeprom len */
1033         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1034                 return -EINVAL;
1035
1036         data = kmalloc(PAGE_SIZE, GFP_USER);
1037         if (!data)
1038                 return -ENOMEM;
1039
1040         bytes_remaining = eeprom.len;
1041         while (bytes_remaining > 0) {
1042                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
1043
1044                 ret = ops->get_eeprom(dev, &eeprom, data);
1045                 if (ret)
1046                         break;
1047                 if (copy_to_user(userbuf, data, eeprom.len)) {
1048                         ret = -EFAULT;
1049                         break;
1050                 }
1051                 userbuf += eeprom.len;
1052                 eeprom.offset += eeprom.len;
1053                 bytes_remaining -= eeprom.len;
1054         }
1055
1056         eeprom.len = userbuf - (useraddr + sizeof(eeprom));
1057         eeprom.offset -= eeprom.len;
1058         if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
1059                 ret = -EFAULT;
1060
1061         kfree(data);
1062         return ret;
1063 }
1064
1065 static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
1066 {
1067         struct ethtool_eeprom eeprom;
1068         const struct ethtool_ops *ops = dev->ethtool_ops;
1069         void __user *userbuf = useraddr + sizeof(eeprom);
1070         u32 bytes_remaining;
1071         u8 *data;
1072         int ret = 0;
1073
1074         if (!ops->set_eeprom || !ops->get_eeprom_len)
1075                 return -EOPNOTSUPP;
1076
1077         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1078                 return -EFAULT;
1079
1080         /* Check for wrap and zero */
1081         if (eeprom.offset + eeprom.len <= eeprom.offset)
1082                 return -EINVAL;
1083
1084         /* Check for exceeding total eeprom len */
1085         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1086                 return -EINVAL;
1087
1088         data = kmalloc(PAGE_SIZE, GFP_USER);
1089         if (!data)
1090                 return -ENOMEM;
1091
1092         bytes_remaining = eeprom.len;
1093         while (bytes_remaining > 0) {
1094                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
1095
1096                 if (copy_from_user(data, userbuf, eeprom.len)) {
1097                         ret = -EFAULT;
1098                         break;
1099                 }
1100                 ret = ops->set_eeprom(dev, &eeprom, data);
1101                 if (ret)
1102                         break;
1103                 userbuf += eeprom.len;
1104                 eeprom.offset += eeprom.len;
1105                 bytes_remaining -= eeprom.len;
1106         }
1107
1108         kfree(data);
1109         return ret;
1110 }
1111
1112 static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
1113                                                    void __user *useraddr)
1114 {
1115         struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
1116
1117         if (!dev->ethtool_ops->get_coalesce)
1118                 return -EOPNOTSUPP;
1119
1120         dev->ethtool_ops->get_coalesce(dev, &coalesce);
1121
1122         if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
1123                 return -EFAULT;
1124         return 0;
1125 }
1126
1127 static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
1128                                                    void __user *useraddr)
1129 {
1130         struct ethtool_coalesce coalesce;
1131
1132         if (!dev->ethtool_ops->set_coalesce)
1133                 return -EOPNOTSUPP;
1134
1135         if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
1136                 return -EFAULT;
1137
1138         return dev->ethtool_ops->set_coalesce(dev, &coalesce);
1139 }
1140
1141 static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
1142 {
1143         struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
1144
1145         if (!dev->ethtool_ops->get_ringparam)
1146                 return -EOPNOTSUPP;
1147
1148         dev->ethtool_ops->get_ringparam(dev, &ringparam);
1149
1150         if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
1151                 return -EFAULT;
1152         return 0;
1153 }
1154
1155 static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
1156 {
1157         struct ethtool_ringparam ringparam;
1158
1159         if (!dev->ethtool_ops->set_ringparam)
1160                 return -EOPNOTSUPP;
1161
1162         if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
1163                 return -EFAULT;
1164
1165         return dev->ethtool_ops->set_ringparam(dev, &ringparam);
1166 }
1167
1168 static noinline_for_stack int ethtool_get_channels(struct net_device *dev,
1169                                                    void __user *useraddr)
1170 {
1171         struct ethtool_channels channels = { .cmd = ETHTOOL_GCHANNELS };
1172
1173         if (!dev->ethtool_ops->get_channels)
1174                 return -EOPNOTSUPP;
1175
1176         dev->ethtool_ops->get_channels(dev, &channels);
1177
1178         if (copy_to_user(useraddr, &channels, sizeof(channels)))
1179                 return -EFAULT;
1180         return 0;
1181 }
1182
1183 static noinline_for_stack int ethtool_set_channels(struct net_device *dev,
1184                                                    void __user *useraddr)
1185 {
1186         struct ethtool_channels channels;
1187
1188         if (!dev->ethtool_ops->set_channels)
1189                 return -EOPNOTSUPP;
1190
1191         if (copy_from_user(&channels, useraddr, sizeof(channels)))
1192                 return -EFAULT;
1193
1194         return dev->ethtool_ops->set_channels(dev, &channels);
1195 }
1196
1197 static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
1198 {
1199         struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
1200
1201         if (!dev->ethtool_ops->get_pauseparam)
1202                 return -EOPNOTSUPP;
1203
1204         dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
1205
1206         if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
1207                 return -EFAULT;
1208         return 0;
1209 }
1210
1211 static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
1212 {
1213         struct ethtool_pauseparam pauseparam;
1214
1215         if (!dev->ethtool_ops->set_pauseparam)
1216                 return -EOPNOTSUPP;
1217
1218         if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
1219                 return -EFAULT;
1220
1221         return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
1222 }
1223
1224 static int __ethtool_set_sg(struct net_device *dev, u32 data)
1225 {
1226         int err;
1227
1228         if (!dev->ethtool_ops->set_sg)
1229                 return -EOPNOTSUPP;
1230
1231         if (data && !(dev->features & NETIF_F_ALL_CSUM))
1232                 return -EINVAL;
1233
1234         if (!data && dev->ethtool_ops->set_tso) {
1235                 err = dev->ethtool_ops->set_tso(dev, 0);
1236                 if (err)
1237                         return err;
1238         }
1239
1240         if (!data && dev->ethtool_ops->set_ufo) {
1241                 err = dev->ethtool_ops->set_ufo(dev, 0);
1242                 if (err)
1243                         return err;
1244         }
1245         return dev->ethtool_ops->set_sg(dev, data);
1246 }
1247
1248 static int __ethtool_set_tx_csum(struct net_device *dev, u32 data)
1249 {
1250         int err;
1251
1252         if (!dev->ethtool_ops->set_tx_csum)
1253                 return -EOPNOTSUPP;
1254
1255         if (!data && dev->ethtool_ops->set_sg) {
1256                 err = __ethtool_set_sg(dev, 0);
1257                 if (err)
1258                         return err;
1259         }
1260
1261         return dev->ethtool_ops->set_tx_csum(dev, data);
1262 }
1263
1264 static int __ethtool_set_rx_csum(struct net_device *dev, u32 data)
1265 {
1266         if (!dev->ethtool_ops->set_rx_csum)
1267                 return -EOPNOTSUPP;
1268
1269         if (!data)
1270                 dev->features &= ~NETIF_F_GRO;
1271
1272         return dev->ethtool_ops->set_rx_csum(dev, data);
1273 }
1274
1275 static int __ethtool_set_tso(struct net_device *dev, u32 data)
1276 {
1277         if (!dev->ethtool_ops->set_tso)
1278                 return -EOPNOTSUPP;
1279
1280         if (data && !(dev->features & NETIF_F_SG))
1281                 return -EINVAL;
1282
1283         return dev->ethtool_ops->set_tso(dev, data);
1284 }
1285
1286 static int __ethtool_set_ufo(struct net_device *dev, u32 data)
1287 {
1288         if (!dev->ethtool_ops->set_ufo)
1289                 return -EOPNOTSUPP;
1290         if (data && !(dev->features & NETIF_F_SG))
1291                 return -EINVAL;
1292         if (data && !((dev->features & NETIF_F_GEN_CSUM) ||
1293                 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))
1294                         == (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM)))
1295                 return -EINVAL;
1296         return dev->ethtool_ops->set_ufo(dev, data);
1297 }
1298
1299 static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
1300 {
1301         struct ethtool_test test;
1302         const struct ethtool_ops *ops = dev->ethtool_ops;
1303         u64 *data;
1304         int ret, test_len;
1305
1306         if (!ops->self_test || !ops->get_sset_count)
1307                 return -EOPNOTSUPP;
1308
1309         test_len = ops->get_sset_count(dev, ETH_SS_TEST);
1310         if (test_len < 0)
1311                 return test_len;
1312         WARN_ON(test_len == 0);
1313
1314         if (copy_from_user(&test, useraddr, sizeof(test)))
1315                 return -EFAULT;
1316
1317         test.len = test_len;
1318         data = kmalloc(test_len * sizeof(u64), GFP_USER);
1319         if (!data)
1320                 return -ENOMEM;
1321
1322         ops->self_test(dev, &test, data);
1323
1324         ret = -EFAULT;
1325         if (copy_to_user(useraddr, &test, sizeof(test)))
1326                 goto out;
1327         useraddr += sizeof(test);
1328         if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
1329                 goto out;
1330         ret = 0;
1331
1332  out:
1333         kfree(data);
1334         return ret;
1335 }
1336
1337 static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
1338 {
1339         struct ethtool_gstrings gstrings;
1340         u8 *data;
1341         int ret;
1342
1343         if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
1344                 return -EFAULT;
1345
1346         ret = __ethtool_get_sset_count(dev, gstrings.string_set);
1347         if (ret < 0)
1348                 return ret;
1349
1350         gstrings.len = ret;
1351
1352         data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
1353         if (!data)
1354                 return -ENOMEM;
1355
1356         __ethtool_get_strings(dev, gstrings.string_set, data);
1357
1358         ret = -EFAULT;
1359         if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1360                 goto out;
1361         useraddr += sizeof(gstrings);
1362         if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1363                 goto out;
1364         ret = 0;
1365
1366 out:
1367         kfree(data);
1368         return ret;
1369 }
1370
1371 static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
1372 {
1373         struct ethtool_value id;
1374         static bool busy;
1375         int rc;
1376
1377         if (!dev->ethtool_ops->set_phys_id)
1378                 return -EOPNOTSUPP;
1379
1380         if (busy)
1381                 return -EBUSY;
1382
1383         if (copy_from_user(&id, useraddr, sizeof(id)))
1384                 return -EFAULT;
1385
1386         rc = dev->ethtool_ops->set_phys_id(dev, ETHTOOL_ID_ACTIVE);
1387         if (rc < 0)
1388                 return rc;
1389
1390         /* Drop the RTNL lock while waiting, but prevent reentry or
1391          * removal of the device.
1392          */
1393         busy = true;
1394         dev_hold(dev);
1395         rtnl_unlock();
1396
1397         if (rc == 0) {
1398                 /* Driver will handle this itself */
1399                 schedule_timeout_interruptible(
1400                         id.data ? (id.data * HZ) : MAX_SCHEDULE_TIMEOUT);
1401         } else {
1402                 /* Driver expects to be called at twice the frequency in rc */
1403                 int n = rc * 2, i, interval = HZ / n;
1404
1405                 /* Count down seconds */
1406                 do {
1407                         /* Count down iterations per second */
1408                         i = n;
1409                         do {
1410                                 rtnl_lock();
1411                                 rc = dev->ethtool_ops->set_phys_id(dev,
1412                                     (i & 1) ? ETHTOOL_ID_OFF : ETHTOOL_ID_ON);
1413                                 rtnl_unlock();
1414                                 if (rc)
1415                                         break;
1416                                 schedule_timeout_interruptible(interval);
1417                         } while (!signal_pending(current) && --i != 0);
1418                 } while (!signal_pending(current) &&
1419                          (id.data == 0 || --id.data != 0));
1420         }
1421
1422         rtnl_lock();
1423         dev_put(dev);
1424         busy = false;
1425
1426         (void)dev->ethtool_ops->set_phys_id(dev, ETHTOOL_ID_INACTIVE);
1427         return rc;
1428 }
1429
1430 static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
1431 {
1432         struct ethtool_stats stats;
1433         const struct ethtool_ops *ops = dev->ethtool_ops;
1434         u64 *data;
1435         int ret, n_stats;
1436
1437         if (!ops->get_ethtool_stats || !ops->get_sset_count)
1438                 return -EOPNOTSUPP;
1439
1440         n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
1441         if (n_stats < 0)
1442                 return n_stats;
1443         WARN_ON(n_stats == 0);
1444
1445         if (copy_from_user(&stats, useraddr, sizeof(stats)))
1446                 return -EFAULT;
1447
1448         stats.n_stats = n_stats;
1449         data = kmalloc(n_stats * sizeof(u64), GFP_USER);
1450         if (!data)
1451                 return -ENOMEM;
1452
1453         ops->get_ethtool_stats(dev, &stats, data);
1454
1455         ret = -EFAULT;
1456         if (copy_to_user(useraddr, &stats, sizeof(stats)))
1457                 goto out;
1458         useraddr += sizeof(stats);
1459         if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
1460                 goto out;
1461         ret = 0;
1462
1463  out:
1464         kfree(data);
1465         return ret;
1466 }
1467
1468 static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
1469 {
1470         struct ethtool_perm_addr epaddr;
1471
1472         if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
1473                 return -EFAULT;
1474
1475         if (epaddr.size < dev->addr_len)
1476                 return -ETOOSMALL;
1477         epaddr.size = dev->addr_len;
1478
1479         if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
1480                 return -EFAULT;
1481         useraddr += sizeof(epaddr);
1482         if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
1483                 return -EFAULT;
1484         return 0;
1485 }
1486
1487 static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
1488                              u32 cmd, u32 (*actor)(struct net_device *))
1489 {
1490         struct ethtool_value edata = { .cmd = cmd };
1491
1492         if (!actor)
1493                 return -EOPNOTSUPP;
1494
1495         edata.data = actor(dev);
1496
1497         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1498                 return -EFAULT;
1499         return 0;
1500 }
1501
1502 static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
1503                              void (*actor)(struct net_device *, u32))
1504 {
1505         struct ethtool_value edata;
1506
1507         if (!actor)
1508                 return -EOPNOTSUPP;
1509
1510         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1511                 return -EFAULT;
1512
1513         actor(dev, edata.data);
1514         return 0;
1515 }
1516
1517 static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
1518                              int (*actor)(struct net_device *, u32))
1519 {
1520         struct ethtool_value edata;
1521
1522         if (!actor)
1523                 return -EOPNOTSUPP;
1524
1525         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1526                 return -EFAULT;
1527
1528         return actor(dev, edata.data);
1529 }
1530
1531 static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
1532                                                    char __user *useraddr)
1533 {
1534         struct ethtool_flash efl;
1535
1536         if (copy_from_user(&efl, useraddr, sizeof(efl)))
1537                 return -EFAULT;
1538
1539         if (!dev->ethtool_ops->flash_device)
1540                 return -EOPNOTSUPP;
1541
1542         return dev->ethtool_ops->flash_device(dev, &efl);
1543 }
1544
1545 static int ethtool_set_dump(struct net_device *dev,
1546                         void __user *useraddr)
1547 {
1548         struct ethtool_dump dump;
1549
1550         if (!dev->ethtool_ops->set_dump)
1551                 return -EOPNOTSUPP;
1552
1553         if (copy_from_user(&dump, useraddr, sizeof(dump)))
1554                 return -EFAULT;
1555
1556         return dev->ethtool_ops->set_dump(dev, &dump);
1557 }
1558
1559 static int ethtool_get_dump_flag(struct net_device *dev,
1560                                 void __user *useraddr)
1561 {
1562         int ret;
1563         struct ethtool_dump dump;
1564         const struct ethtool_ops *ops = dev->ethtool_ops;
1565
1566         if (!dev->ethtool_ops->get_dump_flag)
1567                 return -EOPNOTSUPP;
1568
1569         if (copy_from_user(&dump, useraddr, sizeof(dump)))
1570                 return -EFAULT;
1571
1572         ret = ops->get_dump_flag(dev, &dump);
1573         if (ret)
1574                 return ret;
1575
1576         if (copy_to_user(useraddr, &dump, sizeof(dump)))
1577                 return -EFAULT;
1578         return 0;
1579 }
1580
1581 static int ethtool_get_dump_data(struct net_device *dev,
1582                                 void __user *useraddr)
1583 {
1584         int ret;
1585         __u32 len;
1586         struct ethtool_dump dump, tmp;
1587         const struct ethtool_ops *ops = dev->ethtool_ops;
1588         void *data = NULL;
1589
1590         if (!dev->ethtool_ops->get_dump_data ||
1591                 !dev->ethtool_ops->get_dump_flag)
1592                 return -EOPNOTSUPP;
1593
1594         if (copy_from_user(&dump, useraddr, sizeof(dump)))
1595                 return -EFAULT;
1596
1597         memset(&tmp, 0, sizeof(tmp));
1598         tmp.cmd = ETHTOOL_GET_DUMP_FLAG;
1599         ret = ops->get_dump_flag(dev, &tmp);
1600         if (ret)
1601                 return ret;
1602
1603         len = (tmp.len > dump.len) ? dump.len : tmp.len;
1604         if (!len)
1605                 return -EFAULT;
1606
1607         data = vzalloc(tmp.len);
1608         if (!data)
1609                 return -ENOMEM;
1610         ret = ops->get_dump_data(dev, &dump, data);
1611         if (ret)
1612                 goto out;
1613
1614         if (copy_to_user(useraddr, &dump, sizeof(dump))) {
1615                 ret = -EFAULT;
1616                 goto out;
1617         }
1618         useraddr += offsetof(struct ethtool_dump, data);
1619         if (copy_to_user(useraddr, data, len))
1620                 ret = -EFAULT;
1621 out:
1622         vfree(data);
1623         return ret;
1624 }
1625
1626 /* The main entry point in this file.  Called from net/core/dev.c */
1627
1628 int dev_ethtool(struct net *net, struct ifreq *ifr)
1629 {
1630         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
1631         void __user *useraddr = ifr->ifr_data;
1632         u32 ethcmd;
1633         int rc;
1634         u32 old_features;
1635
1636         if (!dev || !netif_device_present(dev))
1637                 return -ENODEV;
1638
1639         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1640                 return -EFAULT;
1641
1642         if (!dev->ethtool_ops) {
1643                 /* ETHTOOL_GDRVINFO does not require any driver support.
1644                  * It is also unprivileged and does not change anything,
1645                  * so we can take a shortcut to it. */
1646                 if (ethcmd == ETHTOOL_GDRVINFO)
1647                         return ethtool_get_drvinfo(dev, useraddr);
1648                 else
1649                         return -EOPNOTSUPP;
1650         }
1651
1652         /* Allow some commands to be done by anyone */
1653         switch (ethcmd) {
1654         case ETHTOOL_GSET:
1655         case ETHTOOL_GDRVINFO:
1656         case ETHTOOL_GMSGLVL:
1657         case ETHTOOL_GCOALESCE:
1658         case ETHTOOL_GRINGPARAM:
1659         case ETHTOOL_GPAUSEPARAM:
1660         case ETHTOOL_GRXCSUM:
1661         case ETHTOOL_GTXCSUM:
1662         case ETHTOOL_GSG:
1663         case ETHTOOL_GSTRINGS:
1664         case ETHTOOL_GTSO:
1665         case ETHTOOL_GPERMADDR:
1666         case ETHTOOL_GUFO:
1667         case ETHTOOL_GGSO:
1668         case ETHTOOL_GGRO:
1669         case ETHTOOL_GFLAGS:
1670         case ETHTOOL_GPFLAGS:
1671         case ETHTOOL_GRXFH:
1672         case ETHTOOL_GRXRINGS:
1673         case ETHTOOL_GRXCLSRLCNT:
1674         case ETHTOOL_GRXCLSRULE:
1675         case ETHTOOL_GRXCLSRLALL:
1676         case ETHTOOL_GFEATURES:
1677                 break;
1678         default:
1679                 if (!capable(CAP_NET_ADMIN))
1680                         return -EPERM;
1681         }
1682
1683         if (dev->ethtool_ops->begin) {
1684                 rc = dev->ethtool_ops->begin(dev);
1685                 if (rc  < 0)
1686                         return rc;
1687         }
1688         old_features = dev->features;
1689
1690         switch (ethcmd) {
1691         case ETHTOOL_GSET:
1692                 rc = ethtool_get_settings(dev, useraddr);
1693                 break;
1694         case ETHTOOL_SSET:
1695                 rc = ethtool_set_settings(dev, useraddr);
1696                 break;
1697         case ETHTOOL_GDRVINFO:
1698                 rc = ethtool_get_drvinfo(dev, useraddr);
1699                 break;
1700         case ETHTOOL_GREGS:
1701                 rc = ethtool_get_regs(dev, useraddr);
1702                 break;
1703         case ETHTOOL_GWOL:
1704                 rc = ethtool_get_wol(dev, useraddr);
1705                 break;
1706         case ETHTOOL_SWOL:
1707                 rc = ethtool_set_wol(dev, useraddr);
1708                 break;
1709         case ETHTOOL_GMSGLVL:
1710                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1711                                        dev->ethtool_ops->get_msglevel);
1712                 break;
1713         case ETHTOOL_SMSGLVL:
1714                 rc = ethtool_set_value_void(dev, useraddr,
1715                                        dev->ethtool_ops->set_msglevel);
1716                 break;
1717         case ETHTOOL_NWAY_RST:
1718                 rc = ethtool_nway_reset(dev);
1719                 break;
1720         case ETHTOOL_GLINK:
1721                 rc = ethtool_get_link(dev, useraddr);
1722                 break;
1723         case ETHTOOL_GEEPROM:
1724                 rc = ethtool_get_eeprom(dev, useraddr);
1725                 break;
1726         case ETHTOOL_SEEPROM:
1727                 rc = ethtool_set_eeprom(dev, useraddr);
1728                 break;
1729         case ETHTOOL_GCOALESCE:
1730                 rc = ethtool_get_coalesce(dev, useraddr);
1731                 break;
1732         case ETHTOOL_SCOALESCE:
1733                 rc = ethtool_set_coalesce(dev, useraddr);
1734                 break;
1735         case ETHTOOL_GRINGPARAM:
1736                 rc = ethtool_get_ringparam(dev, useraddr);
1737                 break;
1738         case ETHTOOL_SRINGPARAM:
1739                 rc = ethtool_set_ringparam(dev, useraddr);
1740                 break;
1741         case ETHTOOL_GPAUSEPARAM:
1742                 rc = ethtool_get_pauseparam(dev, useraddr);
1743                 break;
1744         case ETHTOOL_SPAUSEPARAM:
1745                 rc = ethtool_set_pauseparam(dev, useraddr);
1746                 break;
1747         case ETHTOOL_TEST:
1748                 rc = ethtool_self_test(dev, useraddr);
1749                 break;
1750         case ETHTOOL_GSTRINGS:
1751                 rc = ethtool_get_strings(dev, useraddr);
1752                 break;
1753         case ETHTOOL_PHYS_ID:
1754                 rc = ethtool_phys_id(dev, useraddr);
1755                 break;
1756         case ETHTOOL_GSTATS:
1757                 rc = ethtool_get_stats(dev, useraddr);
1758                 break;
1759         case ETHTOOL_GPERMADDR:
1760                 rc = ethtool_get_perm_addr(dev, useraddr);
1761                 break;
1762         case ETHTOOL_GFLAGS:
1763                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1764                                        (dev->ethtool_ops->get_flags ?
1765                                         dev->ethtool_ops->get_flags :
1766                                         ethtool_op_get_flags));
1767                 break;
1768         case ETHTOOL_SFLAGS:
1769                 rc = ethtool_set_value(dev, useraddr, __ethtool_set_flags);
1770                 break;
1771         case ETHTOOL_GPFLAGS:
1772                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1773                                        dev->ethtool_ops->get_priv_flags);
1774                 break;
1775         case ETHTOOL_SPFLAGS:
1776                 rc = ethtool_set_value(dev, useraddr,
1777                                        dev->ethtool_ops->set_priv_flags);
1778                 break;
1779         case ETHTOOL_GRXFH:
1780         case ETHTOOL_GRXRINGS:
1781         case ETHTOOL_GRXCLSRLCNT:
1782         case ETHTOOL_GRXCLSRULE:
1783         case ETHTOOL_GRXCLSRLALL:
1784                 rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
1785                 break;
1786         case ETHTOOL_SRXFH:
1787         case ETHTOOL_SRXCLSRLDEL:
1788         case ETHTOOL_SRXCLSRLINS:
1789                 rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
1790                 break;
1791         case ETHTOOL_FLASHDEV:
1792                 rc = ethtool_flash_device(dev, useraddr);
1793                 break;
1794         case ETHTOOL_RESET:
1795                 rc = ethtool_reset(dev, useraddr);
1796                 break;
1797         case ETHTOOL_SRXNTUPLE:
1798                 rc = ethtool_set_rx_ntuple(dev, useraddr);
1799                 break;
1800         case ETHTOOL_GSSET_INFO:
1801                 rc = ethtool_get_sset_info(dev, useraddr);
1802                 break;
1803         case ETHTOOL_GRXFHINDIR:
1804                 rc = ethtool_get_rxfh_indir(dev, useraddr);
1805                 break;
1806         case ETHTOOL_SRXFHINDIR:
1807                 rc = ethtool_set_rxfh_indir(dev, useraddr);
1808                 break;
1809         case ETHTOOL_GFEATURES:
1810                 rc = ethtool_get_features(dev, useraddr);
1811                 break;
1812         case ETHTOOL_SFEATURES:
1813                 rc = ethtool_set_features(dev, useraddr);
1814                 break;
1815         case ETHTOOL_GTXCSUM:
1816         case ETHTOOL_GRXCSUM:
1817         case ETHTOOL_GSG:
1818         case ETHTOOL_GTSO:
1819         case ETHTOOL_GUFO:
1820         case ETHTOOL_GGSO:
1821         case ETHTOOL_GGRO:
1822                 rc = ethtool_get_one_feature(dev, useraddr, ethcmd);
1823                 break;
1824         case ETHTOOL_STXCSUM:
1825         case ETHTOOL_SRXCSUM:
1826         case ETHTOOL_SSG:
1827         case ETHTOOL_STSO:
1828         case ETHTOOL_SUFO:
1829         case ETHTOOL_SGSO:
1830         case ETHTOOL_SGRO:
1831                 rc = ethtool_set_one_feature(dev, useraddr, ethcmd);
1832                 break;
1833         case ETHTOOL_GCHANNELS:
1834                 rc = ethtool_get_channels(dev, useraddr);
1835                 break;
1836         case ETHTOOL_SCHANNELS:
1837                 rc = ethtool_set_channels(dev, useraddr);
1838                 break;
1839         case ETHTOOL_SET_DUMP:
1840                 rc = ethtool_set_dump(dev, useraddr);
1841                 break;
1842         case ETHTOOL_GET_DUMP_FLAG:
1843                 rc = ethtool_get_dump_flag(dev, useraddr);
1844                 break;
1845         case ETHTOOL_GET_DUMP_DATA:
1846                 rc = ethtool_get_dump_data(dev, useraddr);
1847                 break;
1848         default:
1849                 rc = -EOPNOTSUPP;
1850         }
1851
1852         if (dev->ethtool_ops->complete)
1853                 dev->ethtool_ops->complete(dev);
1854
1855         if (old_features != dev->features)
1856                 netdev_features_change(dev);
1857
1858         return rc;
1859 }