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