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/slab.h>
  23
  24 /*
  25  * Some useful ethtool_ops methods that're device independent.
  26  * If we find that all drivers want to do the same thing here,
  27  * we can turn these into dev_() function calls.
  28  */
  29
  30 u32 ethtool_op_get_link(struct net_device *dev)
  31 {
  32         return netif_carrier_ok(dev) ? 1 : 0;
  33 }
  34 EXPORT_SYMBOL(ethtool_op_get_link);
  35
  36 u32 ethtool_op_get_rx_csum(struct net_device *dev)
  37 {
  38         return (dev->features & NETIF_F_ALL_CSUM) != 0;
  39 }
  40 EXPORT_SYMBOL(ethtool_op_get_rx_csum);
  41
  42 u32 ethtool_op_get_tx_csum(struct net_device *dev)
  43 {
  44         return (dev->features & NETIF_F_ALL_CSUM) != 0;
  45 }
  46 EXPORT_SYMBOL(ethtool_op_get_tx_csum);
  47
  48 int ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
  49 {
  50         if (data)
  51                 dev->features |= NETIF_F_IP_CSUM;
  52         else
  53                 dev->features &= ~NETIF_F_IP_CSUM;
  54
  55         return 0;
  56 }
  57
  58 int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)
  59 {
  60         if (data)
  61                 dev->features |= NETIF_F_HW_CSUM;
  62         else
  63                 dev->features &= ~NETIF_F_HW_CSUM;
  64
  65         return 0;
  66 }
  67 EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
  68
  69 int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)
  70 {
  71         if (data)
  72                 dev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
  73         else
  74                 dev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
  75
  76         return 0;
  77 }
  78 EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
  79
  80 u32 ethtool_op_get_sg(struct net_device *dev)
  81 {
  82         return (dev->features & NETIF_F_SG) != 0;
  83 }
  84 EXPORT_SYMBOL(ethtool_op_get_sg);
  85
  86 int ethtool_op_set_sg(struct net_device *dev, u32 data)
  87 {
  88         if (data)
  89                 dev->features |= NETIF_F_SG;
  90         else
  91                 dev->features &= ~NETIF_F_SG;
  92
  93         return 0;
  94 }
  95 EXPORT_SYMBOL(ethtool_op_set_sg);
  96
  97 u32 ethtool_op_get_tso(struct net_device *dev)
  98 {
  99         return (dev->features & NETIF_F_TSO) != 0;
 100 }
 101 EXPORT_SYMBOL(ethtool_op_get_tso);
 102
 103 int ethtool_op_set_tso(struct net_device *dev, u32 data)
 104 {
 105         if (data)
 106                 dev->features |= NETIF_F_TSO;
 107         else
 108                 dev->features &= ~NETIF_F_TSO;
 109
 110         return 0;
 111 }
 112 EXPORT_SYMBOL(ethtool_op_set_tso);
 113
 114 u32 ethtool_op_get_ufo(struct net_device *dev)
 115 {
 116         return (dev->features & NETIF_F_UFO) != 0;
 117 }
 118 EXPORT_SYMBOL(ethtool_op_get_ufo);
 119
 120 int ethtool_op_set_ufo(struct net_device *dev, u32 data)
 121 {
 122         if (data)
 123                 dev->features |= NETIF_F_UFO;
 124         else
 125                 dev->features &= ~NETIF_F_UFO;
 126         return 0;
 127 }
 128 EXPORT_SYMBOL(ethtool_op_set_ufo);
 129
 130 /* the following list of flags are the same as their associated
 131  * NETIF_F_xxx values in include/linux/netdevice.h
 132  */
 133 static const u32 flags_dup_features =
 134         (ETH_FLAG_LRO | ETH_FLAG_NTUPLE | ETH_FLAG_RXHASH);
 135
 136 u32 ethtool_op_get_flags(struct net_device *dev)
 137 {
 138         /* in the future, this function will probably contain additional
 139          * handling for flags which are not so easily handled
 140          * by a simple masking operation
 141          */
 142
 143         return dev->features & flags_dup_features;
 144 }
 145 EXPORT_SYMBOL(ethtool_op_get_flags);
 146
 147 int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported)
 148 {
 149         if (data & ~supported)
 150                 return -EINVAL;
 151
 152         dev->features = ((dev->features & ~flags_dup_features) |
 153                          (data & flags_dup_features));
 154         return 0;
 155 }
 156 EXPORT_SYMBOL(ethtool_op_set_flags);
 157
 158 void ethtool_ntuple_flush(struct net_device *dev)
 159 {
 160         struct ethtool_rx_ntuple_flow_spec_container *fsc, *f;
 161
 162         list_for_each_entry_safe(fsc, f, &dev->ethtool_ntuple_list.list, list) {
 163                 list_del(&fsc->list);
 164                 kfree(fsc);
 165         }
 166         dev->ethtool_ntuple_list.count = 0;
 167 }
 168 EXPORT_SYMBOL(ethtool_ntuple_flush);
 169
 170 /* Handlers for each ethtool command */
 171
 172 static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
 173 {
 174         struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
 175         int err;
 176
 177         if (!dev->ethtool_ops->get_settings)
 178                 return -EOPNOTSUPP;
 179
 180         err = dev->ethtool_ops->get_settings(dev, &cmd);
 181         if (err < 0)
 182                 return err;
 183
 184         if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
 185                 return -EFAULT;
 186         return 0;
 187 }
 188
 189 static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
 190 {
 191         struct ethtool_cmd cmd;
 192
 193         if (!dev->ethtool_ops->set_settings)
 194                 return -EOPNOTSUPP;
 195
 196         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
 197                 return -EFAULT;
 198
 199         return dev->ethtool_ops->set_settings(dev, &cmd);
 200 }
 201
 202 static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
 203                                                   void __user *useraddr)
 204 {
 205         struct ethtool_drvinfo info;
 206         const struct ethtool_ops *ops = dev->ethtool_ops;
 207
 208         memset(&info, 0, sizeof(info));
 209         info.cmd = ETHTOOL_GDRVINFO;
 210         if (ops && ops->get_drvinfo) {
 211                 ops->get_drvinfo(dev, &info);
 212         } else if (dev->dev.parent && dev->dev.parent->driver) {
 213                 strlcpy(info.bus_info, dev_name(dev->dev.parent),
 214                         sizeof(info.bus_info));
 215                 strlcpy(info.driver, dev->dev.parent->driver->name,
 216                         sizeof(info.driver));
 217         } else {
 218                 return -EOPNOTSUPP;
 219         }
 220
 221         /*
 222          * this method of obtaining string set info is deprecated;
 223          * Use ETHTOOL_GSSET_INFO instead.
 224          */
 225         if (ops && ops->get_sset_count) {
 226                 int rc;
 227
 228                 rc = ops->get_sset_count(dev, ETH_SS_TEST);
 229                 if (rc >= 0)
 230                         info.testinfo_len = rc;
 231                 rc = ops->get_sset_count(dev, ETH_SS_STATS);
 232                 if (rc >= 0)
 233                         info.n_stats = rc;
 234                 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
 235                 if (rc >= 0)
 236                         info.n_priv_flags = rc;
 237         }
 238         if (ops && ops->get_regs_len)
 239                 info.regdump_len = ops->get_regs_len(dev);
 240         if (ops && ops->get_eeprom_len)
 241                 info.eedump_len = ops->get_eeprom_len(dev);
 242
 243         if (copy_to_user(useraddr, &info, sizeof(info)))
 244                 return -EFAULT;
 245         return 0;
 246 }
 247
 248 static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
 249                                                     void __user *useraddr)
 250 {
 251         struct ethtool_sset_info info;
 252         const struct ethtool_ops *ops = dev->ethtool_ops;
 253         u64 sset_mask;
 254         int i, idx = 0, n_bits = 0, ret, rc;
 255         u32 *info_buf = NULL;
 256
 257         if (!ops->get_sset_count)
 258                 return -EOPNOTSUPP;
 259
 260         if (copy_from_user(&info, useraddr, sizeof(info)))
 261                 return -EFAULT;
 262
 263         /* store copy of mask, because we zero struct later on */
 264         sset_mask = info.sset_mask;
 265         if (!sset_mask)
 266                 return 0;
 267
 268         /* calculate size of return buffer */
 269         n_bits = hweight64(sset_mask);
 270
 271         memset(&info, 0, sizeof(info));
 272         info.cmd = ETHTOOL_GSSET_INFO;
 273
 274         info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
 275         if (!info_buf)
 276                 return -ENOMEM;
 277
 278         /*
 279          * fill return buffer based on input bitmask and successful
 280          * get_sset_count return
 281          */
 282         for (i = 0; i < 64; i++) {
 283                 if (!(sset_mask & (1ULL << i)))
 284                         continue;
 285
 286                 rc = ops->get_sset_count(dev, i);
 287                 if (rc >= 0) {
 288                         info.sset_mask |= (1ULL << i);
 289                         info_buf[idx++] = rc;
 290                 }
 291         }
 292
 293         ret = -EFAULT;
 294         if (copy_to_user(useraddr, &info, sizeof(info)))
 295                 goto out;
 296
 297         useraddr += offsetof(struct ethtool_sset_info, data);
 298         if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
 299                 goto out;
 300
 301         ret = 0;
 302
 303 out:
 304         kfree(info_buf);
 305         return ret;
 306 }
 307
 308 static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
 309                                                 u32 cmd, void __user *useraddr)
 310 {
 311         struct ethtool_rxnfc info;
 312         size_t info_size = sizeof(info);
 313
 314         if (!dev->ethtool_ops->set_rxnfc)
 315                 return -EOPNOTSUPP;
 316
 317         /* struct ethtool_rxnfc was originally defined for
 318          * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
 319          * members.  User-space might still be using that
 320          * definition. */
 321         if (cmd == ETHTOOL_SRXFH)
 322                 info_size = (offsetof(struct ethtool_rxnfc, data) +
 323                              sizeof(info.data));
 324
 325         if (copy_from_user(&info, useraddr, info_size))
 326                 return -EFAULT;
 327
 328         return dev->ethtool_ops->set_rxnfc(dev, &info);
 329 }
 330
 331 static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
 332                                                 u32 cmd, void __user *useraddr)
 333 {
 334         struct ethtool_rxnfc info;
 335         size_t info_size = sizeof(info);
 336         const struct ethtool_ops *ops = dev->ethtool_ops;
 337         int ret;
 338         void *rule_buf = NULL;
 339
 340         if (!ops->get_rxnfc)
 341                 return -EOPNOTSUPP;
 342
 343         /* struct ethtool_rxnfc was originally defined for
 344          * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
 345          * members.  User-space might still be using that
 346          * definition. */
 347         if (cmd == ETHTOOL_GRXFH)
 348                 info_size = (offsetof(struct ethtool_rxnfc, data) +
 349                              sizeof(info.data));
 350
 351         if (copy_from_user(&info, useraddr, info_size))
 352                 return -EFAULT;
 353
 354         if (info.cmd == ETHTOOL_GRXCLSRLALL) {
 355                 if (info.rule_cnt > 0) {
 356                         if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
 357                                 rule_buf = kmalloc(info.rule_cnt * sizeof(u32),
 358                                                    GFP_USER);
 359                         if (!rule_buf)
 360                                 return -ENOMEM;
 361                 }
 362         }
 363
 364         ret = ops->get_rxnfc(dev, &info, rule_buf);
 365         if (ret < 0)
 366                 goto err_out;
 367
 368         ret = -EFAULT;
 369         if (copy_to_user(useraddr, &info, info_size))
 370                 goto err_out;
 371
 372         if (rule_buf) {
 373                 useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
 374                 if (copy_to_user(useraddr, rule_buf,
 375                                  info.rule_cnt * sizeof(u32)))
 376                         goto err_out;
 377         }
 378         ret = 0;
 379
 380 err_out:
 381         kfree(rule_buf);
 382
 383         return ret;
 384 }
 385
 386 static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,
 387                                                      void __user *useraddr)
 388 {
 389         struct ethtool_rxfh_indir *indir;
 390         u32 table_size;
 391         size_t full_size;
 392         int ret;
 393
 394         if (!dev->ethtool_ops->get_rxfh_indir)
 395                 return -EOPNOTSUPP;
 396
 397         if (copy_from_user(&table_size,
 398                            useraddr + offsetof(struct ethtool_rxfh_indir, size),
 399                            sizeof(table_size)))
 400                 return -EFAULT;
 401
 402         if (table_size >
 403             (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
 404                 return -ENOMEM;
 405         full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
 406         indir = kmalloc(full_size, GFP_USER);
 407         if (!indir)
 408                 return -ENOMEM;
 409
 410         indir->cmd = ETHTOOL_GRXFHINDIR;
 411         indir->size = table_size;
 412         ret = dev->ethtool_ops->get_rxfh_indir(dev, indir);
 413         if (ret)
 414                 goto out;
 415
 416         if (copy_to_user(useraddr, indir, full_size))
 417                 ret = -EFAULT;
 418
 419 out:
 420         kfree(indir);
 421         return ret;
 422 }
 423
 424 static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,
 425                                                      void __user *useraddr)
 426 {
 427         struct ethtool_rxfh_indir *indir;
 428         u32 table_size;
 429         size_t full_size;
 430         int ret;
 431
 432         if (!dev->ethtool_ops->set_rxfh_indir)
 433                 return -EOPNOTSUPP;
 434
 435         if (copy_from_user(&table_size,
 436                            useraddr + offsetof(struct ethtool_rxfh_indir, size),
 437                            sizeof(table_size)))
 438                 return -EFAULT;
 439
 440         if (table_size >
 441             (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
 442                 return -ENOMEM;
 443         full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
 444         indir = kmalloc(full_size, GFP_USER);
 445         if (!indir)
 446                 return -ENOMEM;
 447
 448         if (copy_from_user(indir, useraddr, full_size)) {
 449                 ret = -EFAULT;
 450                 goto out;
 451         }
 452
 453         ret = dev->ethtool_ops->set_rxfh_indir(dev, indir);
 454
 455 out:
 456         kfree(indir);
 457         return ret;
 458 }
 459
 460 static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,
 461                         struct ethtool_rx_ntuple_flow_spec *spec,
 462                         struct ethtool_rx_ntuple_flow_spec_container *fsc)
 463 {
 464
 465         /* don't add filters forever */
 466         if (list->count >= ETHTOOL_MAX_NTUPLE_LIST_ENTRY) {
 467                 /* free the container */
 468                 kfree(fsc);
 469                 return;
 470         }
 471
 472         /* Copy the whole filter over */
 473         fsc->fs.flow_type = spec->flow_type;
 474         memcpy(&fsc->fs.h_u, &spec->h_u, sizeof(spec->h_u));
 475         memcpy(&fsc->fs.m_u, &spec->m_u, sizeof(spec->m_u));
 476
 477         fsc->fs.vlan_tag = spec->vlan_tag;
 478         fsc->fs.vlan_tag_mask = spec->vlan_tag_mask;
 479         fsc->fs.data = spec->data;
 480         fsc->fs.data_mask = spec->data_mask;
 481         fsc->fs.action = spec->action;
 482
 483         /* add to the list */
 484         list_add_tail_rcu(&fsc->list, &list->list);
 485         list->count++;
 486 }
 487
 488 static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
 489                                                     void __user *useraddr)
 490 {
 491         struct ethtool_rx_ntuple cmd;
 492         const struct ethtool_ops *ops = dev->ethtool_ops;
 493         struct ethtool_rx_ntuple_flow_spec_container *fsc = NULL;
 494         int ret;
 495
 496         if (!(dev->features & NETIF_F_NTUPLE))
 497                 return -EINVAL;
 498
 499         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
 500                 return -EFAULT;
 501
 502         /*
 503          * Cache filter in dev struct for GET operation only if
 504          * the underlying driver doesn't have its own GET operation, and
 505          * only if the filter was added successfully.  First make sure we
 506          * can allocate the filter, then continue if successful.
 507          */
 508         if (!ops->get_rx_ntuple) {
 509                 fsc = kmalloc(sizeof(*fsc), GFP_ATOMIC);
 510                 if (!fsc)
 511                         return -ENOMEM;
 512         }
 513
 514         ret = ops->set_rx_ntuple(dev, &cmd);
 515         if (ret) {
 516                 kfree(fsc);
 517                 return ret;
 518         }
 519
 520         if (!ops->get_rx_ntuple)
 521                 __rx_ntuple_filter_add(&dev->ethtool_ntuple_list, &cmd.fs, fsc);
 522
 523         return ret;
 524 }
 525
 526 static int ethtool_get_rx_ntuple(struct net_device *dev, void __user *useraddr)
 527 {
 528         struct ethtool_gstrings gstrings;
 529         const struct ethtool_ops *ops = dev->ethtool_ops;
 530         struct ethtool_rx_ntuple_flow_spec_container *fsc;
 531         u8 *data;
 532         char *p;
 533         int ret, i, num_strings = 0;
 534
 535         if (!ops->get_sset_count)
 536                 return -EOPNOTSUPP;
 537
 538         if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
 539                 return -EFAULT;
 540
 541         ret = ops->get_sset_count(dev, gstrings.string_set);
 542         if (ret < 0)
 543                 return ret;
 544
 545         gstrings.len = ret;
 546
 547         data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
 548         if (!data)
 549                 return -ENOMEM;
 550
 551         if (ops->get_rx_ntuple) {
 552                 /* driver-specific filter grab */
 553                 ret = ops->get_rx_ntuple(dev, gstrings.string_set, data);
 554                 goto copy;
 555         }
 556
 557         /* default ethtool filter grab */
 558         i = 0;
 559         p = (char *)data;
 560         list_for_each_entry(fsc, &dev->ethtool_ntuple_list.list, list) {
 561                 sprintf(p, "Filter %d:\n", i);
 562                 p += ETH_GSTRING_LEN;
 563                 num_strings++;
 564
 565                 switch (fsc->fs.flow_type) {
 566                 case TCP_V4_FLOW:
 567                         sprintf(p, "\tFlow Type: TCP\n");
 568                         p += ETH_GSTRING_LEN;
 569                         num_strings++;
 570                         break;
 571                 case UDP_V4_FLOW:
 572                         sprintf(p, "\tFlow Type: UDP\n");
 573                         p += ETH_GSTRING_LEN;
 574                         num_strings++;
 575                         break;
 576                 case SCTP_V4_FLOW:
 577                         sprintf(p, "\tFlow Type: SCTP\n");
 578                         p += ETH_GSTRING_LEN;
 579                         num_strings++;
 580                         break;
 581                 case AH_ESP_V4_FLOW:
 582                         sprintf(p, "\tFlow Type: AH ESP\n");
 583                         p += ETH_GSTRING_LEN;
 584                         num_strings++;
 585                         break;
 586                 case ESP_V4_FLOW:
 587                         sprintf(p, "\tFlow Type: ESP\n");
 588                         p += ETH_GSTRING_LEN;
 589                         num_strings++;
 590                         break;
 591                 case IP_USER_FLOW:
 592                         sprintf(p, "\tFlow Type: Raw IP\n");
 593                         p += ETH_GSTRING_LEN;
 594                         num_strings++;
 595                         break;
 596                 case IPV4_FLOW:
 597                         sprintf(p, "\tFlow Type: IPv4\n");
 598                         p += ETH_GSTRING_LEN;
 599                         num_strings++;
 600                         break;
 601                 default:
 602                         sprintf(p, "\tFlow Type: Unknown\n");
 603                         p += ETH_GSTRING_LEN;
 604                         num_strings++;
 605                         goto unknown_filter;
 606                 }
 607
 608                 /* now the rest of the filters */
 609                 switch (fsc->fs.flow_type) {
 610                 case TCP_V4_FLOW:
 611                 case UDP_V4_FLOW:
 612                 case SCTP_V4_FLOW:
 613                         sprintf(p, "\tSrc IP addr: 0x%x\n",
 614                                 fsc->fs.h_u.tcp_ip4_spec.ip4src);
 615                         p += ETH_GSTRING_LEN;
 616                         num_strings++;
 617                         sprintf(p, "\tSrc IP mask: 0x%x\n",
 618                                 fsc->fs.m_u.tcp_ip4_spec.ip4src);
 619                         p += ETH_GSTRING_LEN;
 620                         num_strings++;
 621                         sprintf(p, "\tDest IP addr: 0x%x\n",
 622                                 fsc->fs.h_u.tcp_ip4_spec.ip4dst);
 623                         p += ETH_GSTRING_LEN;
 624                         num_strings++;
 625                         sprintf(p, "\tDest IP mask: 0x%x\n",
 626                                 fsc->fs.m_u.tcp_ip4_spec.ip4dst);
 627                         p += ETH_GSTRING_LEN;
 628                         num_strings++;
 629                         sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",
 630                                 fsc->fs.h_u.tcp_ip4_spec.psrc,
 631                                 fsc->fs.m_u.tcp_ip4_spec.psrc);
 632                         p += ETH_GSTRING_LEN;
 633                         num_strings++;
 634                         sprintf(p, "\tDest Port: %d, mask: 0x%x\n",
 635                                 fsc->fs.h_u.tcp_ip4_spec.pdst,
 636                                 fsc->fs.m_u.tcp_ip4_spec.pdst);
 637                         p += ETH_GSTRING_LEN;
 638                         num_strings++;
 639                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
 640                                 fsc->fs.h_u.tcp_ip4_spec.tos,
 641                                 fsc->fs.m_u.tcp_ip4_spec.tos);
 642                         p += ETH_GSTRING_LEN;
 643                         num_strings++;
 644                         break;
 645                 case AH_ESP_V4_FLOW:
 646                 case ESP_V4_FLOW:
 647                         sprintf(p, "\tSrc IP addr: 0x%x\n",
 648                                 fsc->fs.h_u.ah_ip4_spec.ip4src);
 649                         p += ETH_GSTRING_LEN;
 650                         num_strings++;
 651                         sprintf(p, "\tSrc IP mask: 0x%x\n",
 652                                 fsc->fs.m_u.ah_ip4_spec.ip4src);
 653                         p += ETH_GSTRING_LEN;
 654                         num_strings++;
 655                         sprintf(p, "\tDest IP addr: 0x%x\n",
 656                                 fsc->fs.h_u.ah_ip4_spec.ip4dst);
 657                         p += ETH_GSTRING_LEN;
 658                         num_strings++;
 659                         sprintf(p, "\tDest IP mask: 0x%x\n",
 660                                 fsc->fs.m_u.ah_ip4_spec.ip4dst);
 661                         p += ETH_GSTRING_LEN;
 662                         num_strings++;
 663                         sprintf(p, "\tSPI: %d, mask: 0x%x\n",
 664                                 fsc->fs.h_u.ah_ip4_spec.spi,
 665                                 fsc->fs.m_u.ah_ip4_spec.spi);
 666                         p += ETH_GSTRING_LEN;
 667                         num_strings++;
 668                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
 669                                 fsc->fs.h_u.ah_ip4_spec.tos,
 670                                 fsc->fs.m_u.ah_ip4_spec.tos);
 671                         p += ETH_GSTRING_LEN;
 672                         num_strings++;
 673                         break;
 674                 case IP_USER_FLOW:
 675                         sprintf(p, "\tSrc IP addr: 0x%x\n",
 676                                 fsc->fs.h_u.raw_ip4_spec.ip4src);
 677                         p += ETH_GSTRING_LEN;
 678                         num_strings++;
 679                         sprintf(p, "\tSrc IP mask: 0x%x\n",
 680                                 fsc->fs.m_u.raw_ip4_spec.ip4src);
 681                         p += ETH_GSTRING_LEN;
 682                         num_strings++;
 683                         sprintf(p, "\tDest IP addr: 0x%x\n",
 684                                 fsc->fs.h_u.raw_ip4_spec.ip4dst);
 685                         p += ETH_GSTRING_LEN;
 686                         num_strings++;
 687                         sprintf(p, "\tDest IP mask: 0x%x\n",
 688                                 fsc->fs.m_u.raw_ip4_spec.ip4dst);
 689                         p += ETH_GSTRING_LEN;
 690                         num_strings++;
 691                         break;
 692                 case IPV4_FLOW:
 693                         sprintf(p, "\tSrc IP addr: 0x%x\n",
 694                                 fsc->fs.h_u.usr_ip4_spec.ip4src);
 695                         p += ETH_GSTRING_LEN;
 696                         num_strings++;
 697                         sprintf(p, "\tSrc IP mask: 0x%x\n",
 698                                 fsc->fs.m_u.usr_ip4_spec.ip4src);
 699                         p += ETH_GSTRING_LEN;
 700                         num_strings++;
 701                         sprintf(p, "\tDest IP addr: 0x%x\n",
 702                                 fsc->fs.h_u.usr_ip4_spec.ip4dst);
 703                         p += ETH_GSTRING_LEN;
 704                         num_strings++;
 705                         sprintf(p, "\tDest IP mask: 0x%x\n",
 706                                 fsc->fs.m_u.usr_ip4_spec.ip4dst);
 707                         p += ETH_GSTRING_LEN;
 708                         num_strings++;
 709                         sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",
 710                                 fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
 711                                 fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
 712                         p += ETH_GSTRING_LEN;
 713                         num_strings++;
 714                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
 715                                 fsc->fs.h_u.usr_ip4_spec.tos,
 716                                 fsc->fs.m_u.usr_ip4_spec.tos);
 717                         p += ETH_GSTRING_LEN;
 718                         num_strings++;
 719                         sprintf(p, "\tIP Version: %d, mask: 0x%x\n",
 720                                 fsc->fs.h_u.usr_ip4_spec.ip_ver,
 721                                 fsc->fs.m_u.usr_ip4_spec.ip_ver);
 722                         p += ETH_GSTRING_LEN;
 723                         num_strings++;
 724                         sprintf(p, "\tProtocol: %d, mask: 0x%x\n",
 725                                 fsc->fs.h_u.usr_ip4_spec.proto,
 726                                 fsc->fs.m_u.usr_ip4_spec.proto);
 727                         p += ETH_GSTRING_LEN;
 728                         num_strings++;
 729                         break;
 730                 }
 731                 sprintf(p, "\tVLAN: %d, mask: 0x%x\n",
 732                         fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
 733                 p += ETH_GSTRING_LEN;
 734                 num_strings++;
 735                 sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);
 736                 p += ETH_GSTRING_LEN;
 737                 num_strings++;
 738                 sprintf(p, "\tUser-defined mask: 0x%Lx\n", fsc->fs.data_mask);
 739                 p += ETH_GSTRING_LEN;
 740                 num_strings++;
 741                 if (fsc->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)
 742                         sprintf(p, "\tAction: Drop\n");
 743                 else
 744                         sprintf(p, "\tAction: Direct to queue %d\n",
 745                                 fsc->fs.action);
 746                 p += ETH_GSTRING_LEN;
 747                 num_strings++;
 748 unknown_filter:
 749                 i++;
 750         }
 751 copy:
 752         /* indicate to userspace how many strings we actually have */
 753         gstrings.len = num_strings;
 754         ret = -EFAULT;
 755         if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
 756                 goto out;
 757         useraddr += sizeof(gstrings);
 758         if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
 759                 goto out;
 760         ret = 0;
 761
 762 out:
 763         kfree(data);
 764         return ret;
 765 }
 766
 767 static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
 768 {
 769         struct ethtool_regs regs;
 770         const struct ethtool_ops *ops = dev->ethtool_ops;
 771         void *regbuf;
 772         int reglen, ret;
 773
 774         if (!ops->get_regs || !ops->get_regs_len)
 775                 return -EOPNOTSUPP;
 776
 777         if (copy_from_user(&regs, useraddr, sizeof(regs)))
 778                 return -EFAULT;
 779
 780         reglen = ops->get_regs_len(dev);
 781         if (regs.len > reglen)
 782                 regs.len = reglen;
 783
 784         regbuf = kmalloc(reglen, GFP_USER);
 785         if (!regbuf)
 786                 return -ENOMEM;
 787
 788         ops->get_regs(dev, &regs, regbuf);
 789
 790         ret = -EFAULT;
 791         if (copy_to_user(useraddr, &regs, sizeof(regs)))
 792                 goto out;
 793         useraddr += offsetof(struct ethtool_regs, data);
 794         if (copy_to_user(useraddr, regbuf, regs.len))
 795                 goto out;
 796         ret = 0;
 797
 798  out:
 799         kfree(regbuf);
 800         return ret;
 801 }
 802
 803 static int ethtool_reset(struct net_device *dev, char __user *useraddr)
 804 {
 805         struct ethtool_value reset;
 806         int ret;
 807
 808         if (!dev->ethtool_ops->reset)
 809                 return -EOPNOTSUPP;
 810
 811         if (copy_from_user(&reset, useraddr, sizeof(reset)))
 812                 return -EFAULT;
 813
 814         ret = dev->ethtool_ops->reset(dev, &reset.data);
 815         if (ret)
 816                 return ret;
 817
 818         if (copy_to_user(useraddr, &reset, sizeof(reset)))
 819                 return -EFAULT;
 820         return 0;
 821 }
 822
 823 static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
 824 {
 825         struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
 826
 827         if (!dev->ethtool_ops->get_wol)
 828                 return -EOPNOTSUPP;
 829
 830         dev->ethtool_ops->get_wol(dev, &wol);
 831
 832         if (copy_to_user(useraddr, &wol, sizeof(wol)))
 833                 return -EFAULT;
 834         return 0;
 835 }
 836
 837 static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
 838 {
 839         struct ethtool_wolinfo wol;
 840
 841         if (!dev->ethtool_ops->set_wol)
 842                 return -EOPNOTSUPP;
 843
 844         if (copy_from_user(&wol, useraddr, sizeof(wol)))
 845                 return -EFAULT;
 846
 847         return dev->ethtool_ops->set_wol(dev, &wol);
 848 }
 849
 850 static int ethtool_nway_reset(struct net_device *dev)
 851 {
 852         if (!dev->ethtool_ops->nway_reset)
 853                 return -EOPNOTSUPP;
 854
 855         return dev->ethtool_ops->nway_reset(dev);
 856 }
 857
 858 static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
 859 {
 860         struct ethtool_eeprom eeprom;
 861         const struct ethtool_ops *ops = dev->ethtool_ops;
 862         void __user *userbuf = useraddr + sizeof(eeprom);
 863         u32 bytes_remaining;
 864         u8 *data;
 865         int ret = 0;
 866
 867         if (!ops->get_eeprom || !ops->get_eeprom_len)
 868                 return -EOPNOTSUPP;
 869
 870         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
 871                 return -EFAULT;
 872
 873         /* Check for wrap and zero */
 874         if (eeprom.offset + eeprom.len <= eeprom.offset)
 875                 return -EINVAL;
 876
 877         /* Check for exceeding total eeprom len */
 878         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
 879                 return -EINVAL;
 880
 881         data = kmalloc(PAGE_SIZE, GFP_USER);
 882         if (!data)
 883                 return -ENOMEM;
 884
 885         bytes_remaining = eeprom.len;
 886         while (bytes_remaining > 0) {
 887                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
 888
 889                 ret = ops->get_eeprom(dev, &eeprom, data);
 890                 if (ret)
 891                         break;
 892                 if (copy_to_user(userbuf, data, eeprom.len)) {
 893                         ret = -EFAULT;
 894                         break;
 895                 }
 896                 userbuf += eeprom.len;
 897                 eeprom.offset += eeprom.len;
 898                 bytes_remaining -= eeprom.len;
 899         }
 900
 901         eeprom.len = userbuf - (useraddr + sizeof(eeprom));
 902         eeprom.offset -= eeprom.len;
 903         if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
 904                 ret = -EFAULT;
 905
 906         kfree(data);
 907         return ret;
 908 }
 909
 910 static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
 911 {
 912         struct ethtool_eeprom eeprom;
 913         const struct ethtool_ops *ops = dev->ethtool_ops;
 914         void __user *userbuf = useraddr + sizeof(eeprom);
 915         u32 bytes_remaining;
 916         u8 *data;
 917         int ret = 0;
 918
 919         if (!ops->set_eeprom || !ops->get_eeprom_len)
 920                 return -EOPNOTSUPP;
 921
 922         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
 923                 return -EFAULT;
 924
 925         /* Check for wrap and zero */
 926         if (eeprom.offset + eeprom.len <= eeprom.offset)
 927                 return -EINVAL;
 928
 929         /* Check for exceeding total eeprom len */
 930         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
 931                 return -EINVAL;
 932
 933         data = kmalloc(PAGE_SIZE, GFP_USER);
 934         if (!data)
 935                 return -ENOMEM;
 936
 937         bytes_remaining = eeprom.len;
 938         while (bytes_remaining > 0) {
 939                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
 940
 941                 if (copy_from_user(data, userbuf, eeprom.len)) {
 942                         ret = -EFAULT;
 943                         break;
 944                 }
 945                 ret = ops->set_eeprom(dev, &eeprom, data);
 946                 if (ret)
 947                         break;
 948                 userbuf += eeprom.len;
 949                 eeprom.offset += eeprom.len;
 950                 bytes_remaining -= eeprom.len;
 951         }
 952
 953         kfree(data);
 954         return ret;
 955 }
 956
 957 static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
 958                                                    void __user *useraddr)
 959 {
 960         struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
 961
 962         if (!dev->ethtool_ops->get_coalesce)
 963                 return -EOPNOTSUPP;
 964
 965         dev->ethtool_ops->get_coalesce(dev, &coalesce);
 966
 967         if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
 968                 return -EFAULT;
 969         return 0;
 970 }
 971
 972 static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
 973                                                    void __user *useraddr)
 974 {
 975         struct ethtool_coalesce coalesce;
 976
 977         if (!dev->ethtool_ops->set_coalesce)
 978                 return -EOPNOTSUPP;
 979
 980         if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
 981                 return -EFAULT;
 982
 983         return dev->ethtool_ops->set_coalesce(dev, &coalesce);
 984 }
 985
 986 static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
 987 {
 988         struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
 989
 990         if (!dev->ethtool_ops->get_ringparam)
 991                 return -EOPNOTSUPP;
 992
 993         dev->ethtool_ops->get_ringparam(dev, &ringparam);
 994
 995         if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
 996                 return -EFAULT;
 997         return 0;
 998 }
 999
1000 static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
1001 {
1002         struct ethtool_ringparam ringparam;
1003
1004         if (!dev->ethtool_ops->set_ringparam)
1005                 return -EOPNOTSUPP;
1006
1007         if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
1008                 return -EFAULT;
1009
1010         return dev->ethtool_ops->set_ringparam(dev, &ringparam);
1011 }
1012
1013 static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
1014 {
1015         struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
1016
1017         if (!dev->ethtool_ops->get_pauseparam)
1018                 return -EOPNOTSUPP;
1019
1020         dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
1021
1022         if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
1023                 return -EFAULT;
1024         return 0;
1025 }
1026
1027 static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
1028 {
1029         struct ethtool_pauseparam pauseparam;
1030
1031         if (!dev->ethtool_ops->set_pauseparam)
1032                 return -EOPNOTSUPP;
1033
1034         if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
1035                 return -EFAULT;
1036
1037         return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
1038 }
1039
1040 static int __ethtool_set_sg(struct net_device *dev, u32 data)
1041 {
1042         int err;
1043
1044         if (!data && dev->ethtool_ops->set_tso) {
1045                 err = dev->ethtool_ops->set_tso(dev, 0);
1046                 if (err)
1047                         return err;
1048         }
1049
1050         if (!data && dev->ethtool_ops->set_ufo) {
1051                 err = dev->ethtool_ops->set_ufo(dev, 0);
1052                 if (err)
1053                         return err;
1054         }
1055         return dev->ethtool_ops->set_sg(dev, data);
1056 }
1057
1058 static int ethtool_set_tx_csum(struct net_device *dev, char __user *useraddr)
1059 {
1060         struct ethtool_value edata;
1061         int err;
1062
1063         if (!dev->ethtool_ops->set_tx_csum)
1064                 return -EOPNOTSUPP;
1065
1066         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1067                 return -EFAULT;
1068
1069         if (!edata.data && dev->ethtool_ops->set_sg) {
1070                 err = __ethtool_set_sg(dev, 0);
1071                 if (err)
1072                         return err;
1073         }
1074
1075         return dev->ethtool_ops->set_tx_csum(dev, edata.data);
1076 }
1077 EXPORT_SYMBOL(ethtool_op_set_tx_csum);
1078
1079 static int ethtool_set_rx_csum(struct net_device *dev, char __user *useraddr)
1080 {
1081         struct ethtool_value edata;
1082
1083         if (!dev->ethtool_ops->set_rx_csum)
1084                 return -EOPNOTSUPP;
1085
1086         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1087                 return -EFAULT;
1088
1089         if (!edata.data && dev->ethtool_ops->set_sg)
1090                 dev->features &= ~NETIF_F_GRO;
1091
1092         return dev->ethtool_ops->set_rx_csum(dev, edata.data);
1093 }
1094
1095 static int ethtool_set_sg(struct net_device *dev, char __user *useraddr)
1096 {
1097         struct ethtool_value edata;
1098
1099         if (!dev->ethtool_ops->set_sg)
1100                 return -EOPNOTSUPP;
1101
1102         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1103                 return -EFAULT;
1104
1105         if (edata.data &&
1106             !(dev->features & NETIF_F_ALL_CSUM))
1107                 return -EINVAL;
1108
1109         return __ethtool_set_sg(dev, edata.data);
1110 }
1111
1112 static int ethtool_set_tso(struct net_device *dev, char __user *useraddr)
1113 {
1114         struct ethtool_value edata;
1115
1116         if (!dev->ethtool_ops->set_tso)
1117                 return -EOPNOTSUPP;
1118
1119         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1120                 return -EFAULT;
1121
1122         if (edata.data && !(dev->features & NETIF_F_SG))
1123                 return -EINVAL;
1124
1125         return dev->ethtool_ops->set_tso(dev, edata.data);
1126 }
1127
1128 static int ethtool_set_ufo(struct net_device *dev, char __user *useraddr)
1129 {
1130         struct ethtool_value edata;
1131
1132         if (!dev->ethtool_ops->set_ufo)
1133                 return -EOPNOTSUPP;
1134         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1135                 return -EFAULT;
1136         if (edata.data && !(dev->features & NETIF_F_SG))
1137                 return -EINVAL;
1138         if (edata.data && !(dev->features & NETIF_F_HW_CSUM))
1139                 return -EINVAL;
1140         return dev->ethtool_ops->set_ufo(dev, edata.data);
1141 }
1142
1143 static int ethtool_get_gso(struct net_device *dev, char __user *useraddr)
1144 {
1145         struct ethtool_value edata = { ETHTOOL_GGSO };
1146
1147         edata.data = dev->features & NETIF_F_GSO;
1148         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1149                 return -EFAULT;
1150         return 0;
1151 }
1152
1153 static int ethtool_set_gso(struct net_device *dev, char __user *useraddr)
1154 {
1155         struct ethtool_value edata;
1156
1157         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1158                 return -EFAULT;
1159         if (edata.data)
1160                 dev->features |= NETIF_F_GSO;
1161         else
1162                 dev->features &= ~NETIF_F_GSO;
1163         return 0;
1164 }
1165
1166 static int ethtool_get_gro(struct net_device *dev, char __user *useraddr)
1167 {
1168         struct ethtool_value edata = { ETHTOOL_GGRO };
1169
1170         edata.data = dev->features & NETIF_F_GRO;
1171         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1172                 return -EFAULT;
1173         return 0;
1174 }
1175
1176 static int ethtool_set_gro(struct net_device *dev, char __user *useraddr)
1177 {
1178         struct ethtool_value edata;
1179
1180         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1181                 return -EFAULT;
1182
1183         if (edata.data) {
1184                 if (!dev->ethtool_ops->get_rx_csum ||
1185                     !dev->ethtool_ops->get_rx_csum(dev))
1186                         return -EINVAL;
1187                 dev->features |= NETIF_F_GRO;
1188         } else
1189                 dev->features &= ~NETIF_F_GRO;
1190
1191         return 0;
1192 }
1193
1194 static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
1195 {
1196         struct ethtool_test test;
1197         const struct ethtool_ops *ops = dev->ethtool_ops;
1198         u64 *data;
1199         int ret, test_len;
1200
1201         if (!ops->self_test || !ops->get_sset_count)
1202                 return -EOPNOTSUPP;
1203
1204         test_len = ops->get_sset_count(dev, ETH_SS_TEST);
1205         if (test_len < 0)
1206                 return test_len;
1207         WARN_ON(test_len == 0);
1208
1209         if (copy_from_user(&test, useraddr, sizeof(test)))
1210                 return -EFAULT;
1211
1212         test.len = test_len;
1213         data = kmalloc(test_len * sizeof(u64), GFP_USER);
1214         if (!data)
1215                 return -ENOMEM;
1216
1217         ops->self_test(dev, &test, data);
1218
1219         ret = -EFAULT;
1220         if (copy_to_user(useraddr, &test, sizeof(test)))
1221                 goto out;
1222         useraddr += sizeof(test);
1223         if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
1224                 goto out;
1225         ret = 0;
1226
1227  out:
1228         kfree(data);
1229         return ret;
1230 }
1231
1232 static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
1233 {
1234         struct ethtool_gstrings gstrings;
1235         const struct ethtool_ops *ops = dev->ethtool_ops;
1236         u8 *data;
1237         int ret;
1238
1239         if (!ops->get_strings || !ops->get_sset_count)
1240                 return -EOPNOTSUPP;
1241
1242         if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
1243                 return -EFAULT;
1244
1245         ret = ops->get_sset_count(dev, gstrings.string_set);
1246         if (ret < 0)
1247                 return ret;
1248
1249         gstrings.len = ret;
1250
1251         data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
1252         if (!data)
1253                 return -ENOMEM;
1254
1255         ops->get_strings(dev, gstrings.string_set, data);
1256
1257         ret = -EFAULT;
1258         if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1259                 goto out;
1260         useraddr += sizeof(gstrings);
1261         if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1262                 goto out;
1263         ret = 0;
1264
1265  out:
1266         kfree(data);
1267         return ret;
1268 }
1269
1270 static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
1271 {
1272         struct ethtool_value id;
1273
1274         if (!dev->ethtool_ops->phys_id)
1275                 return -EOPNOTSUPP;
1276
1277         if (copy_from_user(&id, useraddr, sizeof(id)))
1278                 return -EFAULT;
1279
1280         return dev->ethtool_ops->phys_id(dev, id.data);
1281 }
1282
1283 static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
1284 {
1285         struct ethtool_stats stats;
1286         const struct ethtool_ops *ops = dev->ethtool_ops;
1287         u64 *data;
1288         int ret, n_stats;
1289
1290         if (!ops->get_ethtool_stats || !ops->get_sset_count)
1291                 return -EOPNOTSUPP;
1292
1293         n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
1294         if (n_stats < 0)
1295                 return n_stats;
1296         WARN_ON(n_stats == 0);
1297
1298         if (copy_from_user(&stats, useraddr, sizeof(stats)))
1299                 return -EFAULT;
1300
1301         stats.n_stats = n_stats;
1302         data = kmalloc(n_stats * sizeof(u64), GFP_USER);
1303         if (!data)
1304                 return -ENOMEM;
1305
1306         ops->get_ethtool_stats(dev, &stats, data);
1307
1308         ret = -EFAULT;
1309         if (copy_to_user(useraddr, &stats, sizeof(stats)))
1310                 goto out;
1311         useraddr += sizeof(stats);
1312         if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
1313                 goto out;
1314         ret = 0;
1315
1316  out:
1317         kfree(data);
1318         return ret;
1319 }
1320
1321 static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
1322 {
1323         struct ethtool_perm_addr epaddr;
1324
1325         if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
1326                 return -EFAULT;
1327
1328         if (epaddr.size < dev->addr_len)
1329                 return -ETOOSMALL;
1330         epaddr.size = dev->addr_len;
1331
1332         if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
1333                 return -EFAULT;
1334         useraddr += sizeof(epaddr);
1335         if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
1336                 return -EFAULT;
1337         return 0;
1338 }
1339
1340 static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
1341                              u32 cmd, u32 (*actor)(struct net_device *))
1342 {
1343         struct ethtool_value edata = { .cmd = cmd };
1344
1345         if (!actor)
1346                 return -EOPNOTSUPP;
1347
1348         edata.data = actor(dev);
1349
1350         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1351                 return -EFAULT;
1352         return 0;
1353 }
1354
1355 static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
1356                              void (*actor)(struct net_device *, u32))
1357 {
1358         struct ethtool_value edata;
1359
1360         if (!actor)
1361                 return -EOPNOTSUPP;
1362
1363         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1364                 return -EFAULT;
1365
1366         actor(dev, edata.data);
1367         return 0;
1368 }
1369
1370 static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
1371                              int (*actor)(struct net_device *, u32))
1372 {
1373         struct ethtool_value edata;
1374
1375         if (!actor)
1376                 return -EOPNOTSUPP;
1377
1378         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1379                 return -EFAULT;
1380
1381         return actor(dev, edata.data);
1382 }
1383
1384 static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
1385                                                    char __user *useraddr)
1386 {
1387         struct ethtool_flash efl;
1388
1389         if (copy_from_user(&efl, useraddr, sizeof(efl)))
1390                 return -EFAULT;
1391
1392         if (!dev->ethtool_ops->flash_device)
1393                 return -EOPNOTSUPP;
1394
1395         return dev->ethtool_ops->flash_device(dev, &efl);
1396 }
1397
1398 /* The main entry point in this file.  Called from net/core/dev.c */
1399
1400 int dev_ethtool(struct net *net, struct ifreq *ifr)
1401 {
1402         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
1403         void __user *useraddr = ifr->ifr_data;
1404         u32 ethcmd;
1405         int rc;
1406         unsigned long old_features;
1407
1408         if (!dev || !netif_device_present(dev))
1409                 return -ENODEV;
1410
1411         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1412                 return -EFAULT;
1413
1414         if (!dev->ethtool_ops) {
1415                 /* ETHTOOL_GDRVINFO does not require any driver support.
1416                  * It is also unprivileged and does not change anything,
1417                  * so we can take a shortcut to it. */
1418                 if (ethcmd == ETHTOOL_GDRVINFO)
1419                         return ethtool_get_drvinfo(dev, useraddr);
1420                 else
1421                         return -EOPNOTSUPP;
1422         }
1423
1424         /* Allow some commands to be done by anyone */
1425         switch (ethcmd) {
1426         case ETHTOOL_GSET:
1427         case ETHTOOL_GDRVINFO:
1428         case ETHTOOL_GMSGLVL:
1429         case ETHTOOL_GCOALESCE:
1430         case ETHTOOL_GRINGPARAM:
1431         case ETHTOOL_GPAUSEPARAM:
1432         case ETHTOOL_GRXCSUM:
1433         case ETHTOOL_GTXCSUM:
1434         case ETHTOOL_GSG:
1435         case ETHTOOL_GSTRINGS:
1436         case ETHTOOL_GTSO:
1437         case ETHTOOL_GPERMADDR:
1438         case ETHTOOL_GUFO:
1439         case ETHTOOL_GGSO:
1440         case ETHTOOL_GGRO:
1441         case ETHTOOL_GFLAGS:
1442         case ETHTOOL_GPFLAGS:
1443         case ETHTOOL_GRXFH:
1444         case ETHTOOL_GRXRINGS:
1445         case ETHTOOL_GRXCLSRLCNT:
1446         case ETHTOOL_GRXCLSRULE:
1447         case ETHTOOL_GRXCLSRLALL:
1448                 break;
1449         default:
1450                 if (!capable(CAP_NET_ADMIN))
1451                         return -EPERM;
1452         }
1453
1454         if (dev->ethtool_ops->begin) {
1455                 rc = dev->ethtool_ops->begin(dev);
1456                 if (rc  < 0)
1457                         return rc;
1458         }
1459         old_features = dev->features;
1460
1461         switch (ethcmd) {
1462         case ETHTOOL_GSET:
1463                 rc = ethtool_get_settings(dev, useraddr);
1464                 break;
1465         case ETHTOOL_SSET:
1466                 rc = ethtool_set_settings(dev, useraddr);
1467                 break;
1468         case ETHTOOL_GDRVINFO:
1469                 rc = ethtool_get_drvinfo(dev, useraddr);
1470                 break;
1471         case ETHTOOL_GREGS:
1472                 rc = ethtool_get_regs(dev, useraddr);
1473                 break;
1474         case ETHTOOL_GWOL:
1475                 rc = ethtool_get_wol(dev, useraddr);
1476                 break;
1477         case ETHTOOL_SWOL:
1478                 rc = ethtool_set_wol(dev, useraddr);
1479                 break;
1480         case ETHTOOL_GMSGLVL:
1481                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1482                                        dev->ethtool_ops->get_msglevel);
1483                 break;
1484         case ETHTOOL_SMSGLVL:
1485                 rc = ethtool_set_value_void(dev, useraddr,
1486                                        dev->ethtool_ops->set_msglevel);
1487                 break;
1488         case ETHTOOL_NWAY_RST:
1489                 rc = ethtool_nway_reset(dev);
1490                 break;
1491         case ETHTOOL_GLINK:
1492                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1493                                        dev->ethtool_ops->get_link);
1494                 break;
1495         case ETHTOOL_GEEPROM:
1496                 rc = ethtool_get_eeprom(dev, useraddr);
1497                 break;
1498         case ETHTOOL_SEEPROM:
1499                 rc = ethtool_set_eeprom(dev, useraddr);
1500                 break;
1501         case ETHTOOL_GCOALESCE:
1502                 rc = ethtool_get_coalesce(dev, useraddr);
1503                 break;
1504         case ETHTOOL_SCOALESCE:
1505                 rc = ethtool_set_coalesce(dev, useraddr);
1506                 break;
1507         case ETHTOOL_GRINGPARAM:
1508                 rc = ethtool_get_ringparam(dev, useraddr);
1509                 break;
1510         case ETHTOOL_SRINGPARAM:
1511                 rc = ethtool_set_ringparam(dev, useraddr);
1512                 break;
1513         case ETHTOOL_GPAUSEPARAM:
1514                 rc = ethtool_get_pauseparam(dev, useraddr);
1515                 break;
1516         case ETHTOOL_SPAUSEPARAM:
1517                 rc = ethtool_set_pauseparam(dev, useraddr);
1518                 break;
1519         case ETHTOOL_GRXCSUM:
1520                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1521                                        (dev->ethtool_ops->get_rx_csum ?
1522                                         dev->ethtool_ops->get_rx_csum :
1523                                         ethtool_op_get_rx_csum));
1524                 break;
1525         case ETHTOOL_SRXCSUM:
1526                 rc = ethtool_set_rx_csum(dev, useraddr);
1527                 break;
1528         case ETHTOOL_GTXCSUM:
1529                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1530                                        (dev->ethtool_ops->get_tx_csum ?
1531                                         dev->ethtool_ops->get_tx_csum :
1532                                         ethtool_op_get_tx_csum));
1533                 break;
1534         case ETHTOOL_STXCSUM:
1535                 rc = ethtool_set_tx_csum(dev, useraddr);
1536                 break;
1537         case ETHTOOL_GSG:
1538                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1539                                        (dev->ethtool_ops->get_sg ?
1540                                         dev->ethtool_ops->get_sg :
1541                                         ethtool_op_get_sg));
1542                 break;
1543         case ETHTOOL_SSG:
1544                 rc = ethtool_set_sg(dev, useraddr);
1545                 break;
1546         case ETHTOOL_GTSO:
1547                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1548                                        (dev->ethtool_ops->get_tso ?
1549                                         dev->ethtool_ops->get_tso :
1550                                         ethtool_op_get_tso));
1551                 break;
1552         case ETHTOOL_STSO:
1553                 rc = ethtool_set_tso(dev, useraddr);
1554                 break;
1555         case ETHTOOL_TEST:
1556                 rc = ethtool_self_test(dev, useraddr);
1557                 break;
1558         case ETHTOOL_GSTRINGS:
1559                 rc = ethtool_get_strings(dev, useraddr);
1560                 break;
1561         case ETHTOOL_PHYS_ID:
1562                 rc = ethtool_phys_id(dev, useraddr);
1563                 break;
1564         case ETHTOOL_GSTATS:
1565                 rc = ethtool_get_stats(dev, useraddr);
1566                 break;
1567         case ETHTOOL_GPERMADDR:
1568                 rc = ethtool_get_perm_addr(dev, useraddr);
1569                 break;
1570         case ETHTOOL_GUFO:
1571                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1572                                        (dev->ethtool_ops->get_ufo ?
1573                                         dev->ethtool_ops->get_ufo :
1574                                         ethtool_op_get_ufo));
1575                 break;
1576         case ETHTOOL_SUFO:
1577                 rc = ethtool_set_ufo(dev, useraddr);
1578                 break;
1579         case ETHTOOL_GGSO:
1580                 rc = ethtool_get_gso(dev, useraddr);
1581                 break;
1582         case ETHTOOL_SGSO:
1583                 rc = ethtool_set_gso(dev, useraddr);
1584                 break;
1585         case ETHTOOL_GFLAGS:
1586                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1587                                        (dev->ethtool_ops->get_flags ?
1588                                         dev->ethtool_ops->get_flags :
1589                                         ethtool_op_get_flags));
1590                 break;
1591         case ETHTOOL_SFLAGS:
1592                 rc = ethtool_set_value(dev, useraddr,
1593                                        dev->ethtool_ops->set_flags);
1594                 break;
1595         case ETHTOOL_GPFLAGS:
1596                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1597                                        dev->ethtool_ops->get_priv_flags);
1598                 break;
1599         case ETHTOOL_SPFLAGS:
1600                 rc = ethtool_set_value(dev, useraddr,
1601                                        dev->ethtool_ops->set_priv_flags);
1602                 break;
1603         case ETHTOOL_GRXFH:
1604         case ETHTOOL_GRXRINGS:
1605         case ETHTOOL_GRXCLSRLCNT:
1606         case ETHTOOL_GRXCLSRULE:
1607         case ETHTOOL_GRXCLSRLALL:
1608                 rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
1609                 break;
1610         case ETHTOOL_SRXFH:
1611         case ETHTOOL_SRXCLSRLDEL:
1612         case ETHTOOL_SRXCLSRLINS:
1613                 rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
1614                 break;
1615         case ETHTOOL_GGRO:
1616                 rc = ethtool_get_gro(dev, useraddr);
1617                 break;
1618         case ETHTOOL_SGRO:
1619                 rc = ethtool_set_gro(dev, useraddr);
1620                 break;
1621         case ETHTOOL_FLASHDEV:
1622                 rc = ethtool_flash_device(dev, useraddr);
1623                 break;
1624         case ETHTOOL_RESET:
1625                 rc = ethtool_reset(dev, useraddr);
1626                 break;
1627         case ETHTOOL_SRXNTUPLE:
1628                 rc = ethtool_set_rx_ntuple(dev, useraddr);
1629                 break;
1630         case ETHTOOL_GRXNTUPLE:
1631                 rc = ethtool_get_rx_ntuple(dev, useraddr);
1632                 break;
1633         case ETHTOOL_GSSET_INFO:
1634                 rc = ethtool_get_sset_info(dev, useraddr);
1635                 break;
1636         case ETHTOOL_GRXFHINDIR:
1637                 rc = ethtool_get_rxfh_indir(dev, useraddr);
1638                 break;
1639         case ETHTOOL_SRXFHINDIR:
1640                 rc = ethtool_set_rxfh_indir(dev, useraddr);
1641                 break;
1642         default:
1643                 rc = -EOPNOTSUPP;
1644         }
1645
1646         if (dev->ethtool_ops->complete)
1647                 dev->ethtool_ops->complete(dev);
1648
1649         if (old_features != dev->features)
1650                 netdev_features_change(dev);
1651
1652         return rc;
1653 }