net/core/ethtool.c

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