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