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 /*
 489  * ethtool does not (or did not) set masks for flow parameters that are
 490  * not specified, so if both value and mask are 0 then this must be
 491  * treated as equivalent to a mask with all bits set.  Implement that
 492  * here rather than in drivers.
 493  */
 494 static void rx_ntuple_fix_masks(struct ethtool_rx_ntuple_flow_spec *fs)
 495 {
 496         struct ethtool_tcpip4_spec *entry = &fs->h_u.tcp_ip4_spec;
 497         struct ethtool_tcpip4_spec *mask = &fs->m_u.tcp_ip4_spec;
 498
 499         if (fs->flow_type != TCP_V4_FLOW &&
 500             fs->flow_type != UDP_V4_FLOW &&
 501             fs->flow_type != SCTP_V4_FLOW)
 502                 return;
 503
 504         if (!(entry->ip4src | mask->ip4src))
 505                 mask->ip4src = htonl(0xffffffff);
 506         if (!(entry->ip4dst | mask->ip4dst))
 507                 mask->ip4dst = htonl(0xffffffff);
 508         if (!(entry->psrc | mask->psrc))
 509                 mask->psrc = htons(0xffff);
 510         if (!(entry->pdst | mask->pdst))
 511                 mask->pdst = htons(0xffff);
 512         if (!(entry->tos | mask->tos))
 513                 mask->tos = 0xff;
 514         if (!(fs->vlan_tag | fs->vlan_tag_mask))
 515                 fs->vlan_tag_mask = 0xffff;
 516         if (!(fs->data | fs->data_mask))
 517                 fs->data_mask = 0xffffffffffffffffULL;
 518 }
 519
 520 static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
 521                                                     void __user *useraddr)
 522 {
 523         struct ethtool_rx_ntuple cmd;
 524         const struct ethtool_ops *ops = dev->ethtool_ops;
 525         struct ethtool_rx_ntuple_flow_spec_container *fsc = NULL;
 526         int ret;
 527
 528         if (!(dev->features & NETIF_F_NTUPLE))
 529                 return -EINVAL;
 530
 531         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
 532                 return -EFAULT;
 533
 534         rx_ntuple_fix_masks(&cmd.fs);
 535
 536         /*
 537          * Cache filter in dev struct for GET operation only if
 538          * the underlying driver doesn't have its own GET operation, and
 539          * only if the filter was added successfully.  First make sure we
 540          * can allocate the filter, then continue if successful.
 541          */
 542         if (!ops->get_rx_ntuple) {
 543                 fsc = kmalloc(sizeof(*fsc), GFP_ATOMIC);
 544                 if (!fsc)
 545                         return -ENOMEM;
 546         }
 547
 548         ret = ops->set_rx_ntuple(dev, &cmd);
 549         if (ret) {
 550                 kfree(fsc);
 551                 return ret;
 552         }
 553
 554         if (!ops->get_rx_ntuple)
 555                 __rx_ntuple_filter_add(&dev->ethtool_ntuple_list, &cmd.fs, fsc);
 556
 557         return ret;
 558 }
 559
 560 static int ethtool_get_rx_ntuple(struct net_device *dev, void __user *useraddr)
 561 {
 562         struct ethtool_gstrings gstrings;
 563         const struct ethtool_ops *ops = dev->ethtool_ops;
 564         struct ethtool_rx_ntuple_flow_spec_container *fsc;
 565         u8 *data;
 566         char *p;
 567         int ret, i, num_strings = 0;
 568
 569         if (!ops->get_sset_count)
 570                 return -EOPNOTSUPP;
 571
 572         if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
 573                 return -EFAULT;
 574
 575         ret = ops->get_sset_count(dev, gstrings.string_set);
 576         if (ret < 0)
 577                 return ret;
 578
 579         gstrings.len = ret;
 580
 581         data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
 582         if (!data)
 583                 return -ENOMEM;
 584
 585         if (ops->get_rx_ntuple) {
 586                 /* driver-specific filter grab */
 587                 ret = ops->get_rx_ntuple(dev, gstrings.string_set, data);
 588                 goto copy;
 589         }
 590
 591         /* default ethtool filter grab */
 592         i = 0;
 593         p = (char *)data;
 594         list_for_each_entry(fsc, &dev->ethtool_ntuple_list.list, list) {
 595                 sprintf(p, "Filter %d:\n", i);
 596                 p += ETH_GSTRING_LEN;
 597                 num_strings++;
 598
 599                 switch (fsc->fs.flow_type) {
 600                 case TCP_V4_FLOW:
 601                         sprintf(p, "\tFlow Type: TCP\n");
 602                         p += ETH_GSTRING_LEN;
 603                         num_strings++;
 604                         break;
 605                 case UDP_V4_FLOW:
 606                         sprintf(p, "\tFlow Type: UDP\n");
 607                         p += ETH_GSTRING_LEN;
 608                         num_strings++;
 609                         break;
 610                 case SCTP_V4_FLOW:
 611                         sprintf(p, "\tFlow Type: SCTP\n");
 612                         p += ETH_GSTRING_LEN;
 613                         num_strings++;
 614                         break;
 615                 case AH_ESP_V4_FLOW:
 616                         sprintf(p, "\tFlow Type: AH ESP\n");
 617                         p += ETH_GSTRING_LEN;
 618                         num_strings++;
 619                         break;
 620                 case ESP_V4_FLOW:
 621                         sprintf(p, "\tFlow Type: ESP\n");
 622                         p += ETH_GSTRING_LEN;
 623                         num_strings++;
 624                         break;
 625                 case IP_USER_FLOW:
 626                         sprintf(p, "\tFlow Type: Raw IP\n");
 627                         p += ETH_GSTRING_LEN;
 628                         num_strings++;
 629                         break;
 630                 case IPV4_FLOW:
 631                         sprintf(p, "\tFlow Type: IPv4\n");
 632                         p += ETH_GSTRING_LEN;
 633                         num_strings++;
 634                         break;
 635                 default:
 636                         sprintf(p, "\tFlow Type: Unknown\n");
 637                         p += ETH_GSTRING_LEN;
 638                         num_strings++;
 639                         goto unknown_filter;
 640                 }
 641
 642                 /* now the rest of the filters */
 643                 switch (fsc->fs.flow_type) {
 644                 case TCP_V4_FLOW:
 645                 case UDP_V4_FLOW:
 646                 case SCTP_V4_FLOW:
 647                         sprintf(p, "\tSrc IP addr: 0x%x\n",
 648                                 fsc->fs.h_u.tcp_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.tcp_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.tcp_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.tcp_ip4_spec.ip4dst);
 661                         p += ETH_GSTRING_LEN;
 662                         num_strings++;
 663                         sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",
 664                                 fsc->fs.h_u.tcp_ip4_spec.psrc,
 665                                 fsc->fs.m_u.tcp_ip4_spec.psrc);
 666                         p += ETH_GSTRING_LEN;
 667                         num_strings++;
 668                         sprintf(p, "\tDest Port: %d, mask: 0x%x\n",
 669                                 fsc->fs.h_u.tcp_ip4_spec.pdst,
 670                                 fsc->fs.m_u.tcp_ip4_spec.pdst);
 671                         p += ETH_GSTRING_LEN;
 672                         num_strings++;
 673                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
 674                                 fsc->fs.h_u.tcp_ip4_spec.tos,
 675                                 fsc->fs.m_u.tcp_ip4_spec.tos);
 676                         p += ETH_GSTRING_LEN;
 677                         num_strings++;
 678                         break;
 679                 case AH_ESP_V4_FLOW:
 680                 case ESP_V4_FLOW:
 681                         sprintf(p, "\tSrc IP addr: 0x%x\n",
 682                                 fsc->fs.h_u.ah_ip4_spec.ip4src);
 683                         p += ETH_GSTRING_LEN;
 684                         num_strings++;
 685                         sprintf(p, "\tSrc IP mask: 0x%x\n",
 686                                 fsc->fs.m_u.ah_ip4_spec.ip4src);
 687                         p += ETH_GSTRING_LEN;
 688                         num_strings++;
 689                         sprintf(p, "\tDest IP addr: 0x%x\n",
 690                                 fsc->fs.h_u.ah_ip4_spec.ip4dst);
 691                         p += ETH_GSTRING_LEN;
 692                         num_strings++;
 693                         sprintf(p, "\tDest IP mask: 0x%x\n",
 694                                 fsc->fs.m_u.ah_ip4_spec.ip4dst);
 695                         p += ETH_GSTRING_LEN;
 696                         num_strings++;
 697                         sprintf(p, "\tSPI: %d, mask: 0x%x\n",
 698                                 fsc->fs.h_u.ah_ip4_spec.spi,
 699                                 fsc->fs.m_u.ah_ip4_spec.spi);
 700                         p += ETH_GSTRING_LEN;
 701                         num_strings++;
 702                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
 703                                 fsc->fs.h_u.ah_ip4_spec.tos,
 704                                 fsc->fs.m_u.ah_ip4_spec.tos);
 705                         p += ETH_GSTRING_LEN;
 706                         num_strings++;
 707                         break;
 708                 case IP_USER_FLOW:
 709                         sprintf(p, "\tSrc IP addr: 0x%x\n",
 710                                 fsc->fs.h_u.usr_ip4_spec.ip4src);
 711                         p += ETH_GSTRING_LEN;
 712                         num_strings++;
 713                         sprintf(p, "\tSrc IP mask: 0x%x\n",
 714                                 fsc->fs.m_u.usr_ip4_spec.ip4src);
 715                         p += ETH_GSTRING_LEN;
 716                         num_strings++;
 717                         sprintf(p, "\tDest IP addr: 0x%x\n",
 718                                 fsc->fs.h_u.usr_ip4_spec.ip4dst);
 719                         p += ETH_GSTRING_LEN;
 720                         num_strings++;
 721                         sprintf(p, "\tDest IP mask: 0x%x\n",
 722                                 fsc->fs.m_u.usr_ip4_spec.ip4dst);
 723                         p += ETH_GSTRING_LEN;
 724                         num_strings++;
 725                         break;
 726                 case IPV4_FLOW:
 727                         sprintf(p, "\tSrc IP addr: 0x%x\n",
 728                                 fsc->fs.h_u.usr_ip4_spec.ip4src);
 729                         p += ETH_GSTRING_LEN;
 730                         num_strings++;
 731                         sprintf(p, "\tSrc IP mask: 0x%x\n",
 732                                 fsc->fs.m_u.usr_ip4_spec.ip4src);
 733                         p += ETH_GSTRING_LEN;
 734                         num_strings++;
 735                         sprintf(p, "\tDest IP addr: 0x%x\n",
 736                                 fsc->fs.h_u.usr_ip4_spec.ip4dst);
 737                         p += ETH_GSTRING_LEN;
 738                         num_strings++;
 739                         sprintf(p, "\tDest IP mask: 0x%x\n",
 740                                 fsc->fs.m_u.usr_ip4_spec.ip4dst);
 741                         p += ETH_GSTRING_LEN;
 742                         num_strings++;
 743                         sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",
 744                                 fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
 745                                 fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
 746                         p += ETH_GSTRING_LEN;
 747                         num_strings++;
 748                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
 749                                 fsc->fs.h_u.usr_ip4_spec.tos,
 750                                 fsc->fs.m_u.usr_ip4_spec.tos);
 751                         p += ETH_GSTRING_LEN;
 752                         num_strings++;
 753                         sprintf(p, "\tIP Version: %d, mask: 0x%x\n",
 754                                 fsc->fs.h_u.usr_ip4_spec.ip_ver,
 755                                 fsc->fs.m_u.usr_ip4_spec.ip_ver);
 756                         p += ETH_GSTRING_LEN;
 757                         num_strings++;
 758                         sprintf(p, "\tProtocol: %d, mask: 0x%x\n",
 759                                 fsc->fs.h_u.usr_ip4_spec.proto,
 760                                 fsc->fs.m_u.usr_ip4_spec.proto);
 761                         p += ETH_GSTRING_LEN;
 762                         num_strings++;
 763                         break;
 764                 }
 765                 sprintf(p, "\tVLAN: %d, mask: 0x%x\n",
 766                         fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
 767                 p += ETH_GSTRING_LEN;
 768                 num_strings++;
 769                 sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);
 770                 p += ETH_GSTRING_LEN;
 771                 num_strings++;
 772                 sprintf(p, "\tUser-defined mask: 0x%Lx\n", fsc->fs.data_mask);
 773                 p += ETH_GSTRING_LEN;
 774                 num_strings++;
 775                 if (fsc->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)
 776                         sprintf(p, "\tAction: Drop\n");
 777                 else
 778                         sprintf(p, "\tAction: Direct to queue %d\n",
 779                                 fsc->fs.action);
 780                 p += ETH_GSTRING_LEN;
 781                 num_strings++;
 782 unknown_filter:
 783                 i++;
 784         }
 785 copy:
 786         /* indicate to userspace how many strings we actually have */
 787         gstrings.len = num_strings;
 788         ret = -EFAULT;
 789         if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
 790                 goto out;
 791         useraddr += sizeof(gstrings);
 792         if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
 793                 goto out;
 794         ret = 0;
 795
 796 out:
 797         kfree(data);
 798         return ret;
 799 }
 800
 801 static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
 802 {
 803         struct ethtool_regs regs;
 804         const struct ethtool_ops *ops = dev->ethtool_ops;
 805         void *regbuf;
 806         int reglen, ret;
 807
 808         if (!ops->get_regs || !ops->get_regs_len)
 809                 return -EOPNOTSUPP;
 810
 811         if (copy_from_user(&regs, useraddr, sizeof(regs)))
 812                 return -EFAULT;
 813
 814         reglen = ops->get_regs_len(dev);
 815         if (regs.len > reglen)
 816                 regs.len = reglen;
 817
 818         regbuf = vmalloc(reglen);
 819         if (!regbuf)
 820                 return -ENOMEM;
 821
 822         ops->get_regs(dev, &regs, regbuf);
 823
 824         ret = -EFAULT;
 825         if (copy_to_user(useraddr, &regs, sizeof(regs)))
 826                 goto out;
 827         useraddr += offsetof(struct ethtool_regs, data);
 828         if (copy_to_user(useraddr, regbuf, regs.len))
 829                 goto out;
 830         ret = 0;
 831
 832  out:
 833         vfree(regbuf);
 834         return ret;
 835 }
 836
 837 static int ethtool_reset(struct net_device *dev, char __user *useraddr)
 838 {
 839         struct ethtool_value reset;
 840         int ret;
 841
 842         if (!dev->ethtool_ops->reset)
 843                 return -EOPNOTSUPP;
 844
 845         if (copy_from_user(&reset, useraddr, sizeof(reset)))
 846                 return -EFAULT;
 847
 848         ret = dev->ethtool_ops->reset(dev, &reset.data);
 849         if (ret)
 850                 return ret;
 851
 852         if (copy_to_user(useraddr, &reset, sizeof(reset)))
 853                 return -EFAULT;
 854         return 0;
 855 }
 856
 857 static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
 858 {
 859         struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
 860
 861         if (!dev->ethtool_ops->get_wol)
 862                 return -EOPNOTSUPP;
 863
 864         dev->ethtool_ops->get_wol(dev, &wol);
 865
 866         if (copy_to_user(useraddr, &wol, sizeof(wol)))
 867                 return -EFAULT;
 868         return 0;
 869 }
 870
 871 static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
 872 {
 873         struct ethtool_wolinfo wol;
 874
 875         if (!dev->ethtool_ops->set_wol)
 876                 return -EOPNOTSUPP;
 877
 878         if (copy_from_user(&wol, useraddr, sizeof(wol)))
 879                 return -EFAULT;
 880
 881         return dev->ethtool_ops->set_wol(dev, &wol);
 882 }
 883
 884 static int ethtool_nway_reset(struct net_device *dev)
 885 {
 886         if (!dev->ethtool_ops->nway_reset)
 887                 return -EOPNOTSUPP;
 888
 889         return dev->ethtool_ops->nway_reset(dev);
 890 }
 891
 892 static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
 893 {
 894         struct ethtool_eeprom eeprom;
 895         const struct ethtool_ops *ops = dev->ethtool_ops;
 896         void __user *userbuf = useraddr + sizeof(eeprom);
 897         u32 bytes_remaining;
 898         u8 *data;
 899         int ret = 0;
 900
 901         if (!ops->get_eeprom || !ops->get_eeprom_len)
 902                 return -EOPNOTSUPP;
 903
 904         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
 905                 return -EFAULT;
 906
 907         /* Check for wrap and zero */
 908         if (eeprom.offset + eeprom.len <= eeprom.offset)
 909                 return -EINVAL;
 910
 911         /* Check for exceeding total eeprom len */
 912         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
 913                 return -EINVAL;
 914
 915         data = kmalloc(PAGE_SIZE, GFP_USER);
 916         if (!data)
 917                 return -ENOMEM;
 918
 919         bytes_remaining = eeprom.len;
 920         while (bytes_remaining > 0) {
 921                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
 922
 923                 ret = ops->get_eeprom(dev, &eeprom, data);
 924                 if (ret)
 925                         break;
 926                 if (copy_to_user(userbuf, data, eeprom.len)) {
 927                         ret = -EFAULT;
 928                         break;
 929                 }
 930                 userbuf += eeprom.len;
 931                 eeprom.offset += eeprom.len;
 932                 bytes_remaining -= eeprom.len;
 933         }
 934
 935         eeprom.len = userbuf - (useraddr + sizeof(eeprom));
 936         eeprom.offset -= eeprom.len;
 937         if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
 938                 ret = -EFAULT;
 939
 940         kfree(data);
 941         return ret;
 942 }
 943
 944 static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
 945 {
 946         struct ethtool_eeprom eeprom;
 947         const struct ethtool_ops *ops = dev->ethtool_ops;
 948         void __user *userbuf = useraddr + sizeof(eeprom);
 949         u32 bytes_remaining;
 950         u8 *data;
 951         int ret = 0;
 952
 953         if (!ops->set_eeprom || !ops->get_eeprom_len)
 954                 return -EOPNOTSUPP;
 955
 956         if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
 957                 return -EFAULT;
 958
 959         /* Check for wrap and zero */
 960         if (eeprom.offset + eeprom.len <= eeprom.offset)
 961                 return -EINVAL;
 962
 963         /* Check for exceeding total eeprom len */
 964         if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
 965                 return -EINVAL;
 966
 967         data = kmalloc(PAGE_SIZE, GFP_USER);
 968         if (!data)
 969                 return -ENOMEM;
 970
 971         bytes_remaining = eeprom.len;
 972         while (bytes_remaining > 0) {
 973                 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
 974
 975                 if (copy_from_user(data, userbuf, eeprom.len)) {
 976                         ret = -EFAULT;
 977                         break;
 978                 }
 979                 ret = ops->set_eeprom(dev, &eeprom, data);
 980                 if (ret)
 981                         break;
 982                 userbuf += eeprom.len;
 983                 eeprom.offset += eeprom.len;
 984                 bytes_remaining -= eeprom.len;
 985         }
 986
 987         kfree(data);
 988         return ret;
 989 }
 990
 991 static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
 992                                                    void __user *useraddr)
 993 {
 994         struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
 995
 996         if (!dev->ethtool_ops->get_coalesce)
 997                 return -EOPNOTSUPP;
 998
 999         dev->ethtool_ops->get_coalesce(dev, &coalesce);
1000
1001         if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
1002                 return -EFAULT;
1003         return 0;
1004 }
1005
1006 static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
1007                                                    void __user *useraddr)
1008 {
1009         struct ethtool_coalesce coalesce;
1010
1011         if (!dev->ethtool_ops->set_coalesce)
1012                 return -EOPNOTSUPP;
1013
1014         if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
1015                 return -EFAULT;
1016
1017         return dev->ethtool_ops->set_coalesce(dev, &coalesce);
1018 }
1019
1020 static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
1021 {
1022         struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
1023
1024         if (!dev->ethtool_ops->get_ringparam)
1025                 return -EOPNOTSUPP;
1026
1027         dev->ethtool_ops->get_ringparam(dev, &ringparam);
1028
1029         if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
1030                 return -EFAULT;
1031         return 0;
1032 }
1033
1034 static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
1035 {
1036         struct ethtool_ringparam ringparam;
1037
1038         if (!dev->ethtool_ops->set_ringparam)
1039                 return -EOPNOTSUPP;
1040
1041         if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
1042                 return -EFAULT;
1043
1044         return dev->ethtool_ops->set_ringparam(dev, &ringparam);
1045 }
1046
1047 static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
1048 {
1049         struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
1050
1051         if (!dev->ethtool_ops->get_pauseparam)
1052                 return -EOPNOTSUPP;
1053
1054         dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
1055
1056         if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
1057                 return -EFAULT;
1058         return 0;
1059 }
1060
1061 static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
1062 {
1063         struct ethtool_pauseparam pauseparam;
1064
1065         if (!dev->ethtool_ops->set_pauseparam)
1066                 return -EOPNOTSUPP;
1067
1068         if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
1069                 return -EFAULT;
1070
1071         return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
1072 }
1073
1074 static int __ethtool_set_sg(struct net_device *dev, u32 data)
1075 {
1076         int err;
1077
1078         if (!data && dev->ethtool_ops->set_tso) {
1079                 err = dev->ethtool_ops->set_tso(dev, 0);
1080                 if (err)
1081                         return err;
1082         }
1083
1084         if (!data && dev->ethtool_ops->set_ufo) {
1085                 err = dev->ethtool_ops->set_ufo(dev, 0);
1086                 if (err)
1087                         return err;
1088         }
1089         return dev->ethtool_ops->set_sg(dev, data);
1090 }
1091
1092 static int ethtool_set_tx_csum(struct net_device *dev, char __user *useraddr)
1093 {
1094         struct ethtool_value edata;
1095         int err;
1096
1097         if (!dev->ethtool_ops->set_tx_csum)
1098                 return -EOPNOTSUPP;
1099
1100         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1101                 return -EFAULT;
1102
1103         if (!edata.data && dev->ethtool_ops->set_sg) {
1104                 err = __ethtool_set_sg(dev, 0);
1105                 if (err)
1106                         return err;
1107         }
1108
1109         return dev->ethtool_ops->set_tx_csum(dev, edata.data);
1110 }
1111 EXPORT_SYMBOL(ethtool_op_set_tx_csum);
1112
1113 static int ethtool_set_rx_csum(struct net_device *dev, char __user *useraddr)
1114 {
1115         struct ethtool_value edata;
1116
1117         if (!dev->ethtool_ops->set_rx_csum)
1118                 return -EOPNOTSUPP;
1119
1120         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1121                 return -EFAULT;
1122
1123         if (!edata.data && dev->ethtool_ops->set_sg)
1124                 dev->features &= ~NETIF_F_GRO;
1125
1126         return dev->ethtool_ops->set_rx_csum(dev, edata.data);
1127 }
1128
1129 static int ethtool_set_sg(struct net_device *dev, char __user *useraddr)
1130 {
1131         struct ethtool_value edata;
1132
1133         if (!dev->ethtool_ops->set_sg)
1134                 return -EOPNOTSUPP;
1135
1136         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1137                 return -EFAULT;
1138
1139         if (edata.data &&
1140             !(dev->features & NETIF_F_ALL_CSUM))
1141                 return -EINVAL;
1142
1143         return __ethtool_set_sg(dev, edata.data);
1144 }
1145
1146 static int ethtool_set_tso(struct net_device *dev, char __user *useraddr)
1147 {
1148         struct ethtool_value edata;
1149
1150         if (!dev->ethtool_ops->set_tso)
1151                 return -EOPNOTSUPP;
1152
1153         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1154                 return -EFAULT;
1155
1156         if (edata.data && !(dev->features & NETIF_F_SG))
1157                 return -EINVAL;
1158
1159         return dev->ethtool_ops->set_tso(dev, edata.data);
1160 }
1161
1162 static int ethtool_set_ufo(struct net_device *dev, char __user *useraddr)
1163 {
1164         struct ethtool_value edata;
1165
1166         if (!dev->ethtool_ops->set_ufo)
1167                 return -EOPNOTSUPP;
1168         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1169                 return -EFAULT;
1170         if (edata.data && !(dev->features & NETIF_F_SG))
1171                 return -EINVAL;
1172         if (edata.data && !(dev->features & NETIF_F_HW_CSUM))
1173                 return -EINVAL;
1174         return dev->ethtool_ops->set_ufo(dev, edata.data);
1175 }
1176
1177 static int ethtool_get_gso(struct net_device *dev, char __user *useraddr)
1178 {
1179         struct ethtool_value edata = { ETHTOOL_GGSO };
1180
1181         edata.data = dev->features & NETIF_F_GSO;
1182         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1183                 return -EFAULT;
1184         return 0;
1185 }
1186
1187 static int ethtool_set_gso(struct net_device *dev, char __user *useraddr)
1188 {
1189         struct ethtool_value edata;
1190
1191         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1192                 return -EFAULT;
1193         if (edata.data)
1194                 dev->features |= NETIF_F_GSO;
1195         else
1196                 dev->features &= ~NETIF_F_GSO;
1197         return 0;
1198 }
1199
1200 static int ethtool_get_gro(struct net_device *dev, char __user *useraddr)
1201 {
1202         struct ethtool_value edata = { ETHTOOL_GGRO };
1203
1204         edata.data = dev->features & NETIF_F_GRO;
1205         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1206                 return -EFAULT;
1207         return 0;
1208 }
1209
1210 static int ethtool_set_gro(struct net_device *dev, char __user *useraddr)
1211 {
1212         struct ethtool_value edata;
1213
1214         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1215                 return -EFAULT;
1216
1217         if (edata.data) {
1218                 u32 rxcsum = dev->ethtool_ops->get_rx_csum ?
1219                                 dev->ethtool_ops->get_rx_csum(dev) :
1220                                 ethtool_op_get_rx_csum(dev);
1221
1222                 if (!rxcsum)
1223                         return -EINVAL;
1224                 dev->features |= NETIF_F_GRO;
1225         } else
1226                 dev->features &= ~NETIF_F_GRO;
1227
1228         return 0;
1229 }
1230
1231 static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
1232 {
1233         struct ethtool_test test;
1234         const struct ethtool_ops *ops = dev->ethtool_ops;
1235         u64 *data;
1236         int ret, test_len;
1237
1238         if (!ops->self_test || !ops->get_sset_count)
1239                 return -EOPNOTSUPP;
1240
1241         test_len = ops->get_sset_count(dev, ETH_SS_TEST);
1242         if (test_len < 0)
1243                 return test_len;
1244         WARN_ON(test_len == 0);
1245
1246         if (copy_from_user(&test, useraddr, sizeof(test)))
1247                 return -EFAULT;
1248
1249         test.len = test_len;
1250         data = kmalloc(test_len * sizeof(u64), GFP_USER);
1251         if (!data)
1252                 return -ENOMEM;
1253
1254         ops->self_test(dev, &test, data);
1255
1256         ret = -EFAULT;
1257         if (copy_to_user(useraddr, &test, sizeof(test)))
1258                 goto out;
1259         useraddr += sizeof(test);
1260         if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
1261                 goto out;
1262         ret = 0;
1263
1264  out:
1265         kfree(data);
1266         return ret;
1267 }
1268
1269 static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
1270 {
1271         struct ethtool_gstrings gstrings;
1272         const struct ethtool_ops *ops = dev->ethtool_ops;
1273         u8 *data;
1274         int ret;
1275
1276         if (!ops->get_strings || !ops->get_sset_count)
1277                 return -EOPNOTSUPP;
1278
1279         if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
1280                 return -EFAULT;
1281
1282         ret = ops->get_sset_count(dev, gstrings.string_set);
1283         if (ret < 0)
1284                 return ret;
1285
1286         gstrings.len = ret;
1287
1288         data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
1289         if (!data)
1290                 return -ENOMEM;
1291
1292         ops->get_strings(dev, gstrings.string_set, data);
1293
1294         ret = -EFAULT;
1295         if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1296                 goto out;
1297         useraddr += sizeof(gstrings);
1298         if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1299                 goto out;
1300         ret = 0;
1301
1302  out:
1303         kfree(data);
1304         return ret;
1305 }
1306
1307 static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
1308 {
1309         struct ethtool_value id;
1310
1311         if (!dev->ethtool_ops->phys_id)
1312                 return -EOPNOTSUPP;
1313
1314         if (copy_from_user(&id, useraddr, sizeof(id)))
1315                 return -EFAULT;
1316
1317         return dev->ethtool_ops->phys_id(dev, id.data);
1318 }
1319
1320 static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
1321 {
1322         struct ethtool_stats stats;
1323         const struct ethtool_ops *ops = dev->ethtool_ops;
1324         u64 *data;
1325         int ret, n_stats;
1326
1327         if (!ops->get_ethtool_stats || !ops->get_sset_count)
1328                 return -EOPNOTSUPP;
1329
1330         n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
1331         if (n_stats < 0)
1332                 return n_stats;
1333         WARN_ON(n_stats == 0);
1334
1335         if (copy_from_user(&stats, useraddr, sizeof(stats)))
1336                 return -EFAULT;
1337
1338         stats.n_stats = n_stats;
1339         data = kmalloc(n_stats * sizeof(u64), GFP_USER);
1340         if (!data)
1341                 return -ENOMEM;
1342
1343         ops->get_ethtool_stats(dev, &stats, data);
1344
1345         ret = -EFAULT;
1346         if (copy_to_user(useraddr, &stats, sizeof(stats)))
1347                 goto out;
1348         useraddr += sizeof(stats);
1349         if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
1350                 goto out;
1351         ret = 0;
1352
1353  out:
1354         kfree(data);
1355         return ret;
1356 }
1357
1358 static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
1359 {
1360         struct ethtool_perm_addr epaddr;
1361
1362         if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
1363                 return -EFAULT;
1364
1365         if (epaddr.size < dev->addr_len)
1366                 return -ETOOSMALL;
1367         epaddr.size = dev->addr_len;
1368
1369         if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
1370                 return -EFAULT;
1371         useraddr += sizeof(epaddr);
1372         if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
1373                 return -EFAULT;
1374         return 0;
1375 }
1376
1377 static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
1378                              u32 cmd, u32 (*actor)(struct net_device *))
1379 {
1380         struct ethtool_value edata = { .cmd = cmd };
1381
1382         if (!actor)
1383                 return -EOPNOTSUPP;
1384
1385         edata.data = actor(dev);
1386
1387         if (copy_to_user(useraddr, &edata, sizeof(edata)))
1388                 return -EFAULT;
1389         return 0;
1390 }
1391
1392 static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
1393                              void (*actor)(struct net_device *, u32))
1394 {
1395         struct ethtool_value edata;
1396
1397         if (!actor)
1398                 return -EOPNOTSUPP;
1399
1400         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1401                 return -EFAULT;
1402
1403         actor(dev, edata.data);
1404         return 0;
1405 }
1406
1407 static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
1408                              int (*actor)(struct net_device *, u32))
1409 {
1410         struct ethtool_value edata;
1411
1412         if (!actor)
1413                 return -EOPNOTSUPP;
1414
1415         if (copy_from_user(&edata, useraddr, sizeof(edata)))
1416                 return -EFAULT;
1417
1418         return actor(dev, edata.data);
1419 }
1420
1421 static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
1422                                                    char __user *useraddr)
1423 {
1424         struct ethtool_flash efl;
1425
1426         if (copy_from_user(&efl, useraddr, sizeof(efl)))
1427                 return -EFAULT;
1428
1429         if (!dev->ethtool_ops->flash_device)
1430                 return -EOPNOTSUPP;
1431
1432         return dev->ethtool_ops->flash_device(dev, &efl);
1433 }
1434
1435 /* The main entry point in this file.  Called from net/core/dev.c */
1436
1437 int dev_ethtool(struct net *net, struct ifreq *ifr)
1438 {
1439         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
1440         void __user *useraddr = ifr->ifr_data;
1441         u32 ethcmd;
1442         int rc;
1443         unsigned long old_features;
1444
1445         if (!dev || !netif_device_present(dev))
1446                 return -ENODEV;
1447
1448         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1449                 return -EFAULT;
1450
1451         if (!dev->ethtool_ops) {
1452                 /* ETHTOOL_GDRVINFO does not require any driver support.
1453                  * It is also unprivileged and does not change anything,
1454                  * so we can take a shortcut to it. */
1455                 if (ethcmd == ETHTOOL_GDRVINFO)
1456                         return ethtool_get_drvinfo(dev, useraddr);
1457                 else
1458                         return -EOPNOTSUPP;
1459         }
1460
1461         /* Allow some commands to be done by anyone */
1462         switch (ethcmd) {
1463         case ETHTOOL_GSET:
1464         case ETHTOOL_GDRVINFO:
1465         case ETHTOOL_GMSGLVL:
1466         case ETHTOOL_GCOALESCE:
1467         case ETHTOOL_GRINGPARAM:
1468         case ETHTOOL_GPAUSEPARAM:
1469         case ETHTOOL_GRXCSUM:
1470         case ETHTOOL_GTXCSUM:
1471         case ETHTOOL_GSG:
1472         case ETHTOOL_GSTRINGS:
1473         case ETHTOOL_GTSO:
1474         case ETHTOOL_GPERMADDR:
1475         case ETHTOOL_GUFO:
1476         case ETHTOOL_GGSO:
1477         case ETHTOOL_GGRO:
1478         case ETHTOOL_GFLAGS:
1479         case ETHTOOL_GPFLAGS:
1480         case ETHTOOL_GRXFH:
1481         case ETHTOOL_GRXRINGS:
1482         case ETHTOOL_GRXCLSRLCNT:
1483         case ETHTOOL_GRXCLSRULE:
1484         case ETHTOOL_GRXCLSRLALL:
1485                 break;
1486         default:
1487                 if (!capable(CAP_NET_ADMIN))
1488                         return -EPERM;
1489         }
1490
1491         if (dev->ethtool_ops->begin) {
1492                 rc = dev->ethtool_ops->begin(dev);
1493                 if (rc  < 0)
1494                         return rc;
1495         }
1496         old_features = dev->features;
1497
1498         switch (ethcmd) {
1499         case ETHTOOL_GSET:
1500                 rc = ethtool_get_settings(dev, useraddr);
1501                 break;
1502         case ETHTOOL_SSET:
1503                 rc = ethtool_set_settings(dev, useraddr);
1504                 break;
1505         case ETHTOOL_GDRVINFO:
1506                 rc = ethtool_get_drvinfo(dev, useraddr);
1507                 break;
1508         case ETHTOOL_GREGS:
1509                 rc = ethtool_get_regs(dev, useraddr);
1510                 break;
1511         case ETHTOOL_GWOL:
1512                 rc = ethtool_get_wol(dev, useraddr);
1513                 break;
1514         case ETHTOOL_SWOL:
1515                 rc = ethtool_set_wol(dev, useraddr);
1516                 break;
1517         case ETHTOOL_GMSGLVL:
1518                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1519                                        dev->ethtool_ops->get_msglevel);
1520                 break;
1521         case ETHTOOL_SMSGLVL:
1522                 rc = ethtool_set_value_void(dev, useraddr,
1523                                        dev->ethtool_ops->set_msglevel);
1524                 break;
1525         case ETHTOOL_NWAY_RST:
1526                 rc = ethtool_nway_reset(dev);
1527                 break;
1528         case ETHTOOL_GLINK:
1529                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1530                                        dev->ethtool_ops->get_link);
1531                 break;
1532         case ETHTOOL_GEEPROM:
1533                 rc = ethtool_get_eeprom(dev, useraddr);
1534                 break;
1535         case ETHTOOL_SEEPROM:
1536                 rc = ethtool_set_eeprom(dev, useraddr);
1537                 break;
1538         case ETHTOOL_GCOALESCE:
1539                 rc = ethtool_get_coalesce(dev, useraddr);
1540                 break;
1541         case ETHTOOL_SCOALESCE:
1542                 rc = ethtool_set_coalesce(dev, useraddr);
1543                 break;
1544         case ETHTOOL_GRINGPARAM:
1545                 rc = ethtool_get_ringparam(dev, useraddr);
1546                 break;
1547         case ETHTOOL_SRINGPARAM:
1548                 rc = ethtool_set_ringparam(dev, useraddr);
1549                 break;
1550         case ETHTOOL_GPAUSEPARAM:
1551                 rc = ethtool_get_pauseparam(dev, useraddr);
1552                 break;
1553         case ETHTOOL_SPAUSEPARAM:
1554                 rc = ethtool_set_pauseparam(dev, useraddr);
1555                 break;
1556         case ETHTOOL_GRXCSUM:
1557                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1558                                        (dev->ethtool_ops->get_rx_csum ?
1559                                         dev->ethtool_ops->get_rx_csum :
1560                                         ethtool_op_get_rx_csum));
1561                 break;
1562         case ETHTOOL_SRXCSUM:
1563                 rc = ethtool_set_rx_csum(dev, useraddr);
1564                 break;
1565         case ETHTOOL_GTXCSUM:
1566                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1567                                        (dev->ethtool_ops->get_tx_csum ?
1568                                         dev->ethtool_ops->get_tx_csum :
1569                                         ethtool_op_get_tx_csum));
1570                 break;
1571         case ETHTOOL_STXCSUM:
1572                 rc = ethtool_set_tx_csum(dev, useraddr);
1573                 break;
1574         case ETHTOOL_GSG:
1575                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1576                                        (dev->ethtool_ops->get_sg ?
1577                                         dev->ethtool_ops->get_sg :
1578                                         ethtool_op_get_sg));
1579                 break;
1580         case ETHTOOL_SSG:
1581                 rc = ethtool_set_sg(dev, useraddr);
1582                 break;
1583         case ETHTOOL_GTSO:
1584                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1585                                        (dev->ethtool_ops->get_tso ?
1586                                         dev->ethtool_ops->get_tso :
1587                                         ethtool_op_get_tso));
1588                 break;
1589         case ETHTOOL_STSO:
1590                 rc = ethtool_set_tso(dev, useraddr);
1591                 break;
1592         case ETHTOOL_TEST:
1593                 rc = ethtool_self_test(dev, useraddr);
1594                 break;
1595         case ETHTOOL_GSTRINGS:
1596                 rc = ethtool_get_strings(dev, useraddr);
1597                 break;
1598         case ETHTOOL_PHYS_ID:
1599                 rc = ethtool_phys_id(dev, useraddr);
1600                 break;
1601         case ETHTOOL_GSTATS:
1602                 rc = ethtool_get_stats(dev, useraddr);
1603                 break;
1604         case ETHTOOL_GPERMADDR:
1605                 rc = ethtool_get_perm_addr(dev, useraddr);
1606                 break;
1607         case ETHTOOL_GUFO:
1608                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1609                                        (dev->ethtool_ops->get_ufo ?
1610                                         dev->ethtool_ops->get_ufo :
1611                                         ethtool_op_get_ufo));
1612                 break;
1613         case ETHTOOL_SUFO:
1614                 rc = ethtool_set_ufo(dev, useraddr);
1615                 break;
1616         case ETHTOOL_GGSO:
1617                 rc = ethtool_get_gso(dev, useraddr);
1618                 break;
1619         case ETHTOOL_SGSO:
1620                 rc = ethtool_set_gso(dev, useraddr);
1621                 break;
1622         case ETHTOOL_GFLAGS:
1623                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1624                                        (dev->ethtool_ops->get_flags ?
1625                                         dev->ethtool_ops->get_flags :
1626                                         ethtool_op_get_flags));
1627                 break;
1628         case ETHTOOL_SFLAGS:
1629                 rc = ethtool_set_value(dev, useraddr,
1630                                        dev->ethtool_ops->set_flags);
1631                 break;
1632         case ETHTOOL_GPFLAGS:
1633                 rc = ethtool_get_value(dev, useraddr, ethcmd,
1634                                        dev->ethtool_ops->get_priv_flags);
1635                 break;
1636         case ETHTOOL_SPFLAGS:
1637                 rc = ethtool_set_value(dev, useraddr,
1638                                        dev->ethtool_ops->set_priv_flags);
1639                 break;
1640         case ETHTOOL_GRXFH:
1641         case ETHTOOL_GRXRINGS:
1642         case ETHTOOL_GRXCLSRLCNT:
1643         case ETHTOOL_GRXCLSRULE:
1644         case ETHTOOL_GRXCLSRLALL:
1645                 rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
1646                 break;
1647         case ETHTOOL_SRXFH:
1648         case ETHTOOL_SRXCLSRLDEL:
1649         case ETHTOOL_SRXCLSRLINS:
1650                 rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
1651                 break;
1652         case ETHTOOL_GGRO:
1653                 rc = ethtool_get_gro(dev, useraddr);
1654                 break;
1655         case ETHTOOL_SGRO:
1656                 rc = ethtool_set_gro(dev, useraddr);
1657                 break;
1658         case ETHTOOL_FLASHDEV:
1659                 rc = ethtool_flash_device(dev, useraddr);
1660                 break;
1661         case ETHTOOL_RESET:
1662                 rc = ethtool_reset(dev, useraddr);
1663                 break;
1664         case ETHTOOL_SRXNTUPLE:
1665                 rc = ethtool_set_rx_ntuple(dev, useraddr);
1666                 break;
1667         case ETHTOOL_GRXNTUPLE:
1668                 rc = ethtool_get_rx_ntuple(dev, useraddr);
1669                 break;
1670         case ETHTOOL_GSSET_INFO:
1671                 rc = ethtool_get_sset_info(dev, useraddr);
1672                 break;
1673         case ETHTOOL_GRXFHINDIR:
1674                 rc = ethtool_get_rxfh_indir(dev, useraddr);
1675                 break;
1676         case ETHTOOL_SRXFHINDIR:
1677                 rc = ethtool_set_rxfh_indir(dev, useraddr);
1678                 break;
1679         default:
1680                 rc = -EOPNOTSUPP;
1681         }
1682
1683         if (dev->ethtool_ops->complete)
1684                 dev->ethtool_ops->complete(dev);
1685
1686         if (old_features != dev->features)
1687                 netdev_features_change(dev);
1688
1689         return rc;
1690 }