2 * net/core/ethtool.c - Ethtool ioctl handler
3 * Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>
5 * This file is where we call all the ethtool_ops commands to get
6 * the information ethtool needs.
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.
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/capability.h>
17 #include <linux/errno.h>
18 #include <linux/ethtool.h>
19 #include <linux/netdevice.h>
20 #include <linux/bitops.h>
21 #include <linux/uaccess.h>
22 #include <linux/vmalloc.h>
23 #include <linux/slab.h>
24 #include <linux/rtnetlink.h>
25 #include <linux/sched.h>
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.
33 u32
ethtool_op_get_link(struct net_device
*dev
)
35 return netif_carrier_ok(dev
) ? 1 : 0;
37 EXPORT_SYMBOL(ethtool_op_get_link
);
39 u32
ethtool_op_get_tx_csum(struct net_device
*dev
)
41 return (dev
->features
& NETIF_F_ALL_CSUM
) != 0;
43 EXPORT_SYMBOL(ethtool_op_get_tx_csum
);
45 int ethtool_op_set_tx_csum(struct net_device
*dev
, u32 data
)
48 dev
->features
|= NETIF_F_IP_CSUM
;
50 dev
->features
&= ~NETIF_F_IP_CSUM
;
54 EXPORT_SYMBOL(ethtool_op_set_tx_csum
);
56 int ethtool_op_set_tx_hw_csum(struct net_device
*dev
, u32 data
)
59 dev
->features
|= NETIF_F_HW_CSUM
;
61 dev
->features
&= ~NETIF_F_HW_CSUM
;
65 EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum
);
67 int ethtool_op_set_tx_ipv6_csum(struct net_device
*dev
, u32 data
)
70 dev
->features
|= NETIF_F_IP_CSUM
| NETIF_F_IPV6_CSUM
;
72 dev
->features
&= ~(NETIF_F_IP_CSUM
| NETIF_F_IPV6_CSUM
);
76 EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum
);
78 u32
ethtool_op_get_sg(struct net_device
*dev
)
80 return (dev
->features
& NETIF_F_SG
) != 0;
82 EXPORT_SYMBOL(ethtool_op_get_sg
);
84 int ethtool_op_set_sg(struct net_device
*dev
, u32 data
)
87 dev
->features
|= NETIF_F_SG
;
89 dev
->features
&= ~NETIF_F_SG
;
93 EXPORT_SYMBOL(ethtool_op_set_sg
);
95 u32
ethtool_op_get_tso(struct net_device
*dev
)
97 return (dev
->features
& NETIF_F_TSO
) != 0;
99 EXPORT_SYMBOL(ethtool_op_get_tso
);
101 int ethtool_op_set_tso(struct net_device
*dev
, u32 data
)
104 dev
->features
|= NETIF_F_TSO
;
106 dev
->features
&= ~NETIF_F_TSO
;
110 EXPORT_SYMBOL(ethtool_op_set_tso
);
112 u32
ethtool_op_get_ufo(struct net_device
*dev
)
114 return (dev
->features
& NETIF_F_UFO
) != 0;
116 EXPORT_SYMBOL(ethtool_op_get_ufo
);
118 int ethtool_op_set_ufo(struct net_device
*dev
, u32 data
)
121 dev
->features
|= NETIF_F_UFO
;
123 dev
->features
&= ~NETIF_F_UFO
;
126 EXPORT_SYMBOL(ethtool_op_set_ufo
);
128 /* the following list of flags are the same as their associated
129 * NETIF_F_xxx values in include/linux/netdevice.h
131 static const u32 flags_dup_features
=
132 (ETH_FLAG_LRO
| ETH_FLAG_RXVLAN
| ETH_FLAG_TXVLAN
| ETH_FLAG_NTUPLE
|
135 u32
ethtool_op_get_flags(struct net_device
*dev
)
137 /* in the future, this function will probably contain additional
138 * handling for flags which are not so easily handled
139 * by a simple masking operation
142 return dev
->features
& flags_dup_features
;
144 EXPORT_SYMBOL(ethtool_op_get_flags
);
146 /* Check if device can enable (or disable) particular feature coded in "data"
147 * argument. Flags "supported" describe features that can be toggled by device.
148 * If feature can not be toggled, it state (enabled or disabled) must match
149 * hardcoded device features state, otherwise flags are marked as invalid.
151 bool ethtool_invalid_flags(struct net_device
*dev
, u32 data
, u32 supported
)
153 u32 features
= dev
->features
& flags_dup_features
;
154 /* "data" can contain only flags_dup_features bits,
155 * see __ethtool_set_flags */
157 return (features
& ~supported
) != (data
& ~supported
);
159 EXPORT_SYMBOL(ethtool_invalid_flags
);
161 int ethtool_op_set_flags(struct net_device
*dev
, u32 data
, u32 supported
)
163 if (ethtool_invalid_flags(dev
, data
, supported
))
166 dev
->features
= ((dev
->features
& ~flags_dup_features
) |
167 (data
& flags_dup_features
));
170 EXPORT_SYMBOL(ethtool_op_set_flags
);
172 /* Handlers for each ethtool command */
174 #define ETHTOOL_DEV_FEATURE_WORDS 1
176 static void ethtool_get_features_compat(struct net_device
*dev
,
177 struct ethtool_get_features_block
*features
)
179 if (!dev
->ethtool_ops
)
182 /* getting RX checksum */
183 if (dev
->ethtool_ops
->get_rx_csum
)
184 if (dev
->ethtool_ops
->get_rx_csum(dev
))
185 features
[0].active
|= NETIF_F_RXCSUM
;
187 /* mark legacy-changeable features */
188 if (dev
->ethtool_ops
->set_sg
)
189 features
[0].available
|= NETIF_F_SG
;
190 if (dev
->ethtool_ops
->set_tx_csum
)
191 features
[0].available
|= NETIF_F_ALL_CSUM
;
192 if (dev
->ethtool_ops
->set_tso
)
193 features
[0].available
|= NETIF_F_ALL_TSO
;
194 if (dev
->ethtool_ops
->set_rx_csum
)
195 features
[0].available
|= NETIF_F_RXCSUM
;
196 if (dev
->ethtool_ops
->set_flags
)
197 features
[0].available
|= flags_dup_features
;
200 static int ethtool_set_feature_compat(struct net_device
*dev
,
201 int (*legacy_set
)(struct net_device
*, u32
),
202 struct ethtool_set_features_block
*features
, u32 mask
)
209 if (!(features
[0].valid
& mask
))
212 features
[0].valid
&= ~mask
;
214 do_set
= !!(features
[0].requested
& mask
);
216 if (legacy_set(dev
, do_set
) < 0)
218 "Legacy feature change (%s) failed for 0x%08x\n",
219 do_set
? "set" : "clear", mask
);
224 static int ethtool_set_flags_compat(struct net_device
*dev
,
225 int (*legacy_set
)(struct net_device
*, u32
),
226 struct ethtool_set_features_block
*features
, u32 mask
)
233 if (!(features
[0].valid
& mask
))
236 value
= dev
->features
& ~features
[0].valid
;
237 value
|= features
[0].requested
;
239 features
[0].valid
&= ~mask
;
241 if (legacy_set(dev
, value
& mask
) < 0)
242 netdev_info(dev
, "Legacy flags change failed\n");
247 static int ethtool_set_features_compat(struct net_device
*dev
,
248 struct ethtool_set_features_block
*features
)
252 if (!dev
->ethtool_ops
)
255 compat
= ethtool_set_feature_compat(dev
, dev
->ethtool_ops
->set_sg
,
256 features
, NETIF_F_SG
);
257 compat
|= ethtool_set_feature_compat(dev
, dev
->ethtool_ops
->set_tx_csum
,
258 features
, NETIF_F_ALL_CSUM
);
259 compat
|= ethtool_set_feature_compat(dev
, dev
->ethtool_ops
->set_tso
,
260 features
, NETIF_F_ALL_TSO
);
261 compat
|= ethtool_set_feature_compat(dev
, dev
->ethtool_ops
->set_rx_csum
,
262 features
, NETIF_F_RXCSUM
);
263 compat
|= ethtool_set_flags_compat(dev
, dev
->ethtool_ops
->set_flags
,
264 features
, flags_dup_features
);
269 static int ethtool_get_features(struct net_device
*dev
, void __user
*useraddr
)
271 struct ethtool_gfeatures cmd
= {
272 .cmd
= ETHTOOL_GFEATURES
,
273 .size
= ETHTOOL_DEV_FEATURE_WORDS
,
275 struct ethtool_get_features_block features
[ETHTOOL_DEV_FEATURE_WORDS
] = {
277 .available
= dev
->hw_features
,
278 .requested
= dev
->wanted_features
,
279 .active
= dev
->features
,
280 .never_changed
= NETIF_F_NEVER_CHANGE
,
283 u32 __user
*sizeaddr
;
286 ethtool_get_features_compat(dev
, features
);
288 sizeaddr
= useraddr
+ offsetof(struct ethtool_gfeatures
, size
);
289 if (get_user(copy_size
, sizeaddr
))
292 if (copy_size
> ETHTOOL_DEV_FEATURE_WORDS
)
293 copy_size
= ETHTOOL_DEV_FEATURE_WORDS
;
295 if (copy_to_user(useraddr
, &cmd
, sizeof(cmd
)))
297 useraddr
+= sizeof(cmd
);
298 if (copy_to_user(useraddr
, features
, copy_size
* sizeof(*features
)))
304 static int ethtool_set_features(struct net_device
*dev
, void __user
*useraddr
)
306 struct ethtool_sfeatures cmd
;
307 struct ethtool_set_features_block features
[ETHTOOL_DEV_FEATURE_WORDS
];
310 if (copy_from_user(&cmd
, useraddr
, sizeof(cmd
)))
312 useraddr
+= sizeof(cmd
);
314 if (cmd
.size
!= ETHTOOL_DEV_FEATURE_WORDS
)
317 if (copy_from_user(features
, useraddr
, sizeof(features
)))
320 if (features
[0].valid
& ~NETIF_F_ETHTOOL_BITS
)
323 if (ethtool_set_features_compat(dev
, features
))
324 ret
|= ETHTOOL_F_COMPAT
;
326 if (features
[0].valid
& ~dev
->hw_features
) {
327 features
[0].valid
&= dev
->hw_features
;
328 ret
|= ETHTOOL_F_UNSUPPORTED
;
331 dev
->wanted_features
&= ~features
[0].valid
;
332 dev
->wanted_features
|= features
[0].valid
& features
[0].requested
;
333 __netdev_update_features(dev
);
335 if ((dev
->wanted_features
^ dev
->features
) & features
[0].valid
)
336 ret
|= ETHTOOL_F_WISH
;
341 static const char netdev_features_strings
[ETHTOOL_DEV_FEATURE_WORDS
* 32][ETH_GSTRING_LEN
] = {
342 /* NETIF_F_SG */ "tx-scatter-gather",
343 /* NETIF_F_IP_CSUM */ "tx-checksum-ipv4",
344 /* NETIF_F_NO_CSUM */ "tx-checksum-unneeded",
345 /* NETIF_F_HW_CSUM */ "tx-checksum-ip-generic",
346 /* NETIF_F_IPV6_CSUM */ "tx-checksum-ipv6",
347 /* NETIF_F_HIGHDMA */ "highdma",
348 /* NETIF_F_FRAGLIST */ "tx-scatter-gather-fraglist",
349 /* NETIF_F_HW_VLAN_TX */ "tx-vlan-hw-insert",
351 /* NETIF_F_HW_VLAN_RX */ "rx-vlan-hw-parse",
352 /* NETIF_F_HW_VLAN_FILTER */ "rx-vlan-filter",
353 /* NETIF_F_VLAN_CHALLENGED */ "vlan-challenged",
354 /* NETIF_F_GSO */ "tx-generic-segmentation",
355 /* NETIF_F_LLTX */ "tx-lockless",
356 /* NETIF_F_NETNS_LOCAL */ "netns-local",
357 /* NETIF_F_GRO */ "rx-gro",
358 /* NETIF_F_LRO */ "rx-lro",
360 /* NETIF_F_TSO */ "tx-tcp-segmentation",
361 /* NETIF_F_UFO */ "tx-udp-fragmentation",
362 /* NETIF_F_GSO_ROBUST */ "tx-gso-robust",
363 /* NETIF_F_TSO_ECN */ "tx-tcp-ecn-segmentation",
364 /* NETIF_F_TSO6 */ "tx-tcp6-segmentation",
365 /* NETIF_F_FSO */ "tx-fcoe-segmentation",
369 /* NETIF_F_FCOE_CRC */ "tx-checksum-fcoe-crc",
370 /* NETIF_F_SCTP_CSUM */ "tx-checksum-sctp",
371 /* NETIF_F_FCOE_MTU */ "fcoe-mtu",
372 /* NETIF_F_NTUPLE */ "rx-ntuple-filter",
373 /* NETIF_F_RXHASH */ "rx-hashing",
374 /* NETIF_F_RXCSUM */ "rx-checksum",
375 /* NETIF_F_NOCACHE_COPY */ "tx-nocache-copy",
376 /* NETIF_F_LOOPBACK */ "loopback",
379 static int __ethtool_get_sset_count(struct net_device
*dev
, int sset
)
381 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
383 if (sset
== ETH_SS_FEATURES
)
384 return ARRAY_SIZE(netdev_features_strings
);
386 if (ops
&& ops
->get_sset_count
&& ops
->get_strings
)
387 return ops
->get_sset_count(dev
, sset
);
392 static void __ethtool_get_strings(struct net_device
*dev
,
393 u32 stringset
, u8
*data
)
395 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
397 if (stringset
== ETH_SS_FEATURES
)
398 memcpy(data
, netdev_features_strings
,
399 sizeof(netdev_features_strings
));
401 /* ops->get_strings is valid because checked earlier */
402 ops
->get_strings(dev
, stringset
, data
);
405 static u32
ethtool_get_feature_mask(u32 eth_cmd
)
407 /* feature masks of legacy discrete ethtool ops */
410 case ETHTOOL_GTXCSUM
:
411 case ETHTOOL_STXCSUM
:
412 return NETIF_F_ALL_CSUM
| NETIF_F_SCTP_CSUM
;
413 case ETHTOOL_GRXCSUM
:
414 case ETHTOOL_SRXCSUM
:
415 return NETIF_F_RXCSUM
;
421 return NETIF_F_ALL_TSO
;
436 static void *__ethtool_get_one_feature_actor(struct net_device
*dev
, u32 ethcmd
)
438 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
444 case ETHTOOL_GTXCSUM
:
445 return ops
->get_tx_csum
;
446 case ETHTOOL_GRXCSUM
:
447 return ops
->get_rx_csum
;
459 static u32
__ethtool_get_rx_csum_oldbug(struct net_device
*dev
)
461 return !!(dev
->features
& NETIF_F_ALL_CSUM
);
464 static int ethtool_get_one_feature(struct net_device
*dev
,
465 char __user
*useraddr
, u32 ethcmd
)
467 u32 mask
= ethtool_get_feature_mask(ethcmd
);
468 struct ethtool_value edata
= {
470 .data
= !!(dev
->features
& mask
),
473 /* compatibility with discrete get_ ops */
474 if (!(dev
->hw_features
& mask
)) {
475 u32 (*actor
)(struct net_device
*);
477 actor
= __ethtool_get_one_feature_actor(dev
, ethcmd
);
479 /* bug compatibility with old get_rx_csum */
480 if (ethcmd
== ETHTOOL_GRXCSUM
&& !actor
)
481 actor
= __ethtool_get_rx_csum_oldbug
;
484 edata
.data
= actor(dev
);
487 if (copy_to_user(useraddr
, &edata
, sizeof(edata
)))
492 static int __ethtool_set_tx_csum(struct net_device
*dev
, u32 data
);
493 static int __ethtool_set_rx_csum(struct net_device
*dev
, u32 data
);
494 static int __ethtool_set_sg(struct net_device
*dev
, u32 data
);
495 static int __ethtool_set_tso(struct net_device
*dev
, u32 data
);
496 static int __ethtool_set_ufo(struct net_device
*dev
, u32 data
);
498 static int ethtool_set_one_feature(struct net_device
*dev
,
499 void __user
*useraddr
, u32 ethcmd
)
501 struct ethtool_value edata
;
504 if (copy_from_user(&edata
, useraddr
, sizeof(edata
)))
507 mask
= ethtool_get_feature_mask(ethcmd
);
508 mask
&= dev
->hw_features
;
511 dev
->wanted_features
|= mask
;
513 dev
->wanted_features
&= ~mask
;
515 __netdev_update_features(dev
);
519 /* Driver is not converted to ndo_fix_features or does not
520 * support changing this offload. In the latter case it won't
521 * have corresponding ethtool_ops field set.
523 * Following part is to be removed after all drivers advertise
524 * their changeable features in netdev->hw_features and stop
525 * using discrete offload setting ops.
529 case ETHTOOL_STXCSUM
:
530 return __ethtool_set_tx_csum(dev
, edata
.data
);
531 case ETHTOOL_SRXCSUM
:
532 return __ethtool_set_rx_csum(dev
, edata
.data
);
534 return __ethtool_set_sg(dev
, edata
.data
);
536 return __ethtool_set_tso(dev
, edata
.data
);
538 return __ethtool_set_ufo(dev
, edata
.data
);
544 int __ethtool_set_flags(struct net_device
*dev
, u32 data
)
548 if (data
& ~flags_dup_features
)
551 /* legacy set_flags() op */
552 if (dev
->ethtool_ops
->set_flags
) {
553 if (unlikely(dev
->hw_features
& flags_dup_features
))
555 "driver BUG: mixed hw_features and set_flags()\n");
556 return dev
->ethtool_ops
->set_flags(dev
, data
);
559 /* allow changing only bits set in hw_features */
560 changed
= (data
^ dev
->features
) & flags_dup_features
;
561 if (changed
& ~dev
->hw_features
)
562 return (changed
& dev
->hw_features
) ? -EINVAL
: -EOPNOTSUPP
;
564 dev
->wanted_features
=
565 (dev
->wanted_features
& ~changed
) | (data
& dev
->hw_features
);
567 __netdev_update_features(dev
);
572 static int ethtool_get_settings(struct net_device
*dev
, void __user
*useraddr
)
574 struct ethtool_cmd cmd
= { .cmd
= ETHTOOL_GSET
};
577 if (!dev
->ethtool_ops
->get_settings
)
580 err
= dev
->ethtool_ops
->get_settings(dev
, &cmd
);
584 if (copy_to_user(useraddr
, &cmd
, sizeof(cmd
)))
589 static int ethtool_set_settings(struct net_device
*dev
, void __user
*useraddr
)
591 struct ethtool_cmd cmd
;
593 if (!dev
->ethtool_ops
->set_settings
)
596 if (copy_from_user(&cmd
, useraddr
, sizeof(cmd
)))
599 return dev
->ethtool_ops
->set_settings(dev
, &cmd
);
602 static noinline_for_stack
int ethtool_get_drvinfo(struct net_device
*dev
,
603 void __user
*useraddr
)
605 struct ethtool_drvinfo info
;
606 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
608 memset(&info
, 0, sizeof(info
));
609 info
.cmd
= ETHTOOL_GDRVINFO
;
610 if (ops
&& ops
->get_drvinfo
) {
611 ops
->get_drvinfo(dev
, &info
);
612 } else if (dev
->dev
.parent
&& dev
->dev
.parent
->driver
) {
613 strlcpy(info
.bus_info
, dev_name(dev
->dev
.parent
),
614 sizeof(info
.bus_info
));
615 strlcpy(info
.driver
, dev
->dev
.parent
->driver
->name
,
616 sizeof(info
.driver
));
622 * this method of obtaining string set info is deprecated;
623 * Use ETHTOOL_GSSET_INFO instead.
625 if (ops
&& ops
->get_sset_count
) {
628 rc
= ops
->get_sset_count(dev
, ETH_SS_TEST
);
630 info
.testinfo_len
= rc
;
631 rc
= ops
->get_sset_count(dev
, ETH_SS_STATS
);
634 rc
= ops
->get_sset_count(dev
, ETH_SS_PRIV_FLAGS
);
636 info
.n_priv_flags
= rc
;
638 if (ops
&& ops
->get_regs_len
)
639 info
.regdump_len
= ops
->get_regs_len(dev
);
640 if (ops
&& ops
->get_eeprom_len
)
641 info
.eedump_len
= ops
->get_eeprom_len(dev
);
643 if (copy_to_user(useraddr
, &info
, sizeof(info
)))
648 static noinline_for_stack
int ethtool_get_sset_info(struct net_device
*dev
,
649 void __user
*useraddr
)
651 struct ethtool_sset_info info
;
653 int i
, idx
= 0, n_bits
= 0, ret
, rc
;
654 u32
*info_buf
= NULL
;
656 if (copy_from_user(&info
, useraddr
, sizeof(info
)))
659 /* store copy of mask, because we zero struct later on */
660 sset_mask
= info
.sset_mask
;
664 /* calculate size of return buffer */
665 n_bits
= hweight64(sset_mask
);
667 memset(&info
, 0, sizeof(info
));
668 info
.cmd
= ETHTOOL_GSSET_INFO
;
670 info_buf
= kzalloc(n_bits
* sizeof(u32
), GFP_USER
);
675 * fill return buffer based on input bitmask and successful
676 * get_sset_count return
678 for (i
= 0; i
< 64; i
++) {
679 if (!(sset_mask
& (1ULL << i
)))
682 rc
= __ethtool_get_sset_count(dev
, i
);
684 info
.sset_mask
|= (1ULL << i
);
685 info_buf
[idx
++] = rc
;
690 if (copy_to_user(useraddr
, &info
, sizeof(info
)))
693 useraddr
+= offsetof(struct ethtool_sset_info
, data
);
694 if (copy_to_user(useraddr
, info_buf
, idx
* sizeof(u32
)))
704 static noinline_for_stack
int ethtool_set_rxnfc(struct net_device
*dev
,
705 u32 cmd
, void __user
*useraddr
)
707 struct ethtool_rxnfc info
;
708 size_t info_size
= sizeof(info
);
710 if (!dev
->ethtool_ops
->set_rxnfc
)
713 /* struct ethtool_rxnfc was originally defined for
714 * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
715 * members. User-space might still be using that
717 if (cmd
== ETHTOOL_SRXFH
)
718 info_size
= (offsetof(struct ethtool_rxnfc
, data
) +
721 if (copy_from_user(&info
, useraddr
, info_size
))
724 return dev
->ethtool_ops
->set_rxnfc(dev
, &info
);
727 static noinline_for_stack
int ethtool_get_rxnfc(struct net_device
*dev
,
728 u32 cmd
, void __user
*useraddr
)
730 struct ethtool_rxnfc info
;
731 size_t info_size
= sizeof(info
);
732 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
734 void *rule_buf
= NULL
;
739 /* struct ethtool_rxnfc was originally defined for
740 * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
741 * members. User-space might still be using that
743 if (cmd
== ETHTOOL_GRXFH
)
744 info_size
= (offsetof(struct ethtool_rxnfc
, data
) +
747 if (copy_from_user(&info
, useraddr
, info_size
))
750 if (info
.cmd
== ETHTOOL_GRXCLSRLALL
) {
751 if (info
.rule_cnt
> 0) {
752 if (info
.rule_cnt
<= KMALLOC_MAX_SIZE
/ sizeof(u32
))
753 rule_buf
= kzalloc(info
.rule_cnt
* sizeof(u32
),
760 ret
= ops
->get_rxnfc(dev
, &info
, rule_buf
);
765 if (copy_to_user(useraddr
, &info
, info_size
))
769 useraddr
+= offsetof(struct ethtool_rxnfc
, rule_locs
);
770 if (copy_to_user(useraddr
, rule_buf
,
771 info
.rule_cnt
* sizeof(u32
)))
782 static noinline_for_stack
int ethtool_get_rxfh_indir(struct net_device
*dev
,
783 void __user
*useraddr
)
785 struct ethtool_rxfh_indir
*indir
;
790 if (!dev
->ethtool_ops
->get_rxfh_indir
)
793 if (copy_from_user(&table_size
,
794 useraddr
+ offsetof(struct ethtool_rxfh_indir
, size
),
799 (KMALLOC_MAX_SIZE
- sizeof(*indir
)) / sizeof(*indir
->ring_index
))
801 full_size
= sizeof(*indir
) + sizeof(*indir
->ring_index
) * table_size
;
802 indir
= kzalloc(full_size
, GFP_USER
);
806 indir
->cmd
= ETHTOOL_GRXFHINDIR
;
807 indir
->size
= table_size
;
808 ret
= dev
->ethtool_ops
->get_rxfh_indir(dev
, indir
);
812 if (copy_to_user(useraddr
, indir
, full_size
))
820 static noinline_for_stack
int ethtool_set_rxfh_indir(struct net_device
*dev
,
821 void __user
*useraddr
)
823 struct ethtool_rxfh_indir
*indir
;
828 if (!dev
->ethtool_ops
->set_rxfh_indir
)
831 if (copy_from_user(&table_size
,
832 useraddr
+ offsetof(struct ethtool_rxfh_indir
, size
),
837 (KMALLOC_MAX_SIZE
- sizeof(*indir
)) / sizeof(*indir
->ring_index
))
839 full_size
= sizeof(*indir
) + sizeof(*indir
->ring_index
) * table_size
;
840 indir
= kmalloc(full_size
, GFP_USER
);
844 if (copy_from_user(indir
, useraddr
, full_size
)) {
849 ret
= dev
->ethtool_ops
->set_rxfh_indir(dev
, indir
);
857 * ethtool does not (or did not) set masks for flow parameters that are
858 * not specified, so if both value and mask are 0 then this must be
859 * treated as equivalent to a mask with all bits set. Implement that
860 * here rather than in drivers.
862 static void rx_ntuple_fix_masks(struct ethtool_rx_ntuple_flow_spec
*fs
)
864 struct ethtool_tcpip4_spec
*entry
= &fs
->h_u
.tcp_ip4_spec
;
865 struct ethtool_tcpip4_spec
*mask
= &fs
->m_u
.tcp_ip4_spec
;
867 if (fs
->flow_type
!= TCP_V4_FLOW
&&
868 fs
->flow_type
!= UDP_V4_FLOW
&&
869 fs
->flow_type
!= SCTP_V4_FLOW
)
872 if (!(entry
->ip4src
| mask
->ip4src
))
873 mask
->ip4src
= htonl(0xffffffff);
874 if (!(entry
->ip4dst
| mask
->ip4dst
))
875 mask
->ip4dst
= htonl(0xffffffff);
876 if (!(entry
->psrc
| mask
->psrc
))
877 mask
->psrc
= htons(0xffff);
878 if (!(entry
->pdst
| mask
->pdst
))
879 mask
->pdst
= htons(0xffff);
880 if (!(entry
->tos
| mask
->tos
))
882 if (!(fs
->vlan_tag
| fs
->vlan_tag_mask
))
883 fs
->vlan_tag_mask
= 0xffff;
884 if (!(fs
->data
| fs
->data_mask
))
885 fs
->data_mask
= 0xffffffffffffffffULL
;
888 static noinline_for_stack
int ethtool_set_rx_ntuple(struct net_device
*dev
,
889 void __user
*useraddr
)
891 struct ethtool_rx_ntuple cmd
;
892 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
894 if (!ops
->set_rx_ntuple
)
897 if (!(dev
->features
& NETIF_F_NTUPLE
))
900 if (copy_from_user(&cmd
, useraddr
, sizeof(cmd
)))
903 rx_ntuple_fix_masks(&cmd
.fs
);
905 return ops
->set_rx_ntuple(dev
, &cmd
);
908 static int ethtool_get_regs(struct net_device
*dev
, char __user
*useraddr
)
910 struct ethtool_regs regs
;
911 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
915 if (!ops
->get_regs
|| !ops
->get_regs_len
)
918 if (copy_from_user(®s
, useraddr
, sizeof(regs
)))
921 reglen
= ops
->get_regs_len(dev
);
922 if (regs
.len
> reglen
)
925 regbuf
= vzalloc(reglen
);
926 if (reglen
&& !regbuf
)
929 ops
->get_regs(dev
, ®s
, regbuf
);
932 if (copy_to_user(useraddr
, ®s
, sizeof(regs
)))
934 useraddr
+= offsetof(struct ethtool_regs
, data
);
935 if (regbuf
&& copy_to_user(useraddr
, regbuf
, regs
.len
))
944 static int ethtool_reset(struct net_device
*dev
, char __user
*useraddr
)
946 struct ethtool_value reset
;
949 if (!dev
->ethtool_ops
->reset
)
952 if (copy_from_user(&reset
, useraddr
, sizeof(reset
)))
955 ret
= dev
->ethtool_ops
->reset(dev
, &reset
.data
);
959 if (copy_to_user(useraddr
, &reset
, sizeof(reset
)))
964 static int ethtool_get_wol(struct net_device
*dev
, char __user
*useraddr
)
966 struct ethtool_wolinfo wol
= { .cmd
= ETHTOOL_GWOL
};
968 if (!dev
->ethtool_ops
->get_wol
)
971 dev
->ethtool_ops
->get_wol(dev
, &wol
);
973 if (copy_to_user(useraddr
, &wol
, sizeof(wol
)))
978 static int ethtool_set_wol(struct net_device
*dev
, char __user
*useraddr
)
980 struct ethtool_wolinfo wol
;
982 if (!dev
->ethtool_ops
->set_wol
)
985 if (copy_from_user(&wol
, useraddr
, sizeof(wol
)))
988 return dev
->ethtool_ops
->set_wol(dev
, &wol
);
991 static int ethtool_nway_reset(struct net_device
*dev
)
993 if (!dev
->ethtool_ops
->nway_reset
)
996 return dev
->ethtool_ops
->nway_reset(dev
);
999 static int ethtool_get_link(struct net_device
*dev
, char __user
*useraddr
)
1001 struct ethtool_value edata
= { .cmd
= ETHTOOL_GLINK
};
1003 if (!dev
->ethtool_ops
->get_link
)
1006 edata
.data
= netif_running(dev
) && dev
->ethtool_ops
->get_link(dev
);
1008 if (copy_to_user(useraddr
, &edata
, sizeof(edata
)))
1013 static int ethtool_get_eeprom(struct net_device
*dev
, void __user
*useraddr
)
1015 struct ethtool_eeprom eeprom
;
1016 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1017 void __user
*userbuf
= useraddr
+ sizeof(eeprom
);
1018 u32 bytes_remaining
;
1022 if (!ops
->get_eeprom
|| !ops
->get_eeprom_len
)
1025 if (copy_from_user(&eeprom
, useraddr
, sizeof(eeprom
)))
1028 /* Check for wrap and zero */
1029 if (eeprom
.offset
+ eeprom
.len
<= eeprom
.offset
)
1032 /* Check for exceeding total eeprom len */
1033 if (eeprom
.offset
+ eeprom
.len
> ops
->get_eeprom_len(dev
))
1036 data
= kmalloc(PAGE_SIZE
, GFP_USER
);
1040 bytes_remaining
= eeprom
.len
;
1041 while (bytes_remaining
> 0) {
1042 eeprom
.len
= min(bytes_remaining
, (u32
)PAGE_SIZE
);
1044 ret
= ops
->get_eeprom(dev
, &eeprom
, data
);
1047 if (copy_to_user(userbuf
, data
, eeprom
.len
)) {
1051 userbuf
+= eeprom
.len
;
1052 eeprom
.offset
+= eeprom
.len
;
1053 bytes_remaining
-= eeprom
.len
;
1056 eeprom
.len
= userbuf
- (useraddr
+ sizeof(eeprom
));
1057 eeprom
.offset
-= eeprom
.len
;
1058 if (copy_to_user(useraddr
, &eeprom
, sizeof(eeprom
)))
1065 static int ethtool_set_eeprom(struct net_device
*dev
, void __user
*useraddr
)
1067 struct ethtool_eeprom eeprom
;
1068 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1069 void __user
*userbuf
= useraddr
+ sizeof(eeprom
);
1070 u32 bytes_remaining
;
1074 if (!ops
->set_eeprom
|| !ops
->get_eeprom_len
)
1077 if (copy_from_user(&eeprom
, useraddr
, sizeof(eeprom
)))
1080 /* Check for wrap and zero */
1081 if (eeprom
.offset
+ eeprom
.len
<= eeprom
.offset
)
1084 /* Check for exceeding total eeprom len */
1085 if (eeprom
.offset
+ eeprom
.len
> ops
->get_eeprom_len(dev
))
1088 data
= kmalloc(PAGE_SIZE
, GFP_USER
);
1092 bytes_remaining
= eeprom
.len
;
1093 while (bytes_remaining
> 0) {
1094 eeprom
.len
= min(bytes_remaining
, (u32
)PAGE_SIZE
);
1096 if (copy_from_user(data
, userbuf
, eeprom
.len
)) {
1100 ret
= ops
->set_eeprom(dev
, &eeprom
, data
);
1103 userbuf
+= eeprom
.len
;
1104 eeprom
.offset
+= eeprom
.len
;
1105 bytes_remaining
-= eeprom
.len
;
1112 static noinline_for_stack
int ethtool_get_coalesce(struct net_device
*dev
,
1113 void __user
*useraddr
)
1115 struct ethtool_coalesce coalesce
= { .cmd
= ETHTOOL_GCOALESCE
};
1117 if (!dev
->ethtool_ops
->get_coalesce
)
1120 dev
->ethtool_ops
->get_coalesce(dev
, &coalesce
);
1122 if (copy_to_user(useraddr
, &coalesce
, sizeof(coalesce
)))
1127 static noinline_for_stack
int ethtool_set_coalesce(struct net_device
*dev
,
1128 void __user
*useraddr
)
1130 struct ethtool_coalesce coalesce
;
1132 if (!dev
->ethtool_ops
->set_coalesce
)
1135 if (copy_from_user(&coalesce
, useraddr
, sizeof(coalesce
)))
1138 return dev
->ethtool_ops
->set_coalesce(dev
, &coalesce
);
1141 static int ethtool_get_ringparam(struct net_device
*dev
, void __user
*useraddr
)
1143 struct ethtool_ringparam ringparam
= { .cmd
= ETHTOOL_GRINGPARAM
};
1145 if (!dev
->ethtool_ops
->get_ringparam
)
1148 dev
->ethtool_ops
->get_ringparam(dev
, &ringparam
);
1150 if (copy_to_user(useraddr
, &ringparam
, sizeof(ringparam
)))
1155 static int ethtool_set_ringparam(struct net_device
*dev
, void __user
*useraddr
)
1157 struct ethtool_ringparam ringparam
;
1159 if (!dev
->ethtool_ops
->set_ringparam
)
1162 if (copy_from_user(&ringparam
, useraddr
, sizeof(ringparam
)))
1165 return dev
->ethtool_ops
->set_ringparam(dev
, &ringparam
);
1168 static noinline_for_stack
int ethtool_get_channels(struct net_device
*dev
,
1169 void __user
*useraddr
)
1171 struct ethtool_channels channels
= { .cmd
= ETHTOOL_GCHANNELS
};
1173 if (!dev
->ethtool_ops
->get_channels
)
1176 dev
->ethtool_ops
->get_channels(dev
, &channels
);
1178 if (copy_to_user(useraddr
, &channels
, sizeof(channels
)))
1183 static noinline_for_stack
int ethtool_set_channels(struct net_device
*dev
,
1184 void __user
*useraddr
)
1186 struct ethtool_channels channels
;
1188 if (!dev
->ethtool_ops
->set_channels
)
1191 if (copy_from_user(&channels
, useraddr
, sizeof(channels
)))
1194 return dev
->ethtool_ops
->set_channels(dev
, &channels
);
1197 static int ethtool_get_pauseparam(struct net_device
*dev
, void __user
*useraddr
)
1199 struct ethtool_pauseparam pauseparam
= { ETHTOOL_GPAUSEPARAM
};
1201 if (!dev
->ethtool_ops
->get_pauseparam
)
1204 dev
->ethtool_ops
->get_pauseparam(dev
, &pauseparam
);
1206 if (copy_to_user(useraddr
, &pauseparam
, sizeof(pauseparam
)))
1211 static int ethtool_set_pauseparam(struct net_device
*dev
, void __user
*useraddr
)
1213 struct ethtool_pauseparam pauseparam
;
1215 if (!dev
->ethtool_ops
->set_pauseparam
)
1218 if (copy_from_user(&pauseparam
, useraddr
, sizeof(pauseparam
)))
1221 return dev
->ethtool_ops
->set_pauseparam(dev
, &pauseparam
);
1224 static int __ethtool_set_sg(struct net_device
*dev
, u32 data
)
1228 if (!dev
->ethtool_ops
->set_sg
)
1231 if (data
&& !(dev
->features
& NETIF_F_ALL_CSUM
))
1234 if (!data
&& dev
->ethtool_ops
->set_tso
) {
1235 err
= dev
->ethtool_ops
->set_tso(dev
, 0);
1240 if (!data
&& dev
->ethtool_ops
->set_ufo
) {
1241 err
= dev
->ethtool_ops
->set_ufo(dev
, 0);
1245 return dev
->ethtool_ops
->set_sg(dev
, data
);
1248 static int __ethtool_set_tx_csum(struct net_device
*dev
, u32 data
)
1252 if (!dev
->ethtool_ops
->set_tx_csum
)
1255 if (!data
&& dev
->ethtool_ops
->set_sg
) {
1256 err
= __ethtool_set_sg(dev
, 0);
1261 return dev
->ethtool_ops
->set_tx_csum(dev
, data
);
1264 static int __ethtool_set_rx_csum(struct net_device
*dev
, u32 data
)
1266 if (!dev
->ethtool_ops
->set_rx_csum
)
1270 dev
->features
&= ~NETIF_F_GRO
;
1272 return dev
->ethtool_ops
->set_rx_csum(dev
, data
);
1275 static int __ethtool_set_tso(struct net_device
*dev
, u32 data
)
1277 if (!dev
->ethtool_ops
->set_tso
)
1280 if (data
&& !(dev
->features
& NETIF_F_SG
))
1283 return dev
->ethtool_ops
->set_tso(dev
, data
);
1286 static int __ethtool_set_ufo(struct net_device
*dev
, u32 data
)
1288 if (!dev
->ethtool_ops
->set_ufo
)
1290 if (data
&& !(dev
->features
& NETIF_F_SG
))
1292 if (data
&& !((dev
->features
& NETIF_F_GEN_CSUM
) ||
1293 (dev
->features
& (NETIF_F_IP_CSUM
|NETIF_F_IPV6_CSUM
))
1294 == (NETIF_F_IP_CSUM
|NETIF_F_IPV6_CSUM
)))
1296 return dev
->ethtool_ops
->set_ufo(dev
, data
);
1299 static int ethtool_self_test(struct net_device
*dev
, char __user
*useraddr
)
1301 struct ethtool_test test
;
1302 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1306 if (!ops
->self_test
|| !ops
->get_sset_count
)
1309 test_len
= ops
->get_sset_count(dev
, ETH_SS_TEST
);
1312 WARN_ON(test_len
== 0);
1314 if (copy_from_user(&test
, useraddr
, sizeof(test
)))
1317 test
.len
= test_len
;
1318 data
= kmalloc(test_len
* sizeof(u64
), GFP_USER
);
1322 ops
->self_test(dev
, &test
, data
);
1325 if (copy_to_user(useraddr
, &test
, sizeof(test
)))
1327 useraddr
+= sizeof(test
);
1328 if (copy_to_user(useraddr
, data
, test
.len
* sizeof(u64
)))
1337 static int ethtool_get_strings(struct net_device
*dev
, void __user
*useraddr
)
1339 struct ethtool_gstrings gstrings
;
1343 if (copy_from_user(&gstrings
, useraddr
, sizeof(gstrings
)))
1346 ret
= __ethtool_get_sset_count(dev
, gstrings
.string_set
);
1352 data
= kmalloc(gstrings
.len
* ETH_GSTRING_LEN
, GFP_USER
);
1356 __ethtool_get_strings(dev
, gstrings
.string_set
, data
);
1359 if (copy_to_user(useraddr
, &gstrings
, sizeof(gstrings
)))
1361 useraddr
+= sizeof(gstrings
);
1362 if (copy_to_user(useraddr
, data
, gstrings
.len
* ETH_GSTRING_LEN
))
1371 static int ethtool_phys_id(struct net_device
*dev
, void __user
*useraddr
)
1373 struct ethtool_value id
;
1377 if (!dev
->ethtool_ops
->set_phys_id
)
1383 if (copy_from_user(&id
, useraddr
, sizeof(id
)))
1386 rc
= dev
->ethtool_ops
->set_phys_id(dev
, ETHTOOL_ID_ACTIVE
);
1390 /* Drop the RTNL lock while waiting, but prevent reentry or
1391 * removal of the device.
1398 /* Driver will handle this itself */
1399 schedule_timeout_interruptible(
1400 id
.data
? (id
.data
* HZ
) : MAX_SCHEDULE_TIMEOUT
);
1402 /* Driver expects to be called at twice the frequency in rc */
1403 int n
= rc
* 2, i
, interval
= HZ
/ n
;
1405 /* Count down seconds */
1407 /* Count down iterations per second */
1411 rc
= dev
->ethtool_ops
->set_phys_id(dev
,
1412 (i
& 1) ? ETHTOOL_ID_OFF
: ETHTOOL_ID_ON
);
1416 schedule_timeout_interruptible(interval
);
1417 } while (!signal_pending(current
) && --i
!= 0);
1418 } while (!signal_pending(current
) &&
1419 (id
.data
== 0 || --id
.data
!= 0));
1426 (void)dev
->ethtool_ops
->set_phys_id(dev
, ETHTOOL_ID_INACTIVE
);
1430 static int ethtool_get_stats(struct net_device
*dev
, void __user
*useraddr
)
1432 struct ethtool_stats stats
;
1433 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1437 if (!ops
->get_ethtool_stats
|| !ops
->get_sset_count
)
1440 n_stats
= ops
->get_sset_count(dev
, ETH_SS_STATS
);
1443 WARN_ON(n_stats
== 0);
1445 if (copy_from_user(&stats
, useraddr
, sizeof(stats
)))
1448 stats
.n_stats
= n_stats
;
1449 data
= kmalloc(n_stats
* sizeof(u64
), GFP_USER
);
1453 ops
->get_ethtool_stats(dev
, &stats
, data
);
1456 if (copy_to_user(useraddr
, &stats
, sizeof(stats
)))
1458 useraddr
+= sizeof(stats
);
1459 if (copy_to_user(useraddr
, data
, stats
.n_stats
* sizeof(u64
)))
1468 static int ethtool_get_perm_addr(struct net_device
*dev
, void __user
*useraddr
)
1470 struct ethtool_perm_addr epaddr
;
1472 if (copy_from_user(&epaddr
, useraddr
, sizeof(epaddr
)))
1475 if (epaddr
.size
< dev
->addr_len
)
1477 epaddr
.size
= dev
->addr_len
;
1479 if (copy_to_user(useraddr
, &epaddr
, sizeof(epaddr
)))
1481 useraddr
+= sizeof(epaddr
);
1482 if (copy_to_user(useraddr
, dev
->perm_addr
, epaddr
.size
))
1487 static int ethtool_get_value(struct net_device
*dev
, char __user
*useraddr
,
1488 u32 cmd
, u32 (*actor
)(struct net_device
*))
1490 struct ethtool_value edata
= { .cmd
= cmd
};
1495 edata
.data
= actor(dev
);
1497 if (copy_to_user(useraddr
, &edata
, sizeof(edata
)))
1502 static int ethtool_set_value_void(struct net_device
*dev
, char __user
*useraddr
,
1503 void (*actor
)(struct net_device
*, u32
))
1505 struct ethtool_value edata
;
1510 if (copy_from_user(&edata
, useraddr
, sizeof(edata
)))
1513 actor(dev
, edata
.data
);
1517 static int ethtool_set_value(struct net_device
*dev
, char __user
*useraddr
,
1518 int (*actor
)(struct net_device
*, u32
))
1520 struct ethtool_value edata
;
1525 if (copy_from_user(&edata
, useraddr
, sizeof(edata
)))
1528 return actor(dev
, edata
.data
);
1531 static noinline_for_stack
int ethtool_flash_device(struct net_device
*dev
,
1532 char __user
*useraddr
)
1534 struct ethtool_flash efl
;
1536 if (copy_from_user(&efl
, useraddr
, sizeof(efl
)))
1539 if (!dev
->ethtool_ops
->flash_device
)
1542 return dev
->ethtool_ops
->flash_device(dev
, &efl
);
1545 static int ethtool_set_dump(struct net_device
*dev
,
1546 void __user
*useraddr
)
1548 struct ethtool_dump dump
;
1550 if (!dev
->ethtool_ops
->set_dump
)
1553 if (copy_from_user(&dump
, useraddr
, sizeof(dump
)))
1556 return dev
->ethtool_ops
->set_dump(dev
, &dump
);
1559 static int ethtool_get_dump_flag(struct net_device
*dev
,
1560 void __user
*useraddr
)
1563 struct ethtool_dump dump
;
1564 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1566 if (!dev
->ethtool_ops
->get_dump_flag
)
1569 if (copy_from_user(&dump
, useraddr
, sizeof(dump
)))
1572 ret
= ops
->get_dump_flag(dev
, &dump
);
1576 if (copy_to_user(useraddr
, &dump
, sizeof(dump
)))
1581 static int ethtool_get_dump_data(struct net_device
*dev
,
1582 void __user
*useraddr
)
1586 struct ethtool_dump dump
, tmp
;
1587 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1590 if (!dev
->ethtool_ops
->get_dump_data
||
1591 !dev
->ethtool_ops
->get_dump_flag
)
1594 if (copy_from_user(&dump
, useraddr
, sizeof(dump
)))
1597 memset(&tmp
, 0, sizeof(tmp
));
1598 tmp
.cmd
= ETHTOOL_GET_DUMP_FLAG
;
1599 ret
= ops
->get_dump_flag(dev
, &tmp
);
1603 len
= (tmp
.len
> dump
.len
) ? dump
.len
: tmp
.len
;
1607 data
= vzalloc(tmp
.len
);
1610 ret
= ops
->get_dump_data(dev
, &dump
, data
);
1614 if (copy_to_user(useraddr
, &dump
, sizeof(dump
))) {
1618 useraddr
+= offsetof(struct ethtool_dump
, data
);
1619 if (copy_to_user(useraddr
, data
, len
))
1626 /* The main entry point in this file. Called from net/core/dev.c */
1628 int dev_ethtool(struct net
*net
, struct ifreq
*ifr
)
1630 struct net_device
*dev
= __dev_get_by_name(net
, ifr
->ifr_name
);
1631 void __user
*useraddr
= ifr
->ifr_data
;
1636 if (!dev
|| !netif_device_present(dev
))
1639 if (copy_from_user(ðcmd
, useraddr
, sizeof(ethcmd
)))
1642 if (!dev
->ethtool_ops
) {
1643 /* ETHTOOL_GDRVINFO does not require any driver support.
1644 * It is also unprivileged and does not change anything,
1645 * so we can take a shortcut to it. */
1646 if (ethcmd
== ETHTOOL_GDRVINFO
)
1647 return ethtool_get_drvinfo(dev
, useraddr
);
1652 /* Allow some commands to be done by anyone */
1655 case ETHTOOL_GDRVINFO
:
1656 case ETHTOOL_GMSGLVL
:
1657 case ETHTOOL_GCOALESCE
:
1658 case ETHTOOL_GRINGPARAM
:
1659 case ETHTOOL_GPAUSEPARAM
:
1660 case ETHTOOL_GRXCSUM
:
1661 case ETHTOOL_GTXCSUM
:
1663 case ETHTOOL_GSTRINGS
:
1665 case ETHTOOL_GPERMADDR
:
1669 case ETHTOOL_GFLAGS
:
1670 case ETHTOOL_GPFLAGS
:
1672 case ETHTOOL_GRXRINGS
:
1673 case ETHTOOL_GRXCLSRLCNT
:
1674 case ETHTOOL_GRXCLSRULE
:
1675 case ETHTOOL_GRXCLSRLALL
:
1676 case ETHTOOL_GFEATURES
:
1679 if (!capable(CAP_NET_ADMIN
))
1683 if (dev
->ethtool_ops
->begin
) {
1684 rc
= dev
->ethtool_ops
->begin(dev
);
1688 old_features
= dev
->features
;
1692 rc
= ethtool_get_settings(dev
, useraddr
);
1695 rc
= ethtool_set_settings(dev
, useraddr
);
1697 case ETHTOOL_GDRVINFO
:
1698 rc
= ethtool_get_drvinfo(dev
, useraddr
);
1701 rc
= ethtool_get_regs(dev
, useraddr
);
1704 rc
= ethtool_get_wol(dev
, useraddr
);
1707 rc
= ethtool_set_wol(dev
, useraddr
);
1709 case ETHTOOL_GMSGLVL
:
1710 rc
= ethtool_get_value(dev
, useraddr
, ethcmd
,
1711 dev
->ethtool_ops
->get_msglevel
);
1713 case ETHTOOL_SMSGLVL
:
1714 rc
= ethtool_set_value_void(dev
, useraddr
,
1715 dev
->ethtool_ops
->set_msglevel
);
1717 case ETHTOOL_NWAY_RST
:
1718 rc
= ethtool_nway_reset(dev
);
1721 rc
= ethtool_get_link(dev
, useraddr
);
1723 case ETHTOOL_GEEPROM
:
1724 rc
= ethtool_get_eeprom(dev
, useraddr
);
1726 case ETHTOOL_SEEPROM
:
1727 rc
= ethtool_set_eeprom(dev
, useraddr
);
1729 case ETHTOOL_GCOALESCE
:
1730 rc
= ethtool_get_coalesce(dev
, useraddr
);
1732 case ETHTOOL_SCOALESCE
:
1733 rc
= ethtool_set_coalesce(dev
, useraddr
);
1735 case ETHTOOL_GRINGPARAM
:
1736 rc
= ethtool_get_ringparam(dev
, useraddr
);
1738 case ETHTOOL_SRINGPARAM
:
1739 rc
= ethtool_set_ringparam(dev
, useraddr
);
1741 case ETHTOOL_GPAUSEPARAM
:
1742 rc
= ethtool_get_pauseparam(dev
, useraddr
);
1744 case ETHTOOL_SPAUSEPARAM
:
1745 rc
= ethtool_set_pauseparam(dev
, useraddr
);
1748 rc
= ethtool_self_test(dev
, useraddr
);
1750 case ETHTOOL_GSTRINGS
:
1751 rc
= ethtool_get_strings(dev
, useraddr
);
1753 case ETHTOOL_PHYS_ID
:
1754 rc
= ethtool_phys_id(dev
, useraddr
);
1756 case ETHTOOL_GSTATS
:
1757 rc
= ethtool_get_stats(dev
, useraddr
);
1759 case ETHTOOL_GPERMADDR
:
1760 rc
= ethtool_get_perm_addr(dev
, useraddr
);
1762 case ETHTOOL_GFLAGS
:
1763 rc
= ethtool_get_value(dev
, useraddr
, ethcmd
,
1764 (dev
->ethtool_ops
->get_flags
?
1765 dev
->ethtool_ops
->get_flags
:
1766 ethtool_op_get_flags
));
1768 case ETHTOOL_SFLAGS
:
1769 rc
= ethtool_set_value(dev
, useraddr
, __ethtool_set_flags
);
1771 case ETHTOOL_GPFLAGS
:
1772 rc
= ethtool_get_value(dev
, useraddr
, ethcmd
,
1773 dev
->ethtool_ops
->get_priv_flags
);
1775 case ETHTOOL_SPFLAGS
:
1776 rc
= ethtool_set_value(dev
, useraddr
,
1777 dev
->ethtool_ops
->set_priv_flags
);
1780 case ETHTOOL_GRXRINGS
:
1781 case ETHTOOL_GRXCLSRLCNT
:
1782 case ETHTOOL_GRXCLSRULE
:
1783 case ETHTOOL_GRXCLSRLALL
:
1784 rc
= ethtool_get_rxnfc(dev
, ethcmd
, useraddr
);
1787 case ETHTOOL_SRXCLSRLDEL
:
1788 case ETHTOOL_SRXCLSRLINS
:
1789 rc
= ethtool_set_rxnfc(dev
, ethcmd
, useraddr
);
1791 case ETHTOOL_FLASHDEV
:
1792 rc
= ethtool_flash_device(dev
, useraddr
);
1795 rc
= ethtool_reset(dev
, useraddr
);
1797 case ETHTOOL_SRXNTUPLE
:
1798 rc
= ethtool_set_rx_ntuple(dev
, useraddr
);
1800 case ETHTOOL_GSSET_INFO
:
1801 rc
= ethtool_get_sset_info(dev
, useraddr
);
1803 case ETHTOOL_GRXFHINDIR
:
1804 rc
= ethtool_get_rxfh_indir(dev
, useraddr
);
1806 case ETHTOOL_SRXFHINDIR
:
1807 rc
= ethtool_set_rxfh_indir(dev
, useraddr
);
1809 case ETHTOOL_GFEATURES
:
1810 rc
= ethtool_get_features(dev
, useraddr
);
1812 case ETHTOOL_SFEATURES
:
1813 rc
= ethtool_set_features(dev
, useraddr
);
1815 case ETHTOOL_GTXCSUM
:
1816 case ETHTOOL_GRXCSUM
:
1822 rc
= ethtool_get_one_feature(dev
, useraddr
, ethcmd
);
1824 case ETHTOOL_STXCSUM
:
1825 case ETHTOOL_SRXCSUM
:
1831 rc
= ethtool_set_one_feature(dev
, useraddr
, ethcmd
);
1833 case ETHTOOL_GCHANNELS
:
1834 rc
= ethtool_get_channels(dev
, useraddr
);
1836 case ETHTOOL_SCHANNELS
:
1837 rc
= ethtool_set_channels(dev
, useraddr
);
1839 case ETHTOOL_SET_DUMP
:
1840 rc
= ethtool_set_dump(dev
, useraddr
);
1842 case ETHTOOL_GET_DUMP_FLAG
:
1843 rc
= ethtool_get_dump_flag(dev
, useraddr
);
1845 case ETHTOOL_GET_DUMP_DATA
:
1846 rc
= ethtool_get_dump_data(dev
, useraddr
);
1852 if (dev
->ethtool_ops
->complete
)
1853 dev
->ethtool_ops
->complete(dev
);
1855 if (old_features
!= dev
->features
)
1856 netdev_features_change(dev
);