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/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 #include <linux/net.h>
31 * Some useful ethtool_ops methods that're device independent.
32 * If we find that all drivers want to do the same thing here,
33 * we can turn these into dev_() function calls.
36 u32
ethtool_op_get_link(struct net_device
*dev
)
38 return netif_carrier_ok(dev
) ? 1 : 0;
40 EXPORT_SYMBOL(ethtool_op_get_link
);
42 int ethtool_op_get_ts_info(struct net_device
*dev
, struct ethtool_ts_info
*info
)
44 info
->so_timestamping
=
45 SOF_TIMESTAMPING_TX_SOFTWARE
|
46 SOF_TIMESTAMPING_RX_SOFTWARE
|
47 SOF_TIMESTAMPING_SOFTWARE
;
51 EXPORT_SYMBOL(ethtool_op_get_ts_info
);
53 /* Handlers for each ethtool command */
55 #define ETHTOOL_DEV_FEATURE_WORDS ((NETDEV_FEATURE_COUNT + 31) / 32)
57 static const char netdev_features_strings
[NETDEV_FEATURE_COUNT
][ETH_GSTRING_LEN
] = {
58 [NETIF_F_SG_BIT
] = "tx-scatter-gather",
59 [NETIF_F_IP_CSUM_BIT
] = "tx-checksum-ipv4",
60 [NETIF_F_HW_CSUM_BIT
] = "tx-checksum-ip-generic",
61 [NETIF_F_IPV6_CSUM_BIT
] = "tx-checksum-ipv6",
62 [NETIF_F_HIGHDMA_BIT
] = "highdma",
63 [NETIF_F_FRAGLIST_BIT
] = "tx-scatter-gather-fraglist",
64 [NETIF_F_HW_VLAN_CTAG_TX_BIT
] = "tx-vlan-hw-insert",
66 [NETIF_F_HW_VLAN_CTAG_RX_BIT
] = "rx-vlan-hw-parse",
67 [NETIF_F_HW_VLAN_CTAG_FILTER_BIT
] = "rx-vlan-filter",
68 [NETIF_F_HW_VLAN_STAG_TX_BIT
] = "tx-vlan-stag-hw-insert",
69 [NETIF_F_HW_VLAN_STAG_RX_BIT
] = "rx-vlan-stag-hw-parse",
70 [NETIF_F_HW_VLAN_STAG_FILTER_BIT
] = "rx-vlan-stag-filter",
71 [NETIF_F_VLAN_CHALLENGED_BIT
] = "vlan-challenged",
72 [NETIF_F_GSO_BIT
] = "tx-generic-segmentation",
73 [NETIF_F_LLTX_BIT
] = "tx-lockless",
74 [NETIF_F_NETNS_LOCAL_BIT
] = "netns-local",
75 [NETIF_F_GRO_BIT
] = "rx-gro",
76 [NETIF_F_LRO_BIT
] = "rx-lro",
78 [NETIF_F_TSO_BIT
] = "tx-tcp-segmentation",
79 [NETIF_F_UFO_BIT
] = "tx-udp-fragmentation",
80 [NETIF_F_GSO_ROBUST_BIT
] = "tx-gso-robust",
81 [NETIF_F_TSO_ECN_BIT
] = "tx-tcp-ecn-segmentation",
82 [NETIF_F_TSO_MANGLEID_BIT
] = "tx-tcp-mangleid-segmentation",
83 [NETIF_F_TSO6_BIT
] = "tx-tcp6-segmentation",
84 [NETIF_F_FSO_BIT
] = "tx-fcoe-segmentation",
85 [NETIF_F_GSO_GRE_BIT
] = "tx-gre-segmentation",
86 [NETIF_F_GSO_GRE_CSUM_BIT
] = "tx-gre-csum-segmentation",
87 [NETIF_F_GSO_IPIP_BIT
] = "tx-ipip-segmentation",
88 [NETIF_F_GSO_SIT_BIT
] = "tx-sit-segmentation",
89 [NETIF_F_GSO_UDP_TUNNEL_BIT
] = "tx-udp_tnl-segmentation",
90 [NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT
] = "tx-udp_tnl-csum-segmentation",
91 [NETIF_F_GSO_PARTIAL_BIT
] = "tx-gso-partial",
93 [NETIF_F_FCOE_CRC_BIT
] = "tx-checksum-fcoe-crc",
94 [NETIF_F_SCTP_CRC_BIT
] = "tx-checksum-sctp",
95 [NETIF_F_FCOE_MTU_BIT
] = "fcoe-mtu",
96 [NETIF_F_NTUPLE_BIT
] = "rx-ntuple-filter",
97 [NETIF_F_RXHASH_BIT
] = "rx-hashing",
98 [NETIF_F_RXCSUM_BIT
] = "rx-checksum",
99 [NETIF_F_NOCACHE_COPY_BIT
] = "tx-nocache-copy",
100 [NETIF_F_LOOPBACK_BIT
] = "loopback",
101 [NETIF_F_RXFCS_BIT
] = "rx-fcs",
102 [NETIF_F_RXALL_BIT
] = "rx-all",
103 [NETIF_F_HW_L2FW_DOFFLOAD_BIT
] = "l2-fwd-offload",
104 [NETIF_F_BUSY_POLL_BIT
] = "busy-poll",
105 [NETIF_F_HW_TC_BIT
] = "hw-tc-offload",
109 rss_hash_func_strings
[ETH_RSS_HASH_FUNCS_COUNT
][ETH_GSTRING_LEN
] = {
110 [ETH_RSS_HASH_TOP_BIT
] = "toeplitz",
111 [ETH_RSS_HASH_XOR_BIT
] = "xor",
115 tunable_strings
[__ETHTOOL_TUNABLE_COUNT
][ETH_GSTRING_LEN
] = {
116 [ETHTOOL_ID_UNSPEC
] = "Unspec",
117 [ETHTOOL_RX_COPYBREAK
] = "rx-copybreak",
118 [ETHTOOL_TX_COPYBREAK
] = "tx-copybreak",
121 static int ethtool_get_features(struct net_device
*dev
, void __user
*useraddr
)
123 struct ethtool_gfeatures cmd
= {
124 .cmd
= ETHTOOL_GFEATURES
,
125 .size
= ETHTOOL_DEV_FEATURE_WORDS
,
127 struct ethtool_get_features_block features
[ETHTOOL_DEV_FEATURE_WORDS
];
128 u32 __user
*sizeaddr
;
132 /* in case feature bits run out again */
133 BUILD_BUG_ON(ETHTOOL_DEV_FEATURE_WORDS
* sizeof(u32
) > sizeof(netdev_features_t
));
135 for (i
= 0; i
< ETHTOOL_DEV_FEATURE_WORDS
; ++i
) {
136 features
[i
].available
= (u32
)(dev
->hw_features
>> (32 * i
));
137 features
[i
].requested
= (u32
)(dev
->wanted_features
>> (32 * i
));
138 features
[i
].active
= (u32
)(dev
->features
>> (32 * i
));
139 features
[i
].never_changed
=
140 (u32
)(NETIF_F_NEVER_CHANGE
>> (32 * i
));
143 sizeaddr
= useraddr
+ offsetof(struct ethtool_gfeatures
, size
);
144 if (get_user(copy_size
, sizeaddr
))
147 if (copy_size
> ETHTOOL_DEV_FEATURE_WORDS
)
148 copy_size
= ETHTOOL_DEV_FEATURE_WORDS
;
150 if (copy_to_user(useraddr
, &cmd
, sizeof(cmd
)))
152 useraddr
+= sizeof(cmd
);
153 if (copy_to_user(useraddr
, features
, copy_size
* sizeof(*features
)))
159 static int ethtool_set_features(struct net_device
*dev
, void __user
*useraddr
)
161 struct ethtool_sfeatures cmd
;
162 struct ethtool_set_features_block features
[ETHTOOL_DEV_FEATURE_WORDS
];
163 netdev_features_t wanted
= 0, valid
= 0;
166 if (copy_from_user(&cmd
, useraddr
, sizeof(cmd
)))
168 useraddr
+= sizeof(cmd
);
170 if (cmd
.size
!= ETHTOOL_DEV_FEATURE_WORDS
)
173 if (copy_from_user(features
, useraddr
, sizeof(features
)))
176 for (i
= 0; i
< ETHTOOL_DEV_FEATURE_WORDS
; ++i
) {
177 valid
|= (netdev_features_t
)features
[i
].valid
<< (32 * i
);
178 wanted
|= (netdev_features_t
)features
[i
].requested
<< (32 * i
);
181 if (valid
& ~NETIF_F_ETHTOOL_BITS
)
184 if (valid
& ~dev
->hw_features
) {
185 valid
&= dev
->hw_features
;
186 ret
|= ETHTOOL_F_UNSUPPORTED
;
189 dev
->wanted_features
&= ~valid
;
190 dev
->wanted_features
|= wanted
& valid
;
191 __netdev_update_features(dev
);
193 if ((dev
->wanted_features
^ dev
->features
) & valid
)
194 ret
|= ETHTOOL_F_WISH
;
199 static int phy_get_sset_count(struct phy_device
*phydev
)
203 if (phydev
->drv
->get_sset_count
&&
204 phydev
->drv
->get_strings
&&
205 phydev
->drv
->get_stats
) {
206 mutex_lock(&phydev
->lock
);
207 ret
= phydev
->drv
->get_sset_count(phydev
);
208 mutex_unlock(&phydev
->lock
);
216 static int __ethtool_get_sset_count(struct net_device
*dev
, int sset
)
218 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
220 if (sset
== ETH_SS_FEATURES
)
221 return ARRAY_SIZE(netdev_features_strings
);
223 if (sset
== ETH_SS_RSS_HASH_FUNCS
)
224 return ARRAY_SIZE(rss_hash_func_strings
);
226 if (sset
== ETH_SS_TUNABLES
)
227 return ARRAY_SIZE(tunable_strings
);
229 if (sset
== ETH_SS_PHY_STATS
) {
231 return phy_get_sset_count(dev
->phydev
);
236 if (ops
->get_sset_count
&& ops
->get_strings
)
237 return ops
->get_sset_count(dev
, sset
);
242 static void __ethtool_get_strings(struct net_device
*dev
,
243 u32 stringset
, u8
*data
)
245 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
247 if (stringset
== ETH_SS_FEATURES
)
248 memcpy(data
, netdev_features_strings
,
249 sizeof(netdev_features_strings
));
250 else if (stringset
== ETH_SS_RSS_HASH_FUNCS
)
251 memcpy(data
, rss_hash_func_strings
,
252 sizeof(rss_hash_func_strings
));
253 else if (stringset
== ETH_SS_TUNABLES
)
254 memcpy(data
, tunable_strings
, sizeof(tunable_strings
));
255 else if (stringset
== ETH_SS_PHY_STATS
) {
256 struct phy_device
*phydev
= dev
->phydev
;
259 mutex_lock(&phydev
->lock
);
260 phydev
->drv
->get_strings(phydev
, data
);
261 mutex_unlock(&phydev
->lock
);
266 /* ops->get_strings is valid because checked earlier */
267 ops
->get_strings(dev
, stringset
, data
);
270 static netdev_features_t
ethtool_get_feature_mask(u32 eth_cmd
)
272 /* feature masks of legacy discrete ethtool ops */
275 case ETHTOOL_GTXCSUM
:
276 case ETHTOOL_STXCSUM
:
277 return NETIF_F_CSUM_MASK
| NETIF_F_SCTP_CRC
;
278 case ETHTOOL_GRXCSUM
:
279 case ETHTOOL_SRXCSUM
:
280 return NETIF_F_RXCSUM
;
286 return NETIF_F_ALL_TSO
;
301 static int ethtool_get_one_feature(struct net_device
*dev
,
302 char __user
*useraddr
, u32 ethcmd
)
304 netdev_features_t mask
= ethtool_get_feature_mask(ethcmd
);
305 struct ethtool_value edata
= {
307 .data
= !!(dev
->features
& mask
),
310 if (copy_to_user(useraddr
, &edata
, sizeof(edata
)))
315 static int ethtool_set_one_feature(struct net_device
*dev
,
316 void __user
*useraddr
, u32 ethcmd
)
318 struct ethtool_value edata
;
319 netdev_features_t mask
;
321 if (copy_from_user(&edata
, useraddr
, sizeof(edata
)))
324 mask
= ethtool_get_feature_mask(ethcmd
);
325 mask
&= dev
->hw_features
;
330 dev
->wanted_features
|= mask
;
332 dev
->wanted_features
&= ~mask
;
334 __netdev_update_features(dev
);
339 #define ETH_ALL_FLAGS (ETH_FLAG_LRO | ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN | \
340 ETH_FLAG_NTUPLE | ETH_FLAG_RXHASH)
341 #define ETH_ALL_FEATURES (NETIF_F_LRO | NETIF_F_HW_VLAN_CTAG_RX | \
342 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_NTUPLE | \
345 static u32
__ethtool_get_flags(struct net_device
*dev
)
349 if (dev
->features
& NETIF_F_LRO
)
350 flags
|= ETH_FLAG_LRO
;
351 if (dev
->features
& NETIF_F_HW_VLAN_CTAG_RX
)
352 flags
|= ETH_FLAG_RXVLAN
;
353 if (dev
->features
& NETIF_F_HW_VLAN_CTAG_TX
)
354 flags
|= ETH_FLAG_TXVLAN
;
355 if (dev
->features
& NETIF_F_NTUPLE
)
356 flags
|= ETH_FLAG_NTUPLE
;
357 if (dev
->features
& NETIF_F_RXHASH
)
358 flags
|= ETH_FLAG_RXHASH
;
363 static int __ethtool_set_flags(struct net_device
*dev
, u32 data
)
365 netdev_features_t features
= 0, changed
;
367 if (data
& ~ETH_ALL_FLAGS
)
370 if (data
& ETH_FLAG_LRO
)
371 features
|= NETIF_F_LRO
;
372 if (data
& ETH_FLAG_RXVLAN
)
373 features
|= NETIF_F_HW_VLAN_CTAG_RX
;
374 if (data
& ETH_FLAG_TXVLAN
)
375 features
|= NETIF_F_HW_VLAN_CTAG_TX
;
376 if (data
& ETH_FLAG_NTUPLE
)
377 features
|= NETIF_F_NTUPLE
;
378 if (data
& ETH_FLAG_RXHASH
)
379 features
|= NETIF_F_RXHASH
;
381 /* allow changing only bits set in hw_features */
382 changed
= (features
^ dev
->features
) & ETH_ALL_FEATURES
;
383 if (changed
& ~dev
->hw_features
)
384 return (changed
& dev
->hw_features
) ? -EINVAL
: -EOPNOTSUPP
;
386 dev
->wanted_features
=
387 (dev
->wanted_features
& ~changed
) | (features
& changed
);
389 __netdev_update_features(dev
);
394 static void convert_legacy_u32_to_link_mode(unsigned long *dst
, u32 legacy_u32
)
396 bitmap_zero(dst
, __ETHTOOL_LINK_MODE_MASK_NBITS
);
400 /* return false if src had higher bits set. lower bits always updated. */
401 static bool convert_link_mode_to_legacy_u32(u32
*legacy_u32
,
402 const unsigned long *src
)
406 /* TODO: following test will soon always be true */
407 if (__ETHTOOL_LINK_MODE_MASK_NBITS
> 32) {
408 __ETHTOOL_DECLARE_LINK_MODE_MASK(ext
);
410 bitmap_zero(ext
, __ETHTOOL_LINK_MODE_MASK_NBITS
);
411 bitmap_fill(ext
, 32);
412 bitmap_complement(ext
, ext
, __ETHTOOL_LINK_MODE_MASK_NBITS
);
413 if (bitmap_intersects(ext
, src
,
414 __ETHTOOL_LINK_MODE_MASK_NBITS
)) {
415 /* src mask goes beyond bit 31 */
419 *legacy_u32
= src
[0];
423 /* return false if legacy contained non-0 deprecated fields
424 * transceiver/maxtxpkt/maxrxpkt. rest of ksettings always updated
427 convert_legacy_settings_to_link_ksettings(
428 struct ethtool_link_ksettings
*link_ksettings
,
429 const struct ethtool_cmd
*legacy_settings
)
433 memset(link_ksettings
, 0, sizeof(*link_ksettings
));
435 /* This is used to tell users that driver is still using these
436 * deprecated legacy fields, and they should not use
437 * %ETHTOOL_GLINKSETTINGS/%ETHTOOL_SLINKSETTINGS
439 if (legacy_settings
->transceiver
||
440 legacy_settings
->maxtxpkt
||
441 legacy_settings
->maxrxpkt
)
444 convert_legacy_u32_to_link_mode(
445 link_ksettings
->link_modes
.supported
,
446 legacy_settings
->supported
);
447 convert_legacy_u32_to_link_mode(
448 link_ksettings
->link_modes
.advertising
,
449 legacy_settings
->advertising
);
450 convert_legacy_u32_to_link_mode(
451 link_ksettings
->link_modes
.lp_advertising
,
452 legacy_settings
->lp_advertising
);
453 link_ksettings
->base
.speed
454 = ethtool_cmd_speed(legacy_settings
);
455 link_ksettings
->base
.duplex
456 = legacy_settings
->duplex
;
457 link_ksettings
->base
.port
458 = legacy_settings
->port
;
459 link_ksettings
->base
.phy_address
460 = legacy_settings
->phy_address
;
461 link_ksettings
->base
.autoneg
462 = legacy_settings
->autoneg
;
463 link_ksettings
->base
.mdio_support
464 = legacy_settings
->mdio_support
;
465 link_ksettings
->base
.eth_tp_mdix
466 = legacy_settings
->eth_tp_mdix
;
467 link_ksettings
->base
.eth_tp_mdix_ctrl
468 = legacy_settings
->eth_tp_mdix_ctrl
;
472 /* return false if ksettings link modes had higher bits
473 * set. legacy_settings always updated (best effort)
476 convert_link_ksettings_to_legacy_settings(
477 struct ethtool_cmd
*legacy_settings
,
478 const struct ethtool_link_ksettings
*link_ksettings
)
482 memset(legacy_settings
, 0, sizeof(*legacy_settings
));
483 /* this also clears the deprecated fields in legacy structure:
489 retval
&= convert_link_mode_to_legacy_u32(
490 &legacy_settings
->supported
,
491 link_ksettings
->link_modes
.supported
);
492 retval
&= convert_link_mode_to_legacy_u32(
493 &legacy_settings
->advertising
,
494 link_ksettings
->link_modes
.advertising
);
495 retval
&= convert_link_mode_to_legacy_u32(
496 &legacy_settings
->lp_advertising
,
497 link_ksettings
->link_modes
.lp_advertising
);
498 ethtool_cmd_speed_set(legacy_settings
, link_ksettings
->base
.speed
);
499 legacy_settings
->duplex
500 = link_ksettings
->base
.duplex
;
501 legacy_settings
->port
502 = link_ksettings
->base
.port
;
503 legacy_settings
->phy_address
504 = link_ksettings
->base
.phy_address
;
505 legacy_settings
->autoneg
506 = link_ksettings
->base
.autoneg
;
507 legacy_settings
->mdio_support
508 = link_ksettings
->base
.mdio_support
;
509 legacy_settings
->eth_tp_mdix
510 = link_ksettings
->base
.eth_tp_mdix
;
511 legacy_settings
->eth_tp_mdix_ctrl
512 = link_ksettings
->base
.eth_tp_mdix_ctrl
;
516 /* number of 32-bit words to store the user's link mode bitmaps */
517 #define __ETHTOOL_LINK_MODE_MASK_NU32 \
518 DIV_ROUND_UP(__ETHTOOL_LINK_MODE_MASK_NBITS, 32)
520 /* layout of the struct passed from/to userland */
521 struct ethtool_link_usettings
{
522 struct ethtool_link_settings base
;
524 __u32 supported
[__ETHTOOL_LINK_MODE_MASK_NU32
];
525 __u32 advertising
[__ETHTOOL_LINK_MODE_MASK_NU32
];
526 __u32 lp_advertising
[__ETHTOOL_LINK_MODE_MASK_NU32
];
530 /* Internal kernel helper to query a device ethtool_link_settings.
532 * Backward compatibility note: for compatibility with legacy drivers
533 * that implement only the ethtool_cmd API, this has to work with both
534 * drivers implementing get_link_ksettings API and drivers
535 * implementing get_settings API. When drivers implement get_settings
536 * and report ethtool_cmd deprecated fields
537 * (transceiver/maxrxpkt/maxtxpkt), these fields are silently ignored
538 * because the resulting struct ethtool_link_settings does not report them.
540 int __ethtool_get_link_ksettings(struct net_device
*dev
,
541 struct ethtool_link_ksettings
*link_ksettings
)
544 struct ethtool_cmd cmd
;
548 if (dev
->ethtool_ops
->get_link_ksettings
) {
549 memset(link_ksettings
, 0, sizeof(*link_ksettings
));
550 return dev
->ethtool_ops
->get_link_ksettings(dev
,
554 /* driver doesn't support %ethtool_link_ksettings API. revert to
555 * legacy %ethtool_cmd API, unless it's not supported either.
556 * TODO: remove when ethtool_ops::get_settings disappears internally
558 if (!dev
->ethtool_ops
->get_settings
)
561 memset(&cmd
, 0, sizeof(cmd
));
562 cmd
.cmd
= ETHTOOL_GSET
;
563 err
= dev
->ethtool_ops
->get_settings(dev
, &cmd
);
567 /* we ignore deprecated fields transceiver/maxrxpkt/maxtxpkt
569 convert_legacy_settings_to_link_ksettings(link_ksettings
, &cmd
);
572 EXPORT_SYMBOL(__ethtool_get_link_ksettings
);
574 /* convert ethtool_link_usettings in user space to a kernel internal
575 * ethtool_link_ksettings. return 0 on success, errno on error.
577 static int load_link_ksettings_from_user(struct ethtool_link_ksettings
*to
,
578 const void __user
*from
)
580 struct ethtool_link_usettings link_usettings
;
582 if (copy_from_user(&link_usettings
, from
, sizeof(link_usettings
)))
585 memcpy(&to
->base
, &link_usettings
.base
, sizeof(to
->base
));
586 bitmap_from_u32array(to
->link_modes
.supported
,
587 __ETHTOOL_LINK_MODE_MASK_NBITS
,
588 link_usettings
.link_modes
.supported
,
589 __ETHTOOL_LINK_MODE_MASK_NU32
);
590 bitmap_from_u32array(to
->link_modes
.advertising
,
591 __ETHTOOL_LINK_MODE_MASK_NBITS
,
592 link_usettings
.link_modes
.advertising
,
593 __ETHTOOL_LINK_MODE_MASK_NU32
);
594 bitmap_from_u32array(to
->link_modes
.lp_advertising
,
595 __ETHTOOL_LINK_MODE_MASK_NBITS
,
596 link_usettings
.link_modes
.lp_advertising
,
597 __ETHTOOL_LINK_MODE_MASK_NU32
);
602 /* convert a kernel internal ethtool_link_ksettings to
603 * ethtool_link_usettings in user space. return 0 on success, errno on
607 store_link_ksettings_for_user(void __user
*to
,
608 const struct ethtool_link_ksettings
*from
)
610 struct ethtool_link_usettings link_usettings
;
612 memcpy(&link_usettings
.base
, &from
->base
, sizeof(link_usettings
));
613 bitmap_to_u32array(link_usettings
.link_modes
.supported
,
614 __ETHTOOL_LINK_MODE_MASK_NU32
,
615 from
->link_modes
.supported
,
616 __ETHTOOL_LINK_MODE_MASK_NBITS
);
617 bitmap_to_u32array(link_usettings
.link_modes
.advertising
,
618 __ETHTOOL_LINK_MODE_MASK_NU32
,
619 from
->link_modes
.advertising
,
620 __ETHTOOL_LINK_MODE_MASK_NBITS
);
621 bitmap_to_u32array(link_usettings
.link_modes
.lp_advertising
,
622 __ETHTOOL_LINK_MODE_MASK_NU32
,
623 from
->link_modes
.lp_advertising
,
624 __ETHTOOL_LINK_MODE_MASK_NBITS
);
626 if (copy_to_user(to
, &link_usettings
, sizeof(link_usettings
)))
632 /* Query device for its ethtool_link_settings.
634 * Backward compatibility note: this function must fail when driver
635 * does not implement ethtool::get_link_ksettings, even if legacy
636 * ethtool_ops::get_settings is implemented. This tells new versions
637 * of ethtool that they should use the legacy API %ETHTOOL_GSET for
638 * this driver, so that they can correctly access the ethtool_cmd
639 * deprecated fields (transceiver/maxrxpkt/maxtxpkt), until no driver
640 * implements ethtool_ops::get_settings anymore.
642 static int ethtool_get_link_ksettings(struct net_device
*dev
,
643 void __user
*useraddr
)
646 struct ethtool_link_ksettings link_ksettings
;
650 if (!dev
->ethtool_ops
->get_link_ksettings
)
653 /* handle bitmap nbits handshake */
654 if (copy_from_user(&link_ksettings
.base
, useraddr
,
655 sizeof(link_ksettings
.base
)))
658 if (__ETHTOOL_LINK_MODE_MASK_NU32
659 != link_ksettings
.base
.link_mode_masks_nwords
) {
660 /* wrong link mode nbits requested */
661 memset(&link_ksettings
, 0, sizeof(link_ksettings
));
662 link_ksettings
.base
.cmd
= ETHTOOL_GLINKSETTINGS
;
663 /* send back number of words required as negative val */
664 compiletime_assert(__ETHTOOL_LINK_MODE_MASK_NU32
<= S8_MAX
,
665 "need too many bits for link modes!");
666 link_ksettings
.base
.link_mode_masks_nwords
667 = -((s8
)__ETHTOOL_LINK_MODE_MASK_NU32
);
669 /* copy the base fields back to user, not the link
672 if (copy_to_user(useraddr
, &link_ksettings
.base
,
673 sizeof(link_ksettings
.base
)))
679 /* handshake successful: user/kernel agree on
680 * link_mode_masks_nwords
683 memset(&link_ksettings
, 0, sizeof(link_ksettings
));
684 err
= dev
->ethtool_ops
->get_link_ksettings(dev
, &link_ksettings
);
688 /* make sure we tell the right values to user */
689 link_ksettings
.base
.cmd
= ETHTOOL_GLINKSETTINGS
;
690 link_ksettings
.base
.link_mode_masks_nwords
691 = __ETHTOOL_LINK_MODE_MASK_NU32
;
693 return store_link_ksettings_for_user(useraddr
, &link_ksettings
);
696 /* Update device ethtool_link_settings.
698 * Backward compatibility note: this function must fail when driver
699 * does not implement ethtool::set_link_ksettings, even if legacy
700 * ethtool_ops::set_settings is implemented. This tells new versions
701 * of ethtool that they should use the legacy API %ETHTOOL_SSET for
702 * this driver, so that they can correctly update the ethtool_cmd
703 * deprecated fields (transceiver/maxrxpkt/maxtxpkt), until no driver
704 * implements ethtool_ops::get_settings anymore.
706 static int ethtool_set_link_ksettings(struct net_device
*dev
,
707 void __user
*useraddr
)
710 struct ethtool_link_ksettings link_ksettings
;
714 if (!dev
->ethtool_ops
->set_link_ksettings
)
717 /* make sure nbits field has expected value */
718 if (copy_from_user(&link_ksettings
.base
, useraddr
,
719 sizeof(link_ksettings
.base
)))
722 if (__ETHTOOL_LINK_MODE_MASK_NU32
723 != link_ksettings
.base
.link_mode_masks_nwords
)
726 /* copy the whole structure, now that we know it has expected
729 err
= load_link_ksettings_from_user(&link_ksettings
, useraddr
);
733 /* re-check nwords field, just in case */
734 if (__ETHTOOL_LINK_MODE_MASK_NU32
735 != link_ksettings
.base
.link_mode_masks_nwords
)
738 return dev
->ethtool_ops
->set_link_ksettings(dev
, &link_ksettings
);
742 warn_incomplete_ethtool_legacy_settings_conversion(const char *details
)
744 char name
[sizeof(current
->comm
)];
746 pr_info_once("warning: `%s' uses legacy ethtool link settings API, %s\n",
747 get_task_comm(name
, current
), details
);
750 /* Query device for its ethtool_cmd settings.
752 * Backward compatibility note: for compatibility with legacy ethtool,
753 * this has to work with both drivers implementing get_link_ksettings
754 * API and drivers implementing get_settings API. When drivers
755 * implement get_link_ksettings and report higher link mode bits, a
756 * kernel warning is logged once (with name of 1st driver/device) to
757 * recommend user to upgrade ethtool, but the command is successful
758 * (only the lower link mode bits reported back to user).
760 static int ethtool_get_settings(struct net_device
*dev
, void __user
*useraddr
)
762 struct ethtool_cmd cmd
;
766 if (dev
->ethtool_ops
->get_link_ksettings
) {
767 /* First, use link_ksettings API if it is supported */
769 struct ethtool_link_ksettings link_ksettings
;
771 memset(&link_ksettings
, 0, sizeof(link_ksettings
));
772 err
= dev
->ethtool_ops
->get_link_ksettings(dev
,
776 if (!convert_link_ksettings_to_legacy_settings(&cmd
,
778 warn_incomplete_ethtool_legacy_settings_conversion(
779 "link modes are only partially reported");
781 /* send a sensible cmd tag back to user */
782 cmd
.cmd
= ETHTOOL_GSET
;
784 /* driver doesn't support %ethtool_link_ksettings
785 * API. revert to legacy %ethtool_cmd API, unless it's
786 * not supported either.
790 if (!dev
->ethtool_ops
->get_settings
)
793 memset(&cmd
, 0, sizeof(cmd
));
794 cmd
.cmd
= ETHTOOL_GSET
;
795 err
= dev
->ethtool_ops
->get_settings(dev
, &cmd
);
800 if (copy_to_user(useraddr
, &cmd
, sizeof(cmd
)))
806 /* Update device link settings with given ethtool_cmd.
808 * Backward compatibility note: for compatibility with legacy ethtool,
809 * this has to work with both drivers implementing set_link_ksettings
810 * API and drivers implementing set_settings API. When drivers
811 * implement set_link_ksettings and user's request updates deprecated
812 * ethtool_cmd fields (transceiver/maxrxpkt/maxtxpkt), a kernel
813 * warning is logged once (with name of 1st driver/device) to
814 * recommend user to upgrade ethtool, and the request is rejected.
816 static int ethtool_set_settings(struct net_device
*dev
, void __user
*useraddr
)
818 struct ethtool_cmd cmd
;
822 if (copy_from_user(&cmd
, useraddr
, sizeof(cmd
)))
825 /* first, try new %ethtool_link_ksettings API. */
826 if (dev
->ethtool_ops
->set_link_ksettings
) {
827 struct ethtool_link_ksettings link_ksettings
;
829 if (!convert_legacy_settings_to_link_ksettings(&link_ksettings
,
833 link_ksettings
.base
.cmd
= ETHTOOL_SLINKSETTINGS
;
834 link_ksettings
.base
.link_mode_masks_nwords
835 = __ETHTOOL_LINK_MODE_MASK_NU32
;
836 return dev
->ethtool_ops
->set_link_ksettings(dev
,
840 /* legacy %ethtool_cmd API */
842 /* TODO: return -EOPNOTSUPP when ethtool_ops::get_settings
843 * disappears internally
846 if (!dev
->ethtool_ops
->set_settings
)
849 return dev
->ethtool_ops
->set_settings(dev
, &cmd
);
852 static noinline_for_stack
int ethtool_get_drvinfo(struct net_device
*dev
,
853 void __user
*useraddr
)
855 struct ethtool_drvinfo info
;
856 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
858 memset(&info
, 0, sizeof(info
));
859 info
.cmd
= ETHTOOL_GDRVINFO
;
860 if (ops
->get_drvinfo
) {
861 ops
->get_drvinfo(dev
, &info
);
862 } else if (dev
->dev
.parent
&& dev
->dev
.parent
->driver
) {
863 strlcpy(info
.bus_info
, dev_name(dev
->dev
.parent
),
864 sizeof(info
.bus_info
));
865 strlcpy(info
.driver
, dev
->dev
.parent
->driver
->name
,
866 sizeof(info
.driver
));
872 * this method of obtaining string set info is deprecated;
873 * Use ETHTOOL_GSSET_INFO instead.
875 if (ops
->get_sset_count
) {
878 rc
= ops
->get_sset_count(dev
, ETH_SS_TEST
);
880 info
.testinfo_len
= rc
;
881 rc
= ops
->get_sset_count(dev
, ETH_SS_STATS
);
884 rc
= ops
->get_sset_count(dev
, ETH_SS_PRIV_FLAGS
);
886 info
.n_priv_flags
= rc
;
888 if (ops
->get_regs_len
)
889 info
.regdump_len
= ops
->get_regs_len(dev
);
890 if (ops
->get_eeprom_len
)
891 info
.eedump_len
= ops
->get_eeprom_len(dev
);
893 if (copy_to_user(useraddr
, &info
, sizeof(info
)))
898 static noinline_for_stack
int ethtool_get_sset_info(struct net_device
*dev
,
899 void __user
*useraddr
)
901 struct ethtool_sset_info info
;
903 int i
, idx
= 0, n_bits
= 0, ret
, rc
;
904 u32
*info_buf
= NULL
;
906 if (copy_from_user(&info
, useraddr
, sizeof(info
)))
909 /* store copy of mask, because we zero struct later on */
910 sset_mask
= info
.sset_mask
;
914 /* calculate size of return buffer */
915 n_bits
= hweight64(sset_mask
);
917 memset(&info
, 0, sizeof(info
));
918 info
.cmd
= ETHTOOL_GSSET_INFO
;
920 info_buf
= kzalloc(n_bits
* sizeof(u32
), GFP_USER
);
925 * fill return buffer based on input bitmask and successful
926 * get_sset_count return
928 for (i
= 0; i
< 64; i
++) {
929 if (!(sset_mask
& (1ULL << i
)))
932 rc
= __ethtool_get_sset_count(dev
, i
);
934 info
.sset_mask
|= (1ULL << i
);
935 info_buf
[idx
++] = rc
;
940 if (copy_to_user(useraddr
, &info
, sizeof(info
)))
943 useraddr
+= offsetof(struct ethtool_sset_info
, data
);
944 if (copy_to_user(useraddr
, info_buf
, idx
* sizeof(u32
)))
954 static noinline_for_stack
int ethtool_set_rxnfc(struct net_device
*dev
,
955 u32 cmd
, void __user
*useraddr
)
957 struct ethtool_rxnfc info
;
958 size_t info_size
= sizeof(info
);
961 if (!dev
->ethtool_ops
->set_rxnfc
)
964 /* struct ethtool_rxnfc was originally defined for
965 * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
966 * members. User-space might still be using that
968 if (cmd
== ETHTOOL_SRXFH
)
969 info_size
= (offsetof(struct ethtool_rxnfc
, data
) +
972 if (copy_from_user(&info
, useraddr
, info_size
))
975 rc
= dev
->ethtool_ops
->set_rxnfc(dev
, &info
);
979 if (cmd
== ETHTOOL_SRXCLSRLINS
&&
980 copy_to_user(useraddr
, &info
, info_size
))
986 static noinline_for_stack
int ethtool_get_rxnfc(struct net_device
*dev
,
987 u32 cmd
, void __user
*useraddr
)
989 struct ethtool_rxnfc info
;
990 size_t info_size
= sizeof(info
);
991 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
993 void *rule_buf
= NULL
;
998 /* struct ethtool_rxnfc was originally defined for
999 * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
1000 * members. User-space might still be using that
1002 if (cmd
== ETHTOOL_GRXFH
)
1003 info_size
= (offsetof(struct ethtool_rxnfc
, data
) +
1006 if (copy_from_user(&info
, useraddr
, info_size
))
1009 if (info
.cmd
== ETHTOOL_GRXCLSRLALL
) {
1010 if (info
.rule_cnt
> 0) {
1011 if (info
.rule_cnt
<= KMALLOC_MAX_SIZE
/ sizeof(u32
))
1012 rule_buf
= kzalloc(info
.rule_cnt
* sizeof(u32
),
1019 ret
= ops
->get_rxnfc(dev
, &info
, rule_buf
);
1024 if (copy_to_user(useraddr
, &info
, info_size
))
1028 useraddr
+= offsetof(struct ethtool_rxnfc
, rule_locs
);
1029 if (copy_to_user(useraddr
, rule_buf
,
1030 info
.rule_cnt
* sizeof(u32
)))
1041 static int ethtool_copy_validate_indir(u32
*indir
, void __user
*useraddr
,
1042 struct ethtool_rxnfc
*rx_rings
,
1047 if (copy_from_user(indir
, useraddr
, size
* sizeof(indir
[0])))
1050 /* Validate ring indices */
1051 for (i
= 0; i
< size
; i
++)
1052 if (indir
[i
] >= rx_rings
->data
)
1058 u8 netdev_rss_key
[NETDEV_RSS_KEY_LEN
] __read_mostly
;
1060 void netdev_rss_key_fill(void *buffer
, size_t len
)
1062 BUG_ON(len
> sizeof(netdev_rss_key
));
1063 net_get_random_once(netdev_rss_key
, sizeof(netdev_rss_key
));
1064 memcpy(buffer
, netdev_rss_key
, len
);
1066 EXPORT_SYMBOL(netdev_rss_key_fill
);
1068 static int ethtool_get_max_rxfh_channel(struct net_device
*dev
, u32
*max
)
1070 u32 dev_size
, current_max
= 0;
1074 if (!dev
->ethtool_ops
->get_rxfh_indir_size
||
1075 !dev
->ethtool_ops
->get_rxfh
)
1077 dev_size
= dev
->ethtool_ops
->get_rxfh_indir_size(dev
);
1081 indir
= kcalloc(dev_size
, sizeof(indir
[0]), GFP_USER
);
1085 ret
= dev
->ethtool_ops
->get_rxfh(dev
, indir
, NULL
, NULL
);
1090 current_max
= max(current_max
, indir
[dev_size
]);
1099 static noinline_for_stack
int ethtool_get_rxfh_indir(struct net_device
*dev
,
1100 void __user
*useraddr
)
1102 u32 user_size
, dev_size
;
1106 if (!dev
->ethtool_ops
->get_rxfh_indir_size
||
1107 !dev
->ethtool_ops
->get_rxfh
)
1109 dev_size
= dev
->ethtool_ops
->get_rxfh_indir_size(dev
);
1113 if (copy_from_user(&user_size
,
1114 useraddr
+ offsetof(struct ethtool_rxfh_indir
, size
),
1118 if (copy_to_user(useraddr
+ offsetof(struct ethtool_rxfh_indir
, size
),
1119 &dev_size
, sizeof(dev_size
)))
1122 /* If the user buffer size is 0, this is just a query for the
1123 * device table size. Otherwise, if it's smaller than the
1124 * device table size it's an error.
1126 if (user_size
< dev_size
)
1127 return user_size
== 0 ? 0 : -EINVAL
;
1129 indir
= kcalloc(dev_size
, sizeof(indir
[0]), GFP_USER
);
1133 ret
= dev
->ethtool_ops
->get_rxfh(dev
, indir
, NULL
, NULL
);
1137 if (copy_to_user(useraddr
+
1138 offsetof(struct ethtool_rxfh_indir
, ring_index
[0]),
1139 indir
, dev_size
* sizeof(indir
[0])))
1147 static noinline_for_stack
int ethtool_set_rxfh_indir(struct net_device
*dev
,
1148 void __user
*useraddr
)
1150 struct ethtool_rxnfc rx_rings
;
1151 u32 user_size
, dev_size
, i
;
1153 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1155 u32 ringidx_offset
= offsetof(struct ethtool_rxfh_indir
, ring_index
[0]);
1157 if (!ops
->get_rxfh_indir_size
|| !ops
->set_rxfh
||
1161 dev_size
= ops
->get_rxfh_indir_size(dev
);
1165 if (copy_from_user(&user_size
,
1166 useraddr
+ offsetof(struct ethtool_rxfh_indir
, size
),
1170 if (user_size
!= 0 && user_size
!= dev_size
)
1173 indir
= kcalloc(dev_size
, sizeof(indir
[0]), GFP_USER
);
1177 rx_rings
.cmd
= ETHTOOL_GRXRINGS
;
1178 ret
= ops
->get_rxnfc(dev
, &rx_rings
, NULL
);
1182 if (user_size
== 0) {
1183 for (i
= 0; i
< dev_size
; i
++)
1184 indir
[i
] = ethtool_rxfh_indir_default(i
, rx_rings
.data
);
1186 ret
= ethtool_copy_validate_indir(indir
,
1187 useraddr
+ ringidx_offset
,
1194 ret
= ops
->set_rxfh(dev
, indir
, NULL
, ETH_RSS_HASH_NO_CHANGE
);
1198 /* indicate whether rxfh was set to default */
1200 dev
->priv_flags
&= ~IFF_RXFH_CONFIGURED
;
1202 dev
->priv_flags
|= IFF_RXFH_CONFIGURED
;
1209 static noinline_for_stack
int ethtool_get_rxfh(struct net_device
*dev
,
1210 void __user
*useraddr
)
1213 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1214 u32 user_indir_size
, user_key_size
;
1215 u32 dev_indir_size
= 0, dev_key_size
= 0;
1216 struct ethtool_rxfh rxfh
;
1227 if (ops
->get_rxfh_indir_size
)
1228 dev_indir_size
= ops
->get_rxfh_indir_size(dev
);
1229 if (ops
->get_rxfh_key_size
)
1230 dev_key_size
= ops
->get_rxfh_key_size(dev
);
1232 if (copy_from_user(&rxfh
, useraddr
, sizeof(rxfh
)))
1234 user_indir_size
= rxfh
.indir_size
;
1235 user_key_size
= rxfh
.key_size
;
1237 /* Check that reserved fields are 0 for now */
1238 if (rxfh
.rss_context
|| rxfh
.rsvd8
[0] || rxfh
.rsvd8
[1] ||
1239 rxfh
.rsvd8
[2] || rxfh
.rsvd32
)
1242 rxfh
.indir_size
= dev_indir_size
;
1243 rxfh
.key_size
= dev_key_size
;
1244 if (copy_to_user(useraddr
, &rxfh
, sizeof(rxfh
)))
1247 if ((user_indir_size
&& (user_indir_size
!= dev_indir_size
)) ||
1248 (user_key_size
&& (user_key_size
!= dev_key_size
)))
1251 indir_bytes
= user_indir_size
* sizeof(indir
[0]);
1252 total_size
= indir_bytes
+ user_key_size
;
1253 rss_config
= kzalloc(total_size
, GFP_USER
);
1257 if (user_indir_size
)
1258 indir
= (u32
*)rss_config
;
1261 hkey
= rss_config
+ indir_bytes
;
1263 ret
= dev
->ethtool_ops
->get_rxfh(dev
, indir
, hkey
, &dev_hfunc
);
1267 if (copy_to_user(useraddr
+ offsetof(struct ethtool_rxfh
, hfunc
),
1268 &dev_hfunc
, sizeof(rxfh
.hfunc
))) {
1270 } else if (copy_to_user(useraddr
+
1271 offsetof(struct ethtool_rxfh
, rss_config
[0]),
1272 rss_config
, total_size
)) {
1281 static noinline_for_stack
int ethtool_set_rxfh(struct net_device
*dev
,
1282 void __user
*useraddr
)
1285 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1286 struct ethtool_rxnfc rx_rings
;
1287 struct ethtool_rxfh rxfh
;
1288 u32 dev_indir_size
= 0, dev_key_size
= 0, i
;
1289 u32
*indir
= NULL
, indir_bytes
= 0;
1292 u32 rss_cfg_offset
= offsetof(struct ethtool_rxfh
, rss_config
[0]);
1294 if (!ops
->get_rxnfc
|| !ops
->set_rxfh
)
1297 if (ops
->get_rxfh_indir_size
)
1298 dev_indir_size
= ops
->get_rxfh_indir_size(dev
);
1299 if (ops
->get_rxfh_key_size
)
1300 dev_key_size
= ops
->get_rxfh_key_size(dev
);
1302 if (copy_from_user(&rxfh
, useraddr
, sizeof(rxfh
)))
1305 /* Check that reserved fields are 0 for now */
1306 if (rxfh
.rss_context
|| rxfh
.rsvd8
[0] || rxfh
.rsvd8
[1] ||
1307 rxfh
.rsvd8
[2] || rxfh
.rsvd32
)
1310 /* If either indir, hash key or function is valid, proceed further.
1311 * Must request at least one change: indir size, hash key or function.
1313 if ((rxfh
.indir_size
&&
1314 rxfh
.indir_size
!= ETH_RXFH_INDIR_NO_CHANGE
&&
1315 rxfh
.indir_size
!= dev_indir_size
) ||
1316 (rxfh
.key_size
&& (rxfh
.key_size
!= dev_key_size
)) ||
1317 (rxfh
.indir_size
== ETH_RXFH_INDIR_NO_CHANGE
&&
1318 rxfh
.key_size
== 0 && rxfh
.hfunc
== ETH_RSS_HASH_NO_CHANGE
))
1321 if (rxfh
.indir_size
!= ETH_RXFH_INDIR_NO_CHANGE
)
1322 indir_bytes
= dev_indir_size
* sizeof(indir
[0]);
1324 rss_config
= kzalloc(indir_bytes
+ rxfh
.key_size
, GFP_USER
);
1328 rx_rings
.cmd
= ETHTOOL_GRXRINGS
;
1329 ret
= ops
->get_rxnfc(dev
, &rx_rings
, NULL
);
1333 /* rxfh.indir_size == 0 means reset the indir table to default.
1334 * rxfh.indir_size == ETH_RXFH_INDIR_NO_CHANGE means leave it unchanged.
1336 if (rxfh
.indir_size
&&
1337 rxfh
.indir_size
!= ETH_RXFH_INDIR_NO_CHANGE
) {
1338 indir
= (u32
*)rss_config
;
1339 ret
= ethtool_copy_validate_indir(indir
,
1340 useraddr
+ rss_cfg_offset
,
1345 } else if (rxfh
.indir_size
== 0) {
1346 indir
= (u32
*)rss_config
;
1347 for (i
= 0; i
< dev_indir_size
; i
++)
1348 indir
[i
] = ethtool_rxfh_indir_default(i
, rx_rings
.data
);
1351 if (rxfh
.key_size
) {
1352 hkey
= rss_config
+ indir_bytes
;
1353 if (copy_from_user(hkey
,
1354 useraddr
+ rss_cfg_offset
+ indir_bytes
,
1361 ret
= ops
->set_rxfh(dev
, indir
, hkey
, rxfh
.hfunc
);
1365 /* indicate whether rxfh was set to default */
1366 if (rxfh
.indir_size
== 0)
1367 dev
->priv_flags
&= ~IFF_RXFH_CONFIGURED
;
1368 else if (rxfh
.indir_size
!= ETH_RXFH_INDIR_NO_CHANGE
)
1369 dev
->priv_flags
|= IFF_RXFH_CONFIGURED
;
1376 static int ethtool_get_regs(struct net_device
*dev
, char __user
*useraddr
)
1378 struct ethtool_regs regs
;
1379 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1383 if (!ops
->get_regs
|| !ops
->get_regs_len
)
1386 if (copy_from_user(®s
, useraddr
, sizeof(regs
)))
1389 reglen
= ops
->get_regs_len(dev
);
1390 if (regs
.len
> reglen
)
1393 regbuf
= vzalloc(reglen
);
1394 if (reglen
&& !regbuf
)
1397 ops
->get_regs(dev
, ®s
, regbuf
);
1400 if (copy_to_user(useraddr
, ®s
, sizeof(regs
)))
1402 useraddr
+= offsetof(struct ethtool_regs
, data
);
1403 if (regbuf
&& copy_to_user(useraddr
, regbuf
, regs
.len
))
1412 static int ethtool_reset(struct net_device
*dev
, char __user
*useraddr
)
1414 struct ethtool_value reset
;
1417 if (!dev
->ethtool_ops
->reset
)
1420 if (copy_from_user(&reset
, useraddr
, sizeof(reset
)))
1423 ret
= dev
->ethtool_ops
->reset(dev
, &reset
.data
);
1427 if (copy_to_user(useraddr
, &reset
, sizeof(reset
)))
1432 static int ethtool_get_wol(struct net_device
*dev
, char __user
*useraddr
)
1434 struct ethtool_wolinfo wol
= { .cmd
= ETHTOOL_GWOL
};
1436 if (!dev
->ethtool_ops
->get_wol
)
1439 dev
->ethtool_ops
->get_wol(dev
, &wol
);
1441 if (copy_to_user(useraddr
, &wol
, sizeof(wol
)))
1446 static int ethtool_set_wol(struct net_device
*dev
, char __user
*useraddr
)
1448 struct ethtool_wolinfo wol
;
1450 if (!dev
->ethtool_ops
->set_wol
)
1453 if (copy_from_user(&wol
, useraddr
, sizeof(wol
)))
1456 return dev
->ethtool_ops
->set_wol(dev
, &wol
);
1459 static int ethtool_get_eee(struct net_device
*dev
, char __user
*useraddr
)
1461 struct ethtool_eee edata
;
1464 if (!dev
->ethtool_ops
->get_eee
)
1467 memset(&edata
, 0, sizeof(struct ethtool_eee
));
1468 edata
.cmd
= ETHTOOL_GEEE
;
1469 rc
= dev
->ethtool_ops
->get_eee(dev
, &edata
);
1474 if (copy_to_user(useraddr
, &edata
, sizeof(edata
)))
1480 static int ethtool_set_eee(struct net_device
*dev
, char __user
*useraddr
)
1482 struct ethtool_eee edata
;
1484 if (!dev
->ethtool_ops
->set_eee
)
1487 if (copy_from_user(&edata
, useraddr
, sizeof(edata
)))
1490 return dev
->ethtool_ops
->set_eee(dev
, &edata
);
1493 static int ethtool_nway_reset(struct net_device
*dev
)
1495 if (!dev
->ethtool_ops
->nway_reset
)
1498 return dev
->ethtool_ops
->nway_reset(dev
);
1501 static int ethtool_get_link(struct net_device
*dev
, char __user
*useraddr
)
1503 struct ethtool_value edata
= { .cmd
= ETHTOOL_GLINK
};
1505 if (!dev
->ethtool_ops
->get_link
)
1508 edata
.data
= netif_running(dev
) && dev
->ethtool_ops
->get_link(dev
);
1510 if (copy_to_user(useraddr
, &edata
, sizeof(edata
)))
1515 static int ethtool_get_any_eeprom(struct net_device
*dev
, void __user
*useraddr
,
1516 int (*getter
)(struct net_device
*,
1517 struct ethtool_eeprom
*, u8
*),
1520 struct ethtool_eeprom eeprom
;
1521 void __user
*userbuf
= useraddr
+ sizeof(eeprom
);
1522 u32 bytes_remaining
;
1526 if (copy_from_user(&eeprom
, useraddr
, sizeof(eeprom
)))
1529 /* Check for wrap and zero */
1530 if (eeprom
.offset
+ eeprom
.len
<= eeprom
.offset
)
1533 /* Check for exceeding total eeprom len */
1534 if (eeprom
.offset
+ eeprom
.len
> total_len
)
1537 data
= kmalloc(PAGE_SIZE
, GFP_USER
);
1541 bytes_remaining
= eeprom
.len
;
1542 while (bytes_remaining
> 0) {
1543 eeprom
.len
= min(bytes_remaining
, (u32
)PAGE_SIZE
);
1545 ret
= getter(dev
, &eeprom
, data
);
1548 if (copy_to_user(userbuf
, data
, eeprom
.len
)) {
1552 userbuf
+= eeprom
.len
;
1553 eeprom
.offset
+= eeprom
.len
;
1554 bytes_remaining
-= eeprom
.len
;
1557 eeprom
.len
= userbuf
- (useraddr
+ sizeof(eeprom
));
1558 eeprom
.offset
-= eeprom
.len
;
1559 if (copy_to_user(useraddr
, &eeprom
, sizeof(eeprom
)))
1566 static int ethtool_get_eeprom(struct net_device
*dev
, void __user
*useraddr
)
1568 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1570 if (!ops
->get_eeprom
|| !ops
->get_eeprom_len
||
1571 !ops
->get_eeprom_len(dev
))
1574 return ethtool_get_any_eeprom(dev
, useraddr
, ops
->get_eeprom
,
1575 ops
->get_eeprom_len(dev
));
1578 static int ethtool_set_eeprom(struct net_device
*dev
, void __user
*useraddr
)
1580 struct ethtool_eeprom eeprom
;
1581 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1582 void __user
*userbuf
= useraddr
+ sizeof(eeprom
);
1583 u32 bytes_remaining
;
1587 if (!ops
->set_eeprom
|| !ops
->get_eeprom_len
||
1588 !ops
->get_eeprom_len(dev
))
1591 if (copy_from_user(&eeprom
, useraddr
, sizeof(eeprom
)))
1594 /* Check for wrap and zero */
1595 if (eeprom
.offset
+ eeprom
.len
<= eeprom
.offset
)
1598 /* Check for exceeding total eeprom len */
1599 if (eeprom
.offset
+ eeprom
.len
> ops
->get_eeprom_len(dev
))
1602 data
= kmalloc(PAGE_SIZE
, GFP_USER
);
1606 bytes_remaining
= eeprom
.len
;
1607 while (bytes_remaining
> 0) {
1608 eeprom
.len
= min(bytes_remaining
, (u32
)PAGE_SIZE
);
1610 if (copy_from_user(data
, userbuf
, eeprom
.len
)) {
1614 ret
= ops
->set_eeprom(dev
, &eeprom
, data
);
1617 userbuf
+= eeprom
.len
;
1618 eeprom
.offset
+= eeprom
.len
;
1619 bytes_remaining
-= eeprom
.len
;
1626 static noinline_for_stack
int ethtool_get_coalesce(struct net_device
*dev
,
1627 void __user
*useraddr
)
1629 struct ethtool_coalesce coalesce
= { .cmd
= ETHTOOL_GCOALESCE
};
1631 if (!dev
->ethtool_ops
->get_coalesce
)
1634 dev
->ethtool_ops
->get_coalesce(dev
, &coalesce
);
1636 if (copy_to_user(useraddr
, &coalesce
, sizeof(coalesce
)))
1641 static noinline_for_stack
int ethtool_set_coalesce(struct net_device
*dev
,
1642 void __user
*useraddr
)
1644 struct ethtool_coalesce coalesce
;
1646 if (!dev
->ethtool_ops
->set_coalesce
)
1649 if (copy_from_user(&coalesce
, useraddr
, sizeof(coalesce
)))
1652 return dev
->ethtool_ops
->set_coalesce(dev
, &coalesce
);
1655 static int ethtool_get_ringparam(struct net_device
*dev
, void __user
*useraddr
)
1657 struct ethtool_ringparam ringparam
= { .cmd
= ETHTOOL_GRINGPARAM
};
1659 if (!dev
->ethtool_ops
->get_ringparam
)
1662 dev
->ethtool_ops
->get_ringparam(dev
, &ringparam
);
1664 if (copy_to_user(useraddr
, &ringparam
, sizeof(ringparam
)))
1669 static int ethtool_set_ringparam(struct net_device
*dev
, void __user
*useraddr
)
1671 struct ethtool_ringparam ringparam
;
1673 if (!dev
->ethtool_ops
->set_ringparam
)
1676 if (copy_from_user(&ringparam
, useraddr
, sizeof(ringparam
)))
1679 return dev
->ethtool_ops
->set_ringparam(dev
, &ringparam
);
1682 static noinline_for_stack
int ethtool_get_channels(struct net_device
*dev
,
1683 void __user
*useraddr
)
1685 struct ethtool_channels channels
= { .cmd
= ETHTOOL_GCHANNELS
};
1687 if (!dev
->ethtool_ops
->get_channels
)
1690 dev
->ethtool_ops
->get_channels(dev
, &channels
);
1692 if (copy_to_user(useraddr
, &channels
, sizeof(channels
)))
1697 static noinline_for_stack
int ethtool_set_channels(struct net_device
*dev
,
1698 void __user
*useraddr
)
1700 struct ethtool_channels channels
, max
;
1701 u32 max_rx_in_use
= 0;
1703 if (!dev
->ethtool_ops
->set_channels
|| !dev
->ethtool_ops
->get_channels
)
1706 if (copy_from_user(&channels
, useraddr
, sizeof(channels
)))
1709 dev
->ethtool_ops
->get_channels(dev
, &max
);
1711 /* ensure new counts are within the maximums */
1712 if ((channels
.rx_count
> max
.max_rx
) ||
1713 (channels
.tx_count
> max
.max_tx
) ||
1714 (channels
.combined_count
> max
.max_combined
) ||
1715 (channels
.other_count
> max
.max_other
))
1718 /* ensure the new Rx count fits within the configured Rx flow
1719 * indirection table settings */
1720 if (netif_is_rxfh_configured(dev
) &&
1721 !ethtool_get_max_rxfh_channel(dev
, &max_rx_in_use
) &&
1722 (channels
.combined_count
+ channels
.rx_count
) <= max_rx_in_use
)
1725 return dev
->ethtool_ops
->set_channels(dev
, &channels
);
1728 static int ethtool_get_pauseparam(struct net_device
*dev
, void __user
*useraddr
)
1730 struct ethtool_pauseparam pauseparam
= { ETHTOOL_GPAUSEPARAM
};
1732 if (!dev
->ethtool_ops
->get_pauseparam
)
1735 dev
->ethtool_ops
->get_pauseparam(dev
, &pauseparam
);
1737 if (copy_to_user(useraddr
, &pauseparam
, sizeof(pauseparam
)))
1742 static int ethtool_set_pauseparam(struct net_device
*dev
, void __user
*useraddr
)
1744 struct ethtool_pauseparam pauseparam
;
1746 if (!dev
->ethtool_ops
->set_pauseparam
)
1749 if (copy_from_user(&pauseparam
, useraddr
, sizeof(pauseparam
)))
1752 return dev
->ethtool_ops
->set_pauseparam(dev
, &pauseparam
);
1755 static int ethtool_self_test(struct net_device
*dev
, char __user
*useraddr
)
1757 struct ethtool_test test
;
1758 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1762 if (!ops
->self_test
|| !ops
->get_sset_count
)
1765 test_len
= ops
->get_sset_count(dev
, ETH_SS_TEST
);
1768 WARN_ON(test_len
== 0);
1770 if (copy_from_user(&test
, useraddr
, sizeof(test
)))
1773 test
.len
= test_len
;
1774 data
= kmalloc(test_len
* sizeof(u64
), GFP_USER
);
1778 ops
->self_test(dev
, &test
, data
);
1781 if (copy_to_user(useraddr
, &test
, sizeof(test
)))
1783 useraddr
+= sizeof(test
);
1784 if (copy_to_user(useraddr
, data
, test
.len
* sizeof(u64
)))
1793 static int ethtool_get_strings(struct net_device
*dev
, void __user
*useraddr
)
1795 struct ethtool_gstrings gstrings
;
1799 if (copy_from_user(&gstrings
, useraddr
, sizeof(gstrings
)))
1802 ret
= __ethtool_get_sset_count(dev
, gstrings
.string_set
);
1808 data
= kcalloc(gstrings
.len
, ETH_GSTRING_LEN
, GFP_USER
);
1812 __ethtool_get_strings(dev
, gstrings
.string_set
, data
);
1815 if (copy_to_user(useraddr
, &gstrings
, sizeof(gstrings
)))
1817 useraddr
+= sizeof(gstrings
);
1818 if (copy_to_user(useraddr
, data
, gstrings
.len
* ETH_GSTRING_LEN
))
1827 static int ethtool_phys_id(struct net_device
*dev
, void __user
*useraddr
)
1829 struct ethtool_value id
;
1831 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1834 if (!ops
->set_phys_id
)
1840 if (copy_from_user(&id
, useraddr
, sizeof(id
)))
1843 rc
= ops
->set_phys_id(dev
, ETHTOOL_ID_ACTIVE
);
1847 /* Drop the RTNL lock while waiting, but prevent reentry or
1848 * removal of the device.
1855 /* Driver will handle this itself */
1856 schedule_timeout_interruptible(
1857 id
.data
? (id
.data
* HZ
) : MAX_SCHEDULE_TIMEOUT
);
1859 /* Driver expects to be called at twice the frequency in rc */
1860 int n
= rc
* 2, i
, interval
= HZ
/ n
;
1862 /* Count down seconds */
1864 /* Count down iterations per second */
1868 rc
= ops
->set_phys_id(dev
,
1869 (i
& 1) ? ETHTOOL_ID_OFF
: ETHTOOL_ID_ON
);
1873 schedule_timeout_interruptible(interval
);
1874 } while (!signal_pending(current
) && --i
!= 0);
1875 } while (!signal_pending(current
) &&
1876 (id
.data
== 0 || --id
.data
!= 0));
1883 (void) ops
->set_phys_id(dev
, ETHTOOL_ID_INACTIVE
);
1887 static int ethtool_get_stats(struct net_device
*dev
, void __user
*useraddr
)
1889 struct ethtool_stats stats
;
1890 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
1894 if (!ops
->get_ethtool_stats
|| !ops
->get_sset_count
)
1897 n_stats
= ops
->get_sset_count(dev
, ETH_SS_STATS
);
1900 WARN_ON(n_stats
== 0);
1902 if (copy_from_user(&stats
, useraddr
, sizeof(stats
)))
1905 stats
.n_stats
= n_stats
;
1906 data
= kmalloc(n_stats
* sizeof(u64
), GFP_USER
);
1910 ops
->get_ethtool_stats(dev
, &stats
, data
);
1913 if (copy_to_user(useraddr
, &stats
, sizeof(stats
)))
1915 useraddr
+= sizeof(stats
);
1916 if (copy_to_user(useraddr
, data
, stats
.n_stats
* sizeof(u64
)))
1925 static int ethtool_get_phy_stats(struct net_device
*dev
, void __user
*useraddr
)
1927 struct ethtool_stats stats
;
1928 struct phy_device
*phydev
= dev
->phydev
;
1935 n_stats
= phy_get_sset_count(phydev
);
1939 WARN_ON(n_stats
== 0);
1941 if (copy_from_user(&stats
, useraddr
, sizeof(stats
)))
1944 stats
.n_stats
= n_stats
;
1945 data
= kmalloc_array(n_stats
, sizeof(u64
), GFP_USER
);
1949 mutex_lock(&phydev
->lock
);
1950 phydev
->drv
->get_stats(phydev
, &stats
, data
);
1951 mutex_unlock(&phydev
->lock
);
1954 if (copy_to_user(useraddr
, &stats
, sizeof(stats
)))
1956 useraddr
+= sizeof(stats
);
1957 if (copy_to_user(useraddr
, data
, stats
.n_stats
* sizeof(u64
)))
1966 static int ethtool_get_perm_addr(struct net_device
*dev
, void __user
*useraddr
)
1968 struct ethtool_perm_addr epaddr
;
1970 if (copy_from_user(&epaddr
, useraddr
, sizeof(epaddr
)))
1973 if (epaddr
.size
< dev
->addr_len
)
1975 epaddr
.size
= dev
->addr_len
;
1977 if (copy_to_user(useraddr
, &epaddr
, sizeof(epaddr
)))
1979 useraddr
+= sizeof(epaddr
);
1980 if (copy_to_user(useraddr
, dev
->perm_addr
, epaddr
.size
))
1985 static int ethtool_get_value(struct net_device
*dev
, char __user
*useraddr
,
1986 u32 cmd
, u32 (*actor
)(struct net_device
*))
1988 struct ethtool_value edata
= { .cmd
= cmd
};
1993 edata
.data
= actor(dev
);
1995 if (copy_to_user(useraddr
, &edata
, sizeof(edata
)))
2000 static int ethtool_set_value_void(struct net_device
*dev
, char __user
*useraddr
,
2001 void (*actor
)(struct net_device
*, u32
))
2003 struct ethtool_value edata
;
2008 if (copy_from_user(&edata
, useraddr
, sizeof(edata
)))
2011 actor(dev
, edata
.data
);
2015 static int ethtool_set_value(struct net_device
*dev
, char __user
*useraddr
,
2016 int (*actor
)(struct net_device
*, u32
))
2018 struct ethtool_value edata
;
2023 if (copy_from_user(&edata
, useraddr
, sizeof(edata
)))
2026 return actor(dev
, edata
.data
);
2029 static noinline_for_stack
int ethtool_flash_device(struct net_device
*dev
,
2030 char __user
*useraddr
)
2032 struct ethtool_flash efl
;
2034 if (copy_from_user(&efl
, useraddr
, sizeof(efl
)))
2037 if (!dev
->ethtool_ops
->flash_device
)
2040 efl
.data
[ETHTOOL_FLASH_MAX_FILENAME
- 1] = 0;
2042 return dev
->ethtool_ops
->flash_device(dev
, &efl
);
2045 static int ethtool_set_dump(struct net_device
*dev
,
2046 void __user
*useraddr
)
2048 struct ethtool_dump dump
;
2050 if (!dev
->ethtool_ops
->set_dump
)
2053 if (copy_from_user(&dump
, useraddr
, sizeof(dump
)))
2056 return dev
->ethtool_ops
->set_dump(dev
, &dump
);
2059 static int ethtool_get_dump_flag(struct net_device
*dev
,
2060 void __user
*useraddr
)
2063 struct ethtool_dump dump
;
2064 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
2066 if (!ops
->get_dump_flag
)
2069 if (copy_from_user(&dump
, useraddr
, sizeof(dump
)))
2072 ret
= ops
->get_dump_flag(dev
, &dump
);
2076 if (copy_to_user(useraddr
, &dump
, sizeof(dump
)))
2081 static int ethtool_get_dump_data(struct net_device
*dev
,
2082 void __user
*useraddr
)
2086 struct ethtool_dump dump
, tmp
;
2087 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
2090 if (!ops
->get_dump_data
|| !ops
->get_dump_flag
)
2093 if (copy_from_user(&dump
, useraddr
, sizeof(dump
)))
2096 memset(&tmp
, 0, sizeof(tmp
));
2097 tmp
.cmd
= ETHTOOL_GET_DUMP_FLAG
;
2098 ret
= ops
->get_dump_flag(dev
, &tmp
);
2102 len
= min(tmp
.len
, dump
.len
);
2106 /* Don't ever let the driver think there's more space available
2107 * than it requested with .get_dump_flag().
2111 /* Always allocate enough space to hold the whole thing so that the
2112 * driver does not need to check the length and bother with partial
2115 data
= vzalloc(tmp
.len
);
2118 ret
= ops
->get_dump_data(dev
, &dump
, data
);
2122 /* There are two sane possibilities:
2123 * 1. The driver's .get_dump_data() does not touch dump.len.
2124 * 2. Or it may set dump.len to how much it really writes, which
2125 * should be tmp.len (or len if it can do a partial dump).
2126 * In any case respond to userspace with the actual length of data
2129 WARN_ON(dump
.len
!= len
&& dump
.len
!= tmp
.len
);
2132 if (copy_to_user(useraddr
, &dump
, sizeof(dump
))) {
2136 useraddr
+= offsetof(struct ethtool_dump
, data
);
2137 if (copy_to_user(useraddr
, data
, len
))
2144 static int ethtool_get_ts_info(struct net_device
*dev
, void __user
*useraddr
)
2147 struct ethtool_ts_info info
;
2148 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
2149 struct phy_device
*phydev
= dev
->phydev
;
2151 memset(&info
, 0, sizeof(info
));
2152 info
.cmd
= ETHTOOL_GET_TS_INFO
;
2154 if (phydev
&& phydev
->drv
&& phydev
->drv
->ts_info
) {
2155 err
= phydev
->drv
->ts_info(phydev
, &info
);
2156 } else if (ops
->get_ts_info
) {
2157 err
= ops
->get_ts_info(dev
, &info
);
2159 info
.so_timestamping
=
2160 SOF_TIMESTAMPING_RX_SOFTWARE
|
2161 SOF_TIMESTAMPING_SOFTWARE
;
2162 info
.phc_index
= -1;
2168 if (copy_to_user(useraddr
, &info
, sizeof(info
)))
2174 static int __ethtool_get_module_info(struct net_device
*dev
,
2175 struct ethtool_modinfo
*modinfo
)
2177 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
2178 struct phy_device
*phydev
= dev
->phydev
;
2180 if (phydev
&& phydev
->drv
&& phydev
->drv
->module_info
)
2181 return phydev
->drv
->module_info(phydev
, modinfo
);
2183 if (ops
->get_module_info
)
2184 return ops
->get_module_info(dev
, modinfo
);
2189 static int ethtool_get_module_info(struct net_device
*dev
,
2190 void __user
*useraddr
)
2193 struct ethtool_modinfo modinfo
;
2195 if (copy_from_user(&modinfo
, useraddr
, sizeof(modinfo
)))
2198 ret
= __ethtool_get_module_info(dev
, &modinfo
);
2202 if (copy_to_user(useraddr
, &modinfo
, sizeof(modinfo
)))
2208 static int __ethtool_get_module_eeprom(struct net_device
*dev
,
2209 struct ethtool_eeprom
*ee
, u8
*data
)
2211 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
2212 struct phy_device
*phydev
= dev
->phydev
;
2214 if (phydev
&& phydev
->drv
&& phydev
->drv
->module_eeprom
)
2215 return phydev
->drv
->module_eeprom(phydev
, ee
, data
);
2217 if (ops
->get_module_eeprom
)
2218 return ops
->get_module_eeprom(dev
, ee
, data
);
2223 static int ethtool_get_module_eeprom(struct net_device
*dev
,
2224 void __user
*useraddr
)
2227 struct ethtool_modinfo modinfo
;
2229 ret
= __ethtool_get_module_info(dev
, &modinfo
);
2233 return ethtool_get_any_eeprom(dev
, useraddr
,
2234 __ethtool_get_module_eeprom
,
2235 modinfo
.eeprom_len
);
2238 static int ethtool_tunable_valid(const struct ethtool_tunable
*tuna
)
2241 case ETHTOOL_RX_COPYBREAK
:
2242 case ETHTOOL_TX_COPYBREAK
:
2243 if (tuna
->len
!= sizeof(u32
) ||
2244 tuna
->type_id
!= ETHTOOL_TUNABLE_U32
)
2254 static int ethtool_get_tunable(struct net_device
*dev
, void __user
*useraddr
)
2257 struct ethtool_tunable tuna
;
2258 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
2261 if (!ops
->get_tunable
)
2263 if (copy_from_user(&tuna
, useraddr
, sizeof(tuna
)))
2265 ret
= ethtool_tunable_valid(&tuna
);
2268 data
= kmalloc(tuna
.len
, GFP_USER
);
2271 ret
= ops
->get_tunable(dev
, &tuna
, data
);
2274 useraddr
+= sizeof(tuna
);
2276 if (copy_to_user(useraddr
, data
, tuna
.len
))
2285 static int ethtool_set_tunable(struct net_device
*dev
, void __user
*useraddr
)
2288 struct ethtool_tunable tuna
;
2289 const struct ethtool_ops
*ops
= dev
->ethtool_ops
;
2292 if (!ops
->set_tunable
)
2294 if (copy_from_user(&tuna
, useraddr
, sizeof(tuna
)))
2296 ret
= ethtool_tunable_valid(&tuna
);
2299 data
= kmalloc(tuna
.len
, GFP_USER
);
2302 useraddr
+= sizeof(tuna
);
2304 if (copy_from_user(data
, useraddr
, tuna
.len
))
2306 ret
= ops
->set_tunable(dev
, &tuna
, data
);
2313 static int ethtool_get_per_queue_coalesce(struct net_device
*dev
,
2314 void __user
*useraddr
,
2315 struct ethtool_per_queue_op
*per_queue_opt
)
2319 DECLARE_BITMAP(queue_mask
, MAX_NUM_QUEUE
);
2321 if (!dev
->ethtool_ops
->get_per_queue_coalesce
)
2324 useraddr
+= sizeof(*per_queue_opt
);
2326 bitmap_from_u32array(queue_mask
,
2328 per_queue_opt
->queue_mask
,
2329 DIV_ROUND_UP(MAX_NUM_QUEUE
, 32));
2331 for_each_set_bit(bit
, queue_mask
, MAX_NUM_QUEUE
) {
2332 struct ethtool_coalesce coalesce
= { .cmd
= ETHTOOL_GCOALESCE
};
2334 ret
= dev
->ethtool_ops
->get_per_queue_coalesce(dev
, bit
, &coalesce
);
2337 if (copy_to_user(useraddr
, &coalesce
, sizeof(coalesce
)))
2339 useraddr
+= sizeof(coalesce
);
2345 static int ethtool_set_per_queue_coalesce(struct net_device
*dev
,
2346 void __user
*useraddr
,
2347 struct ethtool_per_queue_op
*per_queue_opt
)
2352 struct ethtool_coalesce
*backup
= NULL
, *tmp
= NULL
;
2353 DECLARE_BITMAP(queue_mask
, MAX_NUM_QUEUE
);
2355 if ((!dev
->ethtool_ops
->set_per_queue_coalesce
) ||
2356 (!dev
->ethtool_ops
->get_per_queue_coalesce
))
2359 useraddr
+= sizeof(*per_queue_opt
);
2361 bitmap_from_u32array(queue_mask
,
2363 per_queue_opt
->queue_mask
,
2364 DIV_ROUND_UP(MAX_NUM_QUEUE
, 32));
2365 n_queue
= bitmap_weight(queue_mask
, MAX_NUM_QUEUE
);
2366 tmp
= backup
= kmalloc_array(n_queue
, sizeof(*backup
), GFP_KERNEL
);
2370 for_each_set_bit(bit
, queue_mask
, MAX_NUM_QUEUE
) {
2371 struct ethtool_coalesce coalesce
;
2373 ret
= dev
->ethtool_ops
->get_per_queue_coalesce(dev
, bit
, tmp
);
2379 if (copy_from_user(&coalesce
, useraddr
, sizeof(coalesce
))) {
2384 ret
= dev
->ethtool_ops
->set_per_queue_coalesce(dev
, bit
, &coalesce
);
2388 useraddr
+= sizeof(coalesce
);
2394 for_each_set_bit(i
, queue_mask
, bit
) {
2395 dev
->ethtool_ops
->set_per_queue_coalesce(dev
, i
, tmp
);
2404 static int ethtool_set_per_queue(struct net_device
*dev
, void __user
*useraddr
)
2406 struct ethtool_per_queue_op per_queue_opt
;
2408 if (copy_from_user(&per_queue_opt
, useraddr
, sizeof(per_queue_opt
)))
2411 switch (per_queue_opt
.sub_command
) {
2412 case ETHTOOL_GCOALESCE
:
2413 return ethtool_get_per_queue_coalesce(dev
, useraddr
, &per_queue_opt
);
2414 case ETHTOOL_SCOALESCE
:
2415 return ethtool_set_per_queue_coalesce(dev
, useraddr
, &per_queue_opt
);
2421 /* The main entry point in this file. Called from net/core/dev_ioctl.c */
2423 int dev_ethtool(struct net
*net
, struct ifreq
*ifr
)
2425 struct net_device
*dev
= __dev_get_by_name(net
, ifr
->ifr_name
);
2426 void __user
*useraddr
= ifr
->ifr_data
;
2427 u32 ethcmd
, sub_cmd
;
2429 netdev_features_t old_features
;
2431 if (!dev
|| !netif_device_present(dev
))
2434 if (copy_from_user(ðcmd
, useraddr
, sizeof(ethcmd
)))
2437 if (ethcmd
== ETHTOOL_PERQUEUE
) {
2438 if (copy_from_user(&sub_cmd
, useraddr
+ sizeof(ethcmd
), sizeof(sub_cmd
)))
2443 /* Allow some commands to be done by anyone */
2446 case ETHTOOL_GDRVINFO
:
2447 case ETHTOOL_GMSGLVL
:
2449 case ETHTOOL_GCOALESCE
:
2450 case ETHTOOL_GRINGPARAM
:
2451 case ETHTOOL_GPAUSEPARAM
:
2452 case ETHTOOL_GRXCSUM
:
2453 case ETHTOOL_GTXCSUM
:
2455 case ETHTOOL_GSSET_INFO
:
2456 case ETHTOOL_GSTRINGS
:
2457 case ETHTOOL_GSTATS
:
2458 case ETHTOOL_GPHYSTATS
:
2460 case ETHTOOL_GPERMADDR
:
2464 case ETHTOOL_GFLAGS
:
2465 case ETHTOOL_GPFLAGS
:
2467 case ETHTOOL_GRXRINGS
:
2468 case ETHTOOL_GRXCLSRLCNT
:
2469 case ETHTOOL_GRXCLSRULE
:
2470 case ETHTOOL_GRXCLSRLALL
:
2471 case ETHTOOL_GRXFHINDIR
:
2473 case ETHTOOL_GFEATURES
:
2474 case ETHTOOL_GCHANNELS
:
2475 case ETHTOOL_GET_TS_INFO
:
2477 case ETHTOOL_GTUNABLE
:
2480 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
2484 if (dev
->ethtool_ops
->begin
) {
2485 rc
= dev
->ethtool_ops
->begin(dev
);
2489 old_features
= dev
->features
;
2493 rc
= ethtool_get_settings(dev
, useraddr
);
2496 rc
= ethtool_set_settings(dev
, useraddr
);
2498 case ETHTOOL_GDRVINFO
:
2499 rc
= ethtool_get_drvinfo(dev
, useraddr
);
2502 rc
= ethtool_get_regs(dev
, useraddr
);
2505 rc
= ethtool_get_wol(dev
, useraddr
);
2508 rc
= ethtool_set_wol(dev
, useraddr
);
2510 case ETHTOOL_GMSGLVL
:
2511 rc
= ethtool_get_value(dev
, useraddr
, ethcmd
,
2512 dev
->ethtool_ops
->get_msglevel
);
2514 case ETHTOOL_SMSGLVL
:
2515 rc
= ethtool_set_value_void(dev
, useraddr
,
2516 dev
->ethtool_ops
->set_msglevel
);
2519 rc
= ethtool_get_eee(dev
, useraddr
);
2522 rc
= ethtool_set_eee(dev
, useraddr
);
2524 case ETHTOOL_NWAY_RST
:
2525 rc
= ethtool_nway_reset(dev
);
2528 rc
= ethtool_get_link(dev
, useraddr
);
2530 case ETHTOOL_GEEPROM
:
2531 rc
= ethtool_get_eeprom(dev
, useraddr
);
2533 case ETHTOOL_SEEPROM
:
2534 rc
= ethtool_set_eeprom(dev
, useraddr
);
2536 case ETHTOOL_GCOALESCE
:
2537 rc
= ethtool_get_coalesce(dev
, useraddr
);
2539 case ETHTOOL_SCOALESCE
:
2540 rc
= ethtool_set_coalesce(dev
, useraddr
);
2542 case ETHTOOL_GRINGPARAM
:
2543 rc
= ethtool_get_ringparam(dev
, useraddr
);
2545 case ETHTOOL_SRINGPARAM
:
2546 rc
= ethtool_set_ringparam(dev
, useraddr
);
2548 case ETHTOOL_GPAUSEPARAM
:
2549 rc
= ethtool_get_pauseparam(dev
, useraddr
);
2551 case ETHTOOL_SPAUSEPARAM
:
2552 rc
= ethtool_set_pauseparam(dev
, useraddr
);
2555 rc
= ethtool_self_test(dev
, useraddr
);
2557 case ETHTOOL_GSTRINGS
:
2558 rc
= ethtool_get_strings(dev
, useraddr
);
2560 case ETHTOOL_PHYS_ID
:
2561 rc
= ethtool_phys_id(dev
, useraddr
);
2563 case ETHTOOL_GSTATS
:
2564 rc
= ethtool_get_stats(dev
, useraddr
);
2566 case ETHTOOL_GPERMADDR
:
2567 rc
= ethtool_get_perm_addr(dev
, useraddr
);
2569 case ETHTOOL_GFLAGS
:
2570 rc
= ethtool_get_value(dev
, useraddr
, ethcmd
,
2571 __ethtool_get_flags
);
2573 case ETHTOOL_SFLAGS
:
2574 rc
= ethtool_set_value(dev
, useraddr
, __ethtool_set_flags
);
2576 case ETHTOOL_GPFLAGS
:
2577 rc
= ethtool_get_value(dev
, useraddr
, ethcmd
,
2578 dev
->ethtool_ops
->get_priv_flags
);
2580 case ETHTOOL_SPFLAGS
:
2581 rc
= ethtool_set_value(dev
, useraddr
,
2582 dev
->ethtool_ops
->set_priv_flags
);
2585 case ETHTOOL_GRXRINGS
:
2586 case ETHTOOL_GRXCLSRLCNT
:
2587 case ETHTOOL_GRXCLSRULE
:
2588 case ETHTOOL_GRXCLSRLALL
:
2589 rc
= ethtool_get_rxnfc(dev
, ethcmd
, useraddr
);
2592 case ETHTOOL_SRXCLSRLDEL
:
2593 case ETHTOOL_SRXCLSRLINS
:
2594 rc
= ethtool_set_rxnfc(dev
, ethcmd
, useraddr
);
2596 case ETHTOOL_FLASHDEV
:
2597 rc
= ethtool_flash_device(dev
, useraddr
);
2600 rc
= ethtool_reset(dev
, useraddr
);
2602 case ETHTOOL_GSSET_INFO
:
2603 rc
= ethtool_get_sset_info(dev
, useraddr
);
2605 case ETHTOOL_GRXFHINDIR
:
2606 rc
= ethtool_get_rxfh_indir(dev
, useraddr
);
2608 case ETHTOOL_SRXFHINDIR
:
2609 rc
= ethtool_set_rxfh_indir(dev
, useraddr
);
2612 rc
= ethtool_get_rxfh(dev
, useraddr
);
2615 rc
= ethtool_set_rxfh(dev
, useraddr
);
2617 case ETHTOOL_GFEATURES
:
2618 rc
= ethtool_get_features(dev
, useraddr
);
2620 case ETHTOOL_SFEATURES
:
2621 rc
= ethtool_set_features(dev
, useraddr
);
2623 case ETHTOOL_GTXCSUM
:
2624 case ETHTOOL_GRXCSUM
:
2630 rc
= ethtool_get_one_feature(dev
, useraddr
, ethcmd
);
2632 case ETHTOOL_STXCSUM
:
2633 case ETHTOOL_SRXCSUM
:
2639 rc
= ethtool_set_one_feature(dev
, useraddr
, ethcmd
);
2641 case ETHTOOL_GCHANNELS
:
2642 rc
= ethtool_get_channels(dev
, useraddr
);
2644 case ETHTOOL_SCHANNELS
:
2645 rc
= ethtool_set_channels(dev
, useraddr
);
2647 case ETHTOOL_SET_DUMP
:
2648 rc
= ethtool_set_dump(dev
, useraddr
);
2650 case ETHTOOL_GET_DUMP_FLAG
:
2651 rc
= ethtool_get_dump_flag(dev
, useraddr
);
2653 case ETHTOOL_GET_DUMP_DATA
:
2654 rc
= ethtool_get_dump_data(dev
, useraddr
);
2656 case ETHTOOL_GET_TS_INFO
:
2657 rc
= ethtool_get_ts_info(dev
, useraddr
);
2659 case ETHTOOL_GMODULEINFO
:
2660 rc
= ethtool_get_module_info(dev
, useraddr
);
2662 case ETHTOOL_GMODULEEEPROM
:
2663 rc
= ethtool_get_module_eeprom(dev
, useraddr
);
2665 case ETHTOOL_GTUNABLE
:
2666 rc
= ethtool_get_tunable(dev
, useraddr
);
2668 case ETHTOOL_STUNABLE
:
2669 rc
= ethtool_set_tunable(dev
, useraddr
);
2671 case ETHTOOL_GPHYSTATS
:
2672 rc
= ethtool_get_phy_stats(dev
, useraddr
);
2674 case ETHTOOL_PERQUEUE
:
2675 rc
= ethtool_set_per_queue(dev
, useraddr
);
2677 case ETHTOOL_GLINKSETTINGS
:
2678 rc
= ethtool_get_link_ksettings(dev
, useraddr
);
2680 case ETHTOOL_SLINKSETTINGS
:
2681 rc
= ethtool_set_link_ksettings(dev
, useraddr
);
2687 if (dev
->ethtool_ops
->complete
)
2688 dev
->ethtool_ops
->complete(dev
);
2690 if (old_features
!= dev
->features
)
2691 netdev_features_change(dev
);