2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* net/core/ethtool.c - Ethtool ioctl handler
|
|
|
|
|
* Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>
|
|
|
|
|
*
|
|
|
|
|
* This file is where we call all the ethtool_ops commands to get
|
2007-07-31 21:00:02 +00:00
|
|
|
* the information ethtool needs.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-07-31 21:00:02 +00:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
|
* (at your option) any later version.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/types.h>
|
2006-01-11 20:17:47 +00:00
|
|
|
#include <linux/capability.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
|
#include <linux/netdevice.h>
|
2012-04-03 22:59:17 +00:00
|
|
|
#include <linux/net_tstamp.h>
|
|
|
|
|
#include <linux/phy.h>
|
ethtool: Add direct access to ops->get_sset_count
On 03/04/2010 09:26 AM, Ben Hutchings wrote:
> On Thu, 2010-03-04 at 00:51 -0800, Jeff Kirsher wrote:
>> From: Jeff Garzik<jgarzik@redhat.com>
>>
>> This patch is an alternative approach for accessing string
>> counts, vs. the drvinfo indirect approach. This way the drvinfo
>> space doesn't run out, and we don't break ABI later.
> [...]
>> --- a/net/core/ethtool.c
>> +++ b/net/core/ethtool.c
>> @@ -214,6 +214,10 @@ static noinline int ethtool_get_drvinfo(struct net_device *dev, void __user *use
>> info.cmd = ETHTOOL_GDRVINFO;
>> ops->get_drvinfo(dev,&info);
>>
>> + /*
>> + * this method of obtaining string set info is deprecated;
>> + * consider using ETHTOOL_GSSET_INFO instead
>> + */
>
> This comment belongs on the interface (ethtool.h) not the
> implementation.
Debatable -- the current comment is located at the callsite of
ops->get_sset_count(), which is where an implementor might think to add
a new call. Not all the numeric fields in ethtool_drvinfo are obtained
from ->get_sset_count().
Hence the "some" in the attached patch to include/linux/ethtool.h,
addressing your comment.
> [...]
>> +static noinline int ethtool_get_sset_info(struct net_device *dev,
>> + void __user *useraddr)
>> +{
> [...]
>> + /* calculate size of return buffer */
>> + for (i = 0; i< 64; i++)
>> + if (sset_mask& (1ULL<< i))
>> + n_bits++;
> [...]
>
> We have a function for this:
>
> n_bits = hweight64(sset_mask);
Agreed.
I've attached a follow-up patch, which should enable my/Jeff's kernel
patch to be applied, followed by this one.
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-03-04 08:21:53 +00:00
|
|
|
#include <linux/bitops.h>
|
2010-04-08 04:54:42 +00:00
|
|
|
#include <linux/uaccess.h>
|
2010-09-21 23:12:11 +00:00
|
|
|
#include <linux/vmalloc.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-04-01 23:35:15 +00:00
|
|
|
#include <linux/rtnetlink.h>
|
|
|
|
|
#include <linux/sched.h>
|
2014-11-16 14:23:05 +00:00
|
|
|
#include <linux/net.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-09 14:24:36 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Some useful ethtool_ops methods that're device independent.
|
|
|
|
|
* If we find that all drivers want to do the same thing here,
|
|
|
|
|
* we can turn these into dev_() function calls.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
u32 ethtool_op_get_link(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
return netif_carrier_ok(dev) ? 1 : 0;
|
|
|
|
|
}
|
2010-04-08 04:54:42 +00:00
|
|
|
EXPORT_SYMBOL(ethtool_op_get_link);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-03 22:59:22 +00:00
|
|
|
int ethtool_op_get_ts_info(struct net_device *dev, struct ethtool_ts_info *info)
|
|
|
|
|
{
|
|
|
|
|
info->so_timestamping =
|
|
|
|
|
SOF_TIMESTAMPING_TX_SOFTWARE |
|
|
|
|
|
SOF_TIMESTAMPING_RX_SOFTWARE |
|
|
|
|
|
SOF_TIMESTAMPING_SOFTWARE;
|
|
|
|
|
info->phc_index = -1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(ethtool_op_get_ts_info);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Handlers for each ethtool command */
|
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
#define ETHTOOL_DEV_FEATURE_WORDS ((NETDEV_FEATURE_COUNT + 31) / 32)
|
2011-02-15 16:59:17 +00:00
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
static const char netdev_features_strings[NETDEV_FEATURE_COUNT][ETH_GSTRING_LEN] = {
|
|
|
|
|
[NETIF_F_SG_BIT] = "tx-scatter-gather",
|
|
|
|
|
[NETIF_F_IP_CSUM_BIT] = "tx-checksum-ipv4",
|
|
|
|
|
[NETIF_F_HW_CSUM_BIT] = "tx-checksum-ip-generic",
|
|
|
|
|
[NETIF_F_IPV6_CSUM_BIT] = "tx-checksum-ipv6",
|
|
|
|
|
[NETIF_F_HIGHDMA_BIT] = "highdma",
|
|
|
|
|
[NETIF_F_FRAGLIST_BIT] = "tx-scatter-gather-fraglist",
|
2013-06-17 02:28:03 +00:00
|
|
|
[NETIF_F_HW_VLAN_CTAG_TX_BIT] = "tx-vlan-hw-insert",
|
2011-11-15 15:29:55 +00:00
|
|
|
|
2013-06-17 02:28:03 +00:00
|
|
|
[NETIF_F_HW_VLAN_CTAG_RX_BIT] = "rx-vlan-hw-parse",
|
|
|
|
|
[NETIF_F_HW_VLAN_CTAG_FILTER_BIT] = "rx-vlan-filter",
|
2013-04-19 20:08:23 +00:00
|
|
|
[NETIF_F_HW_VLAN_STAG_TX_BIT] = "tx-vlan-stag-hw-insert",
|
|
|
|
|
[NETIF_F_HW_VLAN_STAG_RX_BIT] = "rx-vlan-stag-hw-parse",
|
|
|
|
|
[NETIF_F_HW_VLAN_STAG_FILTER_BIT] = "rx-vlan-stag-filter",
|
2011-11-15 15:29:55 +00:00
|
|
|
[NETIF_F_VLAN_CHALLENGED_BIT] = "vlan-challenged",
|
|
|
|
|
[NETIF_F_GSO_BIT] = "tx-generic-segmentation",
|
|
|
|
|
[NETIF_F_LLTX_BIT] = "tx-lockless",
|
|
|
|
|
[NETIF_F_NETNS_LOCAL_BIT] = "netns-local",
|
|
|
|
|
[NETIF_F_GRO_BIT] = "rx-gro",
|
|
|
|
|
[NETIF_F_LRO_BIT] = "rx-lro",
|
|
|
|
|
|
|
|
|
|
[NETIF_F_TSO_BIT] = "tx-tcp-segmentation",
|
|
|
|
|
[NETIF_F_UFO_BIT] = "tx-udp-fragmentation",
|
|
|
|
|
[NETIF_F_GSO_ROBUST_BIT] = "tx-gso-robust",
|
|
|
|
|
[NETIF_F_TSO_ECN_BIT] = "tx-tcp-ecn-segmentation",
|
|
|
|
|
[NETIF_F_TSO6_BIT] = "tx-tcp6-segmentation",
|
|
|
|
|
[NETIF_F_FSO_BIT] = "tx-fcoe-segmentation",
|
2013-02-14 14:02:41 +00:00
|
|
|
[NETIF_F_GSO_GRE_BIT] = "tx-gre-segmentation",
|
2013-10-19 18:42:57 +00:00
|
|
|
[NETIF_F_GSO_IPIP_BIT] = "tx-ipip-segmentation",
|
2013-10-21 03:47:30 +00:00
|
|
|
[NETIF_F_GSO_SIT_BIT] = "tx-sit-segmentation",
|
2013-03-07 13:21:51 +00:00
|
|
|
[NETIF_F_GSO_UDP_TUNNEL_BIT] = "tx-udp_tnl-segmentation",
|
2011-11-15 15:29:55 +00:00
|
|
|
|
|
|
|
|
[NETIF_F_FCOE_CRC_BIT] = "tx-checksum-fcoe-crc",
|
2015-12-14 19:19:41 +00:00
|
|
|
[NETIF_F_SCTP_CRC_BIT] = "tx-checksum-sctp",
|
2011-11-15 15:29:55 +00:00
|
|
|
[NETIF_F_FCOE_MTU_BIT] = "fcoe-mtu",
|
|
|
|
|
[NETIF_F_NTUPLE_BIT] = "rx-ntuple-filter",
|
|
|
|
|
[NETIF_F_RXHASH_BIT] = "rx-hashing",
|
|
|
|
|
[NETIF_F_RXCSUM_BIT] = "rx-checksum",
|
|
|
|
|
[NETIF_F_NOCACHE_COPY_BIT] = "tx-nocache-copy",
|
|
|
|
|
[NETIF_F_LOOPBACK_BIT] = "loopback",
|
2012-02-11 15:39:14 +00:00
|
|
|
[NETIF_F_RXFCS_BIT] = "rx-fcs",
|
2012-02-11 15:39:45 +00:00
|
|
|
[NETIF_F_RXALL_BIT] = "rx-all",
|
2013-11-06 17:54:46 +00:00
|
|
|
[NETIF_F_HW_L2FW_DOFFLOAD_BIT] = "l2-fwd-offload",
|
2014-04-02 21:09:31 +00:00
|
|
|
[NETIF_F_BUSY_POLL_BIT] = "busy-poll",
|
2016-02-17 05:17:37 +00:00
|
|
|
[NETIF_F_HW_TC_BIT] = "hw-tc-offload",
|
2011-11-15 15:29:55 +00:00
|
|
|
};
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
static const char
|
|
|
|
|
rss_hash_func_strings[ETH_RSS_HASH_FUNCS_COUNT][ETH_GSTRING_LEN] = {
|
|
|
|
|
[ETH_RSS_HASH_TOP_BIT] = "toeplitz",
|
|
|
|
|
[ETH_RSS_HASH_XOR_BIT] = "xor",
|
|
|
|
|
};
|
|
|
|
|
|
2015-06-11 07:28:16 +00:00
|
|
|
static const char
|
|
|
|
|
tunable_strings[__ETHTOOL_TUNABLE_COUNT][ETH_GSTRING_LEN] = {
|
|
|
|
|
[ETHTOOL_ID_UNSPEC] = "Unspec",
|
|
|
|
|
[ETHTOOL_RX_COPYBREAK] = "rx-copybreak",
|
|
|
|
|
[ETHTOOL_TX_COPYBREAK] = "tx-copybreak",
|
|
|
|
|
};
|
|
|
|
|
|
2011-02-15 16:59:17 +00:00
|
|
|
static int ethtool_get_features(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_gfeatures cmd = {
|
|
|
|
|
.cmd = ETHTOOL_GFEATURES,
|
|
|
|
|
.size = ETHTOOL_DEV_FEATURE_WORDS,
|
|
|
|
|
};
|
2011-11-15 15:29:55 +00:00
|
|
|
struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS];
|
2011-02-15 16:59:17 +00:00
|
|
|
u32 __user *sizeaddr;
|
|
|
|
|
u32 copy_size;
|
2011-11-15 15:29:55 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* in case feature bits run out again */
|
2011-11-16 14:32:03 +00:00
|
|
|
BUILD_BUG_ON(ETHTOOL_DEV_FEATURE_WORDS * sizeof(u32) > sizeof(netdev_features_t));
|
2011-11-15 15:29:55 +00:00
|
|
|
|
|
|
|
|
for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; ++i) {
|
2011-11-16 14:32:03 +00:00
|
|
|
features[i].available = (u32)(dev->hw_features >> (32 * i));
|
|
|
|
|
features[i].requested = (u32)(dev->wanted_features >> (32 * i));
|
|
|
|
|
features[i].active = (u32)(dev->features >> (32 * i));
|
|
|
|
|
features[i].never_changed =
|
|
|
|
|
(u32)(NETIF_F_NEVER_CHANGE >> (32 * i));
|
2011-11-15 15:29:55 +00:00
|
|
|
}
|
2011-02-15 16:59:17 +00:00
|
|
|
|
|
|
|
|
sizeaddr = useraddr + offsetof(struct ethtool_gfeatures, size);
|
|
|
|
|
if (get_user(copy_size, sizeaddr))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (copy_size > ETHTOOL_DEV_FEATURE_WORDS)
|
|
|
|
|
copy_size = ETHTOOL_DEV_FEATURE_WORDS;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
useraddr += sizeof(cmd);
|
|
|
|
|
if (copy_to_user(useraddr, features, copy_size * sizeof(*features)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_set_features(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_sfeatures cmd;
|
|
|
|
|
struct ethtool_set_features_block features[ETHTOOL_DEV_FEATURE_WORDS];
|
2011-11-15 15:29:55 +00:00
|
|
|
netdev_features_t wanted = 0, valid = 0;
|
|
|
|
|
int i, ret = 0;
|
2011-02-15 16:59:17 +00:00
|
|
|
|
|
|
|
|
if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
useraddr += sizeof(cmd);
|
|
|
|
|
|
|
|
|
|
if (cmd.size != ETHTOOL_DEV_FEATURE_WORDS)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(features, useraddr, sizeof(features)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; ++i) {
|
2011-11-16 14:32:03 +00:00
|
|
|
valid |= (netdev_features_t)features[i].valid << (32 * i);
|
|
|
|
|
wanted |= (netdev_features_t)features[i].requested << (32 * i);
|
2011-11-15 15:29:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (valid & ~NETIF_F_ETHTOOL_BITS)
|
2011-02-15 16:59:17 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
if (valid & ~dev->hw_features) {
|
|
|
|
|
valid &= dev->hw_features;
|
2011-02-15 16:59:17 +00:00
|
|
|
ret |= ETHTOOL_F_UNSUPPORTED;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
dev->wanted_features &= ~valid;
|
|
|
|
|
dev->wanted_features |= wanted & valid;
|
2011-04-03 05:48:47 +00:00
|
|
|
__netdev_update_features(dev);
|
2011-02-15 16:59:17 +00:00
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
if ((dev->wanted_features ^ dev->features) & valid)
|
2011-02-15 16:59:17 +00:00
|
|
|
ret |= ETHTOOL_F_WISH;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-30 15:28:25 +00:00
|
|
|
static int phy_get_sset_count(struct phy_device *phydev)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (phydev->drv->get_sset_count &&
|
|
|
|
|
phydev->drv->get_strings &&
|
|
|
|
|
phydev->drv->get_stats) {
|
|
|
|
|
mutex_lock(&phydev->lock);
|
|
|
|
|
ret = phydev->drv->get_sset_count(phydev);
|
|
|
|
|
mutex_unlock(&phydev->lock);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-15 16:59:16 +00:00
|
|
|
static int __ethtool_get_sset_count(struct net_device *dev, int sset)
|
|
|
|
|
{
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
|
2011-02-15 16:59:17 +00:00
|
|
|
if (sset == ETH_SS_FEATURES)
|
|
|
|
|
return ARRAY_SIZE(netdev_features_strings);
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
if (sset == ETH_SS_RSS_HASH_FUNCS)
|
|
|
|
|
return ARRAY_SIZE(rss_hash_func_strings);
|
|
|
|
|
|
2015-06-11 07:28:16 +00:00
|
|
|
if (sset == ETH_SS_TUNABLES)
|
|
|
|
|
return ARRAY_SIZE(tunable_strings);
|
|
|
|
|
|
2015-12-30 15:28:25 +00:00
|
|
|
if (sset == ETH_SS_PHY_STATS) {
|
|
|
|
|
if (dev->phydev)
|
|
|
|
|
return phy_get_sset_count(dev->phydev);
|
|
|
|
|
else
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-07 09:02:08 +00:00
|
|
|
if (ops->get_sset_count && ops->get_strings)
|
2011-02-15 16:59:16 +00:00
|
|
|
return ops->get_sset_count(dev, sset);
|
|
|
|
|
else
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __ethtool_get_strings(struct net_device *dev,
|
|
|
|
|
u32 stringset, u8 *data)
|
|
|
|
|
{
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
|
2011-02-15 16:59:17 +00:00
|
|
|
if (stringset == ETH_SS_FEATURES)
|
|
|
|
|
memcpy(data, netdev_features_strings,
|
|
|
|
|
sizeof(netdev_features_strings));
|
2014-12-02 16:12:10 +00:00
|
|
|
else if (stringset == ETH_SS_RSS_HASH_FUNCS)
|
|
|
|
|
memcpy(data, rss_hash_func_strings,
|
|
|
|
|
sizeof(rss_hash_func_strings));
|
2015-06-11 07:28:16 +00:00
|
|
|
else if (stringset == ETH_SS_TUNABLES)
|
|
|
|
|
memcpy(data, tunable_strings, sizeof(tunable_strings));
|
2015-12-30 15:28:25 +00:00
|
|
|
else if (stringset == ETH_SS_PHY_STATS) {
|
|
|
|
|
struct phy_device *phydev = dev->phydev;
|
|
|
|
|
|
|
|
|
|
if (phydev) {
|
|
|
|
|
mutex_lock(&phydev->lock);
|
|
|
|
|
phydev->drv->get_strings(phydev, data);
|
|
|
|
|
mutex_unlock(&phydev->lock);
|
|
|
|
|
} else {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
} else
|
2011-02-15 16:59:17 +00:00
|
|
|
/* ops->get_strings is valid because checked earlier */
|
|
|
|
|
ops->get_strings(dev, stringset, data);
|
2011-02-15 16:59:16 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
static netdev_features_t ethtool_get_feature_mask(u32 eth_cmd)
|
2011-02-15 16:59:17 +00:00
|
|
|
{
|
|
|
|
|
/* feature masks of legacy discrete ethtool ops */
|
|
|
|
|
|
|
|
|
|
switch (eth_cmd) {
|
|
|
|
|
case ETHTOOL_GTXCSUM:
|
|
|
|
|
case ETHTOOL_STXCSUM:
|
2015-12-14 19:19:43 +00:00
|
|
|
return NETIF_F_CSUM_MASK | NETIF_F_SCTP_CRC;
|
2011-02-15 16:59:18 +00:00
|
|
|
case ETHTOOL_GRXCSUM:
|
|
|
|
|
case ETHTOOL_SRXCSUM:
|
|
|
|
|
return NETIF_F_RXCSUM;
|
2011-02-15 16:59:17 +00:00
|
|
|
case ETHTOOL_GSG:
|
|
|
|
|
case ETHTOOL_SSG:
|
|
|
|
|
return NETIF_F_SG;
|
|
|
|
|
case ETHTOOL_GTSO:
|
|
|
|
|
case ETHTOOL_STSO:
|
|
|
|
|
return NETIF_F_ALL_TSO;
|
|
|
|
|
case ETHTOOL_GUFO:
|
|
|
|
|
case ETHTOOL_SUFO:
|
|
|
|
|
return NETIF_F_UFO;
|
|
|
|
|
case ETHTOOL_GGSO:
|
|
|
|
|
case ETHTOOL_SGSO:
|
|
|
|
|
return NETIF_F_GSO;
|
|
|
|
|
case ETHTOOL_GGRO:
|
|
|
|
|
case ETHTOOL_SGRO:
|
|
|
|
|
return NETIF_F_GRO;
|
|
|
|
|
default:
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_get_one_feature(struct net_device *dev,
|
|
|
|
|
char __user *useraddr, u32 ethcmd)
|
|
|
|
|
{
|
2011-11-15 15:29:55 +00:00
|
|
|
netdev_features_t mask = ethtool_get_feature_mask(ethcmd);
|
2011-02-15 16:59:17 +00:00
|
|
|
struct ethtool_value edata = {
|
|
|
|
|
.cmd = ethcmd,
|
2011-02-15 16:59:17 +00:00
|
|
|
.data = !!(dev->features & mask),
|
2011-02-15 16:59:17 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &edata, sizeof(edata)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_set_one_feature(struct net_device *dev,
|
|
|
|
|
void __user *useraddr, u32 ethcmd)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_value edata;
|
2011-11-15 15:29:55 +00:00
|
|
|
netdev_features_t mask;
|
2011-02-15 16:59:17 +00:00
|
|
|
|
|
|
|
|
if (copy_from_user(&edata, useraddr, sizeof(edata)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2011-02-15 16:59:17 +00:00
|
|
|
mask = ethtool_get_feature_mask(ethcmd);
|
|
|
|
|
mask &= dev->hw_features;
|
2011-11-15 15:29:55 +00:00
|
|
|
if (!mask)
|
|
|
|
|
return -EOPNOTSUPP;
|
2011-02-15 16:59:17 +00:00
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
if (edata.data)
|
|
|
|
|
dev->wanted_features |= mask;
|
|
|
|
|
else
|
|
|
|
|
dev->wanted_features &= ~mask;
|
2011-02-15 16:59:17 +00:00
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
__netdev_update_features(dev);
|
2011-02-15 16:59:17 +00:00
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
#define ETH_ALL_FLAGS (ETH_FLAG_LRO | ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN | \
|
|
|
|
|
ETH_FLAG_NTUPLE | ETH_FLAG_RXHASH)
|
2013-04-19 02:04:27 +00:00
|
|
|
#define ETH_ALL_FEATURES (NETIF_F_LRO | NETIF_F_HW_VLAN_CTAG_RX | \
|
|
|
|
|
NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_NTUPLE | \
|
|
|
|
|
NETIF_F_RXHASH)
|
2011-11-15 15:29:55 +00:00
|
|
|
|
|
|
|
|
static u32 __ethtool_get_flags(struct net_device *dev)
|
|
|
|
|
{
|
2011-11-15 15:29:55 +00:00
|
|
|
u32 flags = 0;
|
|
|
|
|
|
2013-07-13 13:43:00 +00:00
|
|
|
if (dev->features & NETIF_F_LRO)
|
|
|
|
|
flags |= ETH_FLAG_LRO;
|
|
|
|
|
if (dev->features & NETIF_F_HW_VLAN_CTAG_RX)
|
|
|
|
|
flags |= ETH_FLAG_RXVLAN;
|
|
|
|
|
if (dev->features & NETIF_F_HW_VLAN_CTAG_TX)
|
|
|
|
|
flags |= ETH_FLAG_TXVLAN;
|
|
|
|
|
if (dev->features & NETIF_F_NTUPLE)
|
|
|
|
|
flags |= ETH_FLAG_NTUPLE;
|
|
|
|
|
if (dev->features & NETIF_F_RXHASH)
|
|
|
|
|
flags |= ETH_FLAG_RXHASH;
|
2011-11-15 15:29:55 +00:00
|
|
|
|
|
|
|
|
return flags;
|
2011-02-15 16:59:17 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
static int __ethtool_set_flags(struct net_device *dev, u32 data)
|
2011-02-15 16:59:18 +00:00
|
|
|
{
|
2011-11-15 15:29:55 +00:00
|
|
|
netdev_features_t features = 0, changed;
|
2011-02-15 16:59:18 +00:00
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
if (data & ~ETH_ALL_FLAGS)
|
2011-02-15 16:59:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2013-07-13 13:43:00 +00:00
|
|
|
if (data & ETH_FLAG_LRO)
|
|
|
|
|
features |= NETIF_F_LRO;
|
|
|
|
|
if (data & ETH_FLAG_RXVLAN)
|
|
|
|
|
features |= NETIF_F_HW_VLAN_CTAG_RX;
|
|
|
|
|
if (data & ETH_FLAG_TXVLAN)
|
|
|
|
|
features |= NETIF_F_HW_VLAN_CTAG_TX;
|
|
|
|
|
if (data & ETH_FLAG_NTUPLE)
|
|
|
|
|
features |= NETIF_F_NTUPLE;
|
|
|
|
|
if (data & ETH_FLAG_RXHASH)
|
|
|
|
|
features |= NETIF_F_RXHASH;
|
2011-11-15 15:29:55 +00:00
|
|
|
|
2011-02-15 16:59:18 +00:00
|
|
|
/* allow changing only bits set in hw_features */
|
2011-11-15 15:29:55 +00:00
|
|
|
changed = (features ^ dev->features) & ETH_ALL_FEATURES;
|
2011-02-15 16:59:18 +00:00
|
|
|
if (changed & ~dev->hw_features)
|
|
|
|
|
return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
dev->wanted_features =
|
2011-11-15 15:29:55 +00:00
|
|
|
(dev->wanted_features & ~changed) | (features & changed);
|
2011-02-15 16:59:18 +00:00
|
|
|
|
2011-04-03 05:48:47 +00:00
|
|
|
__netdev_update_features(dev);
|
2011-02-15 16:59:18 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
static void convert_legacy_u32_to_link_mode(unsigned long *dst, u32 legacy_u32)
|
|
|
|
|
{
|
|
|
|
|
bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
|
|
|
dst[0] = legacy_u32;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* return false if src had higher bits set. lower bits always updated. */
|
|
|
|
|
static bool convert_link_mode_to_legacy_u32(u32 *legacy_u32,
|
|
|
|
|
const unsigned long *src)
|
|
|
|
|
{
|
|
|
|
|
bool retval = true;
|
|
|
|
|
|
|
|
|
|
/* TODO: following test will soon always be true */
|
|
|
|
|
if (__ETHTOOL_LINK_MODE_MASK_NBITS > 32) {
|
|
|
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(ext);
|
|
|
|
|
|
|
|
|
|
bitmap_zero(ext, __ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
|
|
|
bitmap_fill(ext, 32);
|
|
|
|
|
bitmap_complement(ext, ext, __ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
|
|
|
if (bitmap_intersects(ext, src,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS)) {
|
|
|
|
|
/* src mask goes beyond bit 31 */
|
|
|
|
|
retval = false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*legacy_u32 = src[0];
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* return false if legacy contained non-0 deprecated fields
|
|
|
|
|
* transceiver/maxtxpkt/maxrxpkt. rest of ksettings always updated
|
|
|
|
|
*/
|
|
|
|
|
static bool
|
|
|
|
|
convert_legacy_settings_to_link_ksettings(
|
|
|
|
|
struct ethtool_link_ksettings *link_ksettings,
|
|
|
|
|
const struct ethtool_cmd *legacy_settings)
|
|
|
|
|
{
|
|
|
|
|
bool retval = true;
|
|
|
|
|
|
|
|
|
|
memset(link_ksettings, 0, sizeof(*link_ksettings));
|
|
|
|
|
|
|
|
|
|
/* This is used to tell users that driver is still using these
|
|
|
|
|
* deprecated legacy fields, and they should not use
|
|
|
|
|
* %ETHTOOL_GLINKSETTINGS/%ETHTOOL_SLINKSETTINGS
|
|
|
|
|
*/
|
|
|
|
|
if (legacy_settings->transceiver ||
|
|
|
|
|
legacy_settings->maxtxpkt ||
|
|
|
|
|
legacy_settings->maxrxpkt)
|
|
|
|
|
retval = false;
|
|
|
|
|
|
|
|
|
|
convert_legacy_u32_to_link_mode(
|
|
|
|
|
link_ksettings->link_modes.supported,
|
|
|
|
|
legacy_settings->supported);
|
|
|
|
|
convert_legacy_u32_to_link_mode(
|
|
|
|
|
link_ksettings->link_modes.advertising,
|
|
|
|
|
legacy_settings->advertising);
|
|
|
|
|
convert_legacy_u32_to_link_mode(
|
|
|
|
|
link_ksettings->link_modes.lp_advertising,
|
|
|
|
|
legacy_settings->lp_advertising);
|
|
|
|
|
link_ksettings->base.speed
|
|
|
|
|
= ethtool_cmd_speed(legacy_settings);
|
|
|
|
|
link_ksettings->base.duplex
|
|
|
|
|
= legacy_settings->duplex;
|
|
|
|
|
link_ksettings->base.port
|
|
|
|
|
= legacy_settings->port;
|
|
|
|
|
link_ksettings->base.phy_address
|
|
|
|
|
= legacy_settings->phy_address;
|
|
|
|
|
link_ksettings->base.autoneg
|
|
|
|
|
= legacy_settings->autoneg;
|
|
|
|
|
link_ksettings->base.mdio_support
|
|
|
|
|
= legacy_settings->mdio_support;
|
|
|
|
|
link_ksettings->base.eth_tp_mdix
|
|
|
|
|
= legacy_settings->eth_tp_mdix;
|
|
|
|
|
link_ksettings->base.eth_tp_mdix_ctrl
|
|
|
|
|
= legacy_settings->eth_tp_mdix_ctrl;
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* return false if ksettings link modes had higher bits
|
|
|
|
|
* set. legacy_settings always updated (best effort)
|
|
|
|
|
*/
|
|
|
|
|
static bool
|
|
|
|
|
convert_link_ksettings_to_legacy_settings(
|
|
|
|
|
struct ethtool_cmd *legacy_settings,
|
|
|
|
|
const struct ethtool_link_ksettings *link_ksettings)
|
|
|
|
|
{
|
|
|
|
|
bool retval = true;
|
|
|
|
|
|
|
|
|
|
memset(legacy_settings, 0, sizeof(*legacy_settings));
|
|
|
|
|
/* this also clears the deprecated fields in legacy structure:
|
|
|
|
|
* __u8 transceiver;
|
|
|
|
|
* __u32 maxtxpkt;
|
|
|
|
|
* __u32 maxrxpkt;
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
retval &= convert_link_mode_to_legacy_u32(
|
|
|
|
|
&legacy_settings->supported,
|
|
|
|
|
link_ksettings->link_modes.supported);
|
|
|
|
|
retval &= convert_link_mode_to_legacy_u32(
|
|
|
|
|
&legacy_settings->advertising,
|
|
|
|
|
link_ksettings->link_modes.advertising);
|
|
|
|
|
retval &= convert_link_mode_to_legacy_u32(
|
|
|
|
|
&legacy_settings->lp_advertising,
|
|
|
|
|
link_ksettings->link_modes.lp_advertising);
|
|
|
|
|
ethtool_cmd_speed_set(legacy_settings, link_ksettings->base.speed);
|
|
|
|
|
legacy_settings->duplex
|
|
|
|
|
= link_ksettings->base.duplex;
|
|
|
|
|
legacy_settings->port
|
|
|
|
|
= link_ksettings->base.port;
|
|
|
|
|
legacy_settings->phy_address
|
|
|
|
|
= link_ksettings->base.phy_address;
|
|
|
|
|
legacy_settings->autoneg
|
|
|
|
|
= link_ksettings->base.autoneg;
|
|
|
|
|
legacy_settings->mdio_support
|
|
|
|
|
= link_ksettings->base.mdio_support;
|
|
|
|
|
legacy_settings->eth_tp_mdix
|
|
|
|
|
= link_ksettings->base.eth_tp_mdix;
|
|
|
|
|
legacy_settings->eth_tp_mdix_ctrl
|
|
|
|
|
= link_ksettings->base.eth_tp_mdix_ctrl;
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* number of 32-bit words to store the user's link mode bitmaps */
|
|
|
|
|
#define __ETHTOOL_LINK_MODE_MASK_NU32 \
|
|
|
|
|
DIV_ROUND_UP(__ETHTOOL_LINK_MODE_MASK_NBITS, 32)
|
|
|
|
|
|
|
|
|
|
/* layout of the struct passed from/to userland */
|
|
|
|
|
struct ethtool_link_usettings {
|
|
|
|
|
struct ethtool_link_settings base;
|
|
|
|
|
struct {
|
|
|
|
|
__u32 supported[__ETHTOOL_LINK_MODE_MASK_NU32];
|
|
|
|
|
__u32 advertising[__ETHTOOL_LINK_MODE_MASK_NU32];
|
|
|
|
|
__u32 lp_advertising[__ETHTOOL_LINK_MODE_MASK_NU32];
|
|
|
|
|
} link_modes;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Internal kernel helper to query a device ethtool_link_settings.
|
|
|
|
|
*
|
|
|
|
|
* Backward compatibility note: for compatibility with legacy drivers
|
|
|
|
|
* that implement only the ethtool_cmd API, this has to work with both
|
|
|
|
|
* drivers implementing get_link_ksettings API and drivers
|
|
|
|
|
* implementing get_settings API. When drivers implement get_settings
|
|
|
|
|
* and report ethtool_cmd deprecated fields
|
|
|
|
|
* (transceiver/maxrxpkt/maxtxpkt), these fields are silently ignored
|
|
|
|
|
* because the resulting struct ethtool_link_settings does not report them.
|
|
|
|
|
*/
|
|
|
|
|
int __ethtool_get_link_ksettings(struct net_device *dev,
|
|
|
|
|
struct ethtool_link_ksettings *link_ksettings)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
struct ethtool_cmd cmd;
|
|
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
|
|
if (dev->ethtool_ops->get_link_ksettings) {
|
|
|
|
|
memset(link_ksettings, 0, sizeof(*link_ksettings));
|
|
|
|
|
return dev->ethtool_ops->get_link_ksettings(dev,
|
|
|
|
|
link_ksettings);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* driver doesn't support %ethtool_link_ksettings API. revert to
|
|
|
|
|
* legacy %ethtool_cmd API, unless it's not supported either.
|
|
|
|
|
* TODO: remove when ethtool_ops::get_settings disappears internally
|
|
|
|
|
*/
|
2016-02-24 18:58:11 +00:00
|
|
|
if (!dev->ethtool_ops->get_settings)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
|
cmd.cmd = ETHTOOL_GSET;
|
|
|
|
|
err = dev->ethtool_ops->get_settings(dev, &cmd);
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
/* we ignore deprecated fields transceiver/maxrxpkt/maxtxpkt
|
|
|
|
|
*/
|
|
|
|
|
convert_legacy_settings_to_link_ksettings(link_ksettings, &cmd);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(__ethtool_get_link_ksettings);
|
|
|
|
|
|
|
|
|
|
/* convert ethtool_link_usettings in user space to a kernel internal
|
|
|
|
|
* ethtool_link_ksettings. return 0 on success, errno on error.
|
|
|
|
|
*/
|
|
|
|
|
static int load_link_ksettings_from_user(struct ethtool_link_ksettings *to,
|
|
|
|
|
const void __user *from)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_link_usettings link_usettings;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&link_usettings, from, sizeof(link_usettings)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
memcpy(&to->base, &link_usettings.base, sizeof(to->base));
|
|
|
|
|
bitmap_from_u32array(to->link_modes.supported,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS,
|
|
|
|
|
link_usettings.link_modes.supported,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NU32);
|
|
|
|
|
bitmap_from_u32array(to->link_modes.advertising,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS,
|
|
|
|
|
link_usettings.link_modes.advertising,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NU32);
|
|
|
|
|
bitmap_from_u32array(to->link_modes.lp_advertising,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS,
|
|
|
|
|
link_usettings.link_modes.lp_advertising,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NU32);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* convert a kernel internal ethtool_link_ksettings to
|
|
|
|
|
* ethtool_link_usettings in user space. return 0 on success, errno on
|
|
|
|
|
* error.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
store_link_ksettings_for_user(void __user *to,
|
|
|
|
|
const struct ethtool_link_ksettings *from)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_link_usettings link_usettings;
|
|
|
|
|
|
|
|
|
|
memcpy(&link_usettings.base, &from->base, sizeof(link_usettings));
|
|
|
|
|
bitmap_to_u32array(link_usettings.link_modes.supported,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NU32,
|
|
|
|
|
from->link_modes.supported,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
|
|
|
bitmap_to_u32array(link_usettings.link_modes.advertising,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NU32,
|
|
|
|
|
from->link_modes.advertising,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
|
|
|
bitmap_to_u32array(link_usettings.link_modes.lp_advertising,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NU32,
|
|
|
|
|
from->link_modes.lp_advertising,
|
|
|
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(to, &link_usettings, sizeof(link_usettings)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Query device for its ethtool_link_settings.
|
|
|
|
|
*
|
|
|
|
|
* Backward compatibility note: this function must fail when driver
|
|
|
|
|
* does not implement ethtool::get_link_ksettings, even if legacy
|
|
|
|
|
* ethtool_ops::get_settings is implemented. This tells new versions
|
|
|
|
|
* of ethtool that they should use the legacy API %ETHTOOL_GSET for
|
|
|
|
|
* this driver, so that they can correctly access the ethtool_cmd
|
|
|
|
|
* deprecated fields (transceiver/maxrxpkt/maxtxpkt), until no driver
|
|
|
|
|
* implements ethtool_ops::get_settings anymore.
|
|
|
|
|
*/
|
|
|
|
|
static int ethtool_get_link_ksettings(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int err = 0;
|
|
|
|
|
struct ethtool_link_ksettings link_ksettings;
|
|
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_link_ksettings)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
/* handle bitmap nbits handshake */
|
|
|
|
|
if (copy_from_user(&link_ksettings.base, useraddr,
|
|
|
|
|
sizeof(link_ksettings.base)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (__ETHTOOL_LINK_MODE_MASK_NU32
|
|
|
|
|
!= link_ksettings.base.link_mode_masks_nwords) {
|
|
|
|
|
/* wrong link mode nbits requested */
|
|
|
|
|
memset(&link_ksettings, 0, sizeof(link_ksettings));
|
|
|
|
|
/* keep cmd field reset to 0 */
|
|
|
|
|
/* send back number of words required as negative val */
|
|
|
|
|
compiletime_assert(__ETHTOOL_LINK_MODE_MASK_NU32 <= S8_MAX,
|
|
|
|
|
"need too many bits for link modes!");
|
|
|
|
|
link_ksettings.base.link_mode_masks_nwords
|
|
|
|
|
= -((s8)__ETHTOOL_LINK_MODE_MASK_NU32);
|
|
|
|
|
|
|
|
|
|
/* copy the base fields back to user, not the link
|
|
|
|
|
* mode bitmaps
|
|
|
|
|
*/
|
|
|
|
|
if (copy_to_user(useraddr, &link_ksettings.base,
|
|
|
|
|
sizeof(link_ksettings.base)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* handshake successful: user/kernel agree on
|
|
|
|
|
* link_mode_masks_nwords
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
memset(&link_ksettings, 0, sizeof(link_ksettings));
|
|
|
|
|
err = dev->ethtool_ops->get_link_ksettings(dev, &link_ksettings);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
/* make sure we tell the right values to user */
|
|
|
|
|
link_ksettings.base.cmd = ETHTOOL_GLINKSETTINGS;
|
|
|
|
|
link_ksettings.base.link_mode_masks_nwords
|
|
|
|
|
= __ETHTOOL_LINK_MODE_MASK_NU32;
|
|
|
|
|
|
|
|
|
|
return store_link_ksettings_for_user(useraddr, &link_ksettings);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Update device ethtool_link_settings.
|
|
|
|
|
*
|
|
|
|
|
* Backward compatibility note: this function must fail when driver
|
|
|
|
|
* does not implement ethtool::set_link_ksettings, even if legacy
|
|
|
|
|
* ethtool_ops::set_settings is implemented. This tells new versions
|
|
|
|
|
* of ethtool that they should use the legacy API %ETHTOOL_SSET for
|
|
|
|
|
* this driver, so that they can correctly update the ethtool_cmd
|
|
|
|
|
* deprecated fields (transceiver/maxrxpkt/maxtxpkt), until no driver
|
|
|
|
|
* implements ethtool_ops::get_settings anymore.
|
|
|
|
|
*/
|
|
|
|
|
static int ethtool_set_link_ksettings(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
struct ethtool_link_ksettings link_ksettings;
|
|
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->set_link_ksettings)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
/* make sure nbits field has expected value */
|
|
|
|
|
if (copy_from_user(&link_ksettings.base, useraddr,
|
|
|
|
|
sizeof(link_ksettings.base)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (__ETHTOOL_LINK_MODE_MASK_NU32
|
|
|
|
|
!= link_ksettings.base.link_mode_masks_nwords)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* copy the whole structure, now that we know it has expected
|
|
|
|
|
* format
|
|
|
|
|
*/
|
|
|
|
|
err = load_link_ksettings_from_user(&link_ksettings, useraddr);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
/* re-check nwords field, just in case */
|
|
|
|
|
if (__ETHTOOL_LINK_MODE_MASK_NU32
|
|
|
|
|
!= link_ksettings.base.link_mode_masks_nwords)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
return dev->ethtool_ops->set_link_ksettings(dev, &link_ksettings);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
warn_incomplete_ethtool_legacy_settings_conversion(const char *details)
|
|
|
|
|
{
|
|
|
|
|
char name[sizeof(current->comm)];
|
|
|
|
|
|
|
|
|
|
pr_info_once("warning: `%s' uses legacy ethtool link settings API, %s\n",
|
|
|
|
|
get_task_comm(name, current), details);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Query device for its ethtool_cmd settings.
|
|
|
|
|
*
|
|
|
|
|
* Backward compatibility note: for compatibility with legacy ethtool,
|
|
|
|
|
* this has to work with both drivers implementing get_link_ksettings
|
|
|
|
|
* API and drivers implementing get_settings API. When drivers
|
|
|
|
|
* implement get_link_ksettings and report higher link mode bits, a
|
|
|
|
|
* kernel warning is logged once (with name of 1st driver/device) to
|
|
|
|
|
* recommend user to upgrade ethtool, but the command is successful
|
|
|
|
|
* (only the lower link mode bits reported back to user).
|
|
|
|
|
*/
|
2011-09-03 03:34:30 +00:00
|
|
|
static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_cmd cmd;
|
|
|
|
|
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
|
|
if (dev->ethtool_ops->get_link_ksettings) {
|
|
|
|
|
/* First, use link_ksettings API if it is supported */
|
|
|
|
|
int err;
|
|
|
|
|
struct ethtool_link_ksettings link_ksettings;
|
|
|
|
|
|
|
|
|
|
memset(&link_ksettings, 0, sizeof(link_ksettings));
|
|
|
|
|
err = dev->ethtool_ops->get_link_ksettings(dev,
|
|
|
|
|
&link_ksettings);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
|
|
|
|
if (!convert_link_ksettings_to_legacy_settings(&cmd,
|
|
|
|
|
&link_ksettings))
|
|
|
|
|
warn_incomplete_ethtool_legacy_settings_conversion(
|
|
|
|
|
"link modes are only partially reported");
|
|
|
|
|
|
|
|
|
|
/* send a sensible cmd tag back to user */
|
|
|
|
|
cmd.cmd = ETHTOOL_GSET;
|
|
|
|
|
} else {
|
|
|
|
|
/* driver doesn't support %ethtool_link_ksettings
|
|
|
|
|
* API. revert to legacy %ethtool_cmd API, unless it's
|
|
|
|
|
* not supported either.
|
|
|
|
|
*/
|
2016-02-24 18:58:11 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_settings)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
|
cmd.cmd = ETHTOOL_GSET;
|
|
|
|
|
err = dev->ethtool_ops->get_settings(dev, &cmd);
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
|
|
|
|
|
return -EFAULT;
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
/* Update device link settings with given ethtool_cmd.
|
|
|
|
|
*
|
|
|
|
|
* Backward compatibility note: for compatibility with legacy ethtool,
|
|
|
|
|
* this has to work with both drivers implementing set_link_ksettings
|
|
|
|
|
* API and drivers implementing set_settings API. When drivers
|
|
|
|
|
* implement set_link_ksettings and user's request updates deprecated
|
|
|
|
|
* ethtool_cmd fields (transceiver/maxrxpkt/maxtxpkt), a kernel
|
|
|
|
|
* warning is logged once (with name of 1st driver/device) to
|
|
|
|
|
* recommend user to upgrade ethtool, and the request is rejected.
|
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_cmd cmd;
|
|
|
|
|
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
ASSERT_RTNL();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
/* first, try new %ethtool_link_ksettings API. */
|
|
|
|
|
if (dev->ethtool_ops->set_link_ksettings) {
|
|
|
|
|
struct ethtool_link_ksettings link_ksettings;
|
|
|
|
|
|
|
|
|
|
if (!convert_legacy_settings_to_link_ksettings(&link_ksettings,
|
|
|
|
|
&cmd))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
link_ksettings.base.cmd = ETHTOOL_SLINKSETTINGS;
|
|
|
|
|
link_ksettings.base.link_mode_masks_nwords
|
|
|
|
|
= __ETHTOOL_LINK_MODE_MASK_NU32;
|
|
|
|
|
return dev->ethtool_ops->set_link_ksettings(dev,
|
|
|
|
|
&link_ksettings);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* legacy %ethtool_cmd API */
|
|
|
|
|
|
|
|
|
|
/* TODO: return -EOPNOTSUPP when ethtool_ops::get_settings
|
|
|
|
|
* disappears internally
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->set_settings)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return dev->ethtool_ops->set_settings(dev, &cmd);
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-08 04:54:42 +00:00
|
|
|
static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_drvinfo info;
|
2006-09-08 18:16:13 +00:00
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
|
info.cmd = ETHTOOL_GDRVINFO;
|
2013-01-07 09:02:08 +00:00
|
|
|
if (ops->get_drvinfo) {
|
2010-08-17 09:31:15 +00:00
|
|
|
ops->get_drvinfo(dev, &info);
|
|
|
|
|
} else if (dev->dev.parent && dev->dev.parent->driver) {
|
|
|
|
|
strlcpy(info.bus_info, dev_name(dev->dev.parent),
|
|
|
|
|
sizeof(info.bus_info));
|
|
|
|
|
strlcpy(info.driver, dev->dev.parent->driver->name,
|
|
|
|
|
sizeof(info.driver));
|
|
|
|
|
} else {
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-03-03 22:51:50 +00:00
|
|
|
/*
|
|
|
|
|
* this method of obtaining string set info is deprecated;
|
ethtool: Add direct access to ops->get_sset_count
On 03/04/2010 09:26 AM, Ben Hutchings wrote:
> On Thu, 2010-03-04 at 00:51 -0800, Jeff Kirsher wrote:
>> From: Jeff Garzik<jgarzik@redhat.com>
>>
>> This patch is an alternative approach for accessing string
>> counts, vs. the drvinfo indirect approach. This way the drvinfo
>> space doesn't run out, and we don't break ABI later.
> [...]
>> --- a/net/core/ethtool.c
>> +++ b/net/core/ethtool.c
>> @@ -214,6 +214,10 @@ static noinline int ethtool_get_drvinfo(struct net_device *dev, void __user *use
>> info.cmd = ETHTOOL_GDRVINFO;
>> ops->get_drvinfo(dev,&info);
>>
>> + /*
>> + * this method of obtaining string set info is deprecated;
>> + * consider using ETHTOOL_GSSET_INFO instead
>> + */
>
> This comment belongs on the interface (ethtool.h) not the
> implementation.
Debatable -- the current comment is located at the callsite of
ops->get_sset_count(), which is where an implementor might think to add
a new call. Not all the numeric fields in ethtool_drvinfo are obtained
from ->get_sset_count().
Hence the "some" in the attached patch to include/linux/ethtool.h,
addressing your comment.
> [...]
>> +static noinline int ethtool_get_sset_info(struct net_device *dev,
>> + void __user *useraddr)
>> +{
> [...]
>> + /* calculate size of return buffer */
>> + for (i = 0; i< 64; i++)
>> + if (sset_mask& (1ULL<< i))
>> + n_bits++;
> [...]
>
> We have a function for this:
>
> n_bits = hweight64(sset_mask);
Agreed.
I've attached a follow-up patch, which should enable my/Jeff's kernel
patch to be applied, followed by this one.
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-03-04 08:21:53 +00:00
|
|
|
* Use ETHTOOL_GSSET_INFO instead.
|
2010-03-03 22:51:50 +00:00
|
|
|
*/
|
2013-01-07 09:02:08 +00:00
|
|
|
if (ops->get_sset_count) {
|
2007-08-15 23:01:08 +00:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
rc = ops->get_sset_count(dev, ETH_SS_TEST);
|
|
|
|
|
if (rc >= 0)
|
|
|
|
|
info.testinfo_len = rc;
|
|
|
|
|
rc = ops->get_sset_count(dev, ETH_SS_STATS);
|
|
|
|
|
if (rc >= 0)
|
|
|
|
|
info.n_stats = rc;
|
2007-08-15 23:01:32 +00:00
|
|
|
rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
|
|
|
|
|
if (rc >= 0)
|
|
|
|
|
info.n_priv_flags = rc;
|
2007-08-15 23:01:08 +00:00
|
|
|
}
|
2013-01-07 09:02:08 +00:00
|
|
|
if (ops->get_regs_len)
|
2005-04-16 22:20:36 +00:00
|
|
|
info.regdump_len = ops->get_regs_len(dev);
|
2013-01-07 09:02:08 +00:00
|
|
|
if (ops->get_eeprom_len)
|
2005-04-16 22:20:36 +00:00
|
|
|
info.eedump_len = ops->get_eeprom_len(dev);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &info, sizeof(info)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-08 20:17:04 +00:00
|
|
|
static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
|
2010-04-08 04:54:42 +00:00
|
|
|
void __user *useraddr)
|
2010-03-03 22:51:50 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_sset_info info;
|
|
|
|
|
u64 sset_mask;
|
|
|
|
|
int i, idx = 0, n_bits = 0, ret, rc;
|
|
|
|
|
u32 *info_buf = NULL;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&info, useraddr, sizeof(info)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
/* store copy of mask, because we zero struct later on */
|
|
|
|
|
sset_mask = info.sset_mask;
|
|
|
|
|
if (!sset_mask)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* calculate size of return buffer */
|
ethtool: Add direct access to ops->get_sset_count
On 03/04/2010 09:26 AM, Ben Hutchings wrote:
> On Thu, 2010-03-04 at 00:51 -0800, Jeff Kirsher wrote:
>> From: Jeff Garzik<jgarzik@redhat.com>
>>
>> This patch is an alternative approach for accessing string
>> counts, vs. the drvinfo indirect approach. This way the drvinfo
>> space doesn't run out, and we don't break ABI later.
> [...]
>> --- a/net/core/ethtool.c
>> +++ b/net/core/ethtool.c
>> @@ -214,6 +214,10 @@ static noinline int ethtool_get_drvinfo(struct net_device *dev, void __user *use
>> info.cmd = ETHTOOL_GDRVINFO;
>> ops->get_drvinfo(dev,&info);
>>
>> + /*
>> + * this method of obtaining string set info is deprecated;
>> + * consider using ETHTOOL_GSSET_INFO instead
>> + */
>
> This comment belongs on the interface (ethtool.h) not the
> implementation.
Debatable -- the current comment is located at the callsite of
ops->get_sset_count(), which is where an implementor might think to add
a new call. Not all the numeric fields in ethtool_drvinfo are obtained
from ->get_sset_count().
Hence the "some" in the attached patch to include/linux/ethtool.h,
addressing your comment.
> [...]
>> +static noinline int ethtool_get_sset_info(struct net_device *dev,
>> + void __user *useraddr)
>> +{
> [...]
>> + /* calculate size of return buffer */
>> + for (i = 0; i< 64; i++)
>> + if (sset_mask& (1ULL<< i))
>> + n_bits++;
> [...]
>
> We have a function for this:
>
> n_bits = hweight64(sset_mask);
Agreed.
I've attached a follow-up patch, which should enable my/Jeff's kernel
patch to be applied, followed by this one.
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-03-04 08:21:53 +00:00
|
|
|
n_bits = hweight64(sset_mask);
|
2010-03-03 22:51:50 +00:00
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
|
info.cmd = ETHTOOL_GSSET_INFO;
|
|
|
|
|
|
|
|
|
|
info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
|
|
|
|
|
if (!info_buf)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* fill return buffer based on input bitmask and successful
|
|
|
|
|
* get_sset_count return
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < 64; i++) {
|
|
|
|
|
if (!(sset_mask & (1ULL << i)))
|
|
|
|
|
continue;
|
|
|
|
|
|
2011-02-15 16:59:16 +00:00
|
|
|
rc = __ethtool_get_sset_count(dev, i);
|
2010-03-03 22:51:50 +00:00
|
|
|
if (rc >= 0) {
|
|
|
|
|
info.sset_mask |= (1ULL << i);
|
|
|
|
|
info_buf[idx++] = rc;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
if (copy_to_user(useraddr, &info, sizeof(info)))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
useraddr += offsetof(struct ethtool_sset_info, data);
|
|
|
|
|
if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(info_buf);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-08 04:54:42 +00:00
|
|
|
static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
|
2010-06-28 08:45:58 +00:00
|
|
|
u32 cmd, void __user *useraddr)
|
2008-07-02 10:47:41 +00:00
|
|
|
{
|
2010-06-28 08:45:58 +00:00
|
|
|
struct ethtool_rxnfc info;
|
|
|
|
|
size_t info_size = sizeof(info);
|
2012-01-03 12:04:51 +00:00
|
|
|
int rc;
|
2008-07-02 10:47:41 +00:00
|
|
|
|
2009-02-20 08:58:13 +00:00
|
|
|
if (!dev->ethtool_ops->set_rxnfc)
|
2008-07-02 10:47:41 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2010-06-28 08:45:58 +00:00
|
|
|
/* struct ethtool_rxnfc was originally defined for
|
|
|
|
|
* ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
|
|
|
|
|
* members. User-space might still be using that
|
|
|
|
|
* definition. */
|
|
|
|
|
if (cmd == ETHTOOL_SRXFH)
|
|
|
|
|
info_size = (offsetof(struct ethtool_rxnfc, data) +
|
|
|
|
|
sizeof(info.data));
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&info, useraddr, info_size))
|
2008-07-02 10:47:41 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2012-01-03 12:04:51 +00:00
|
|
|
rc = dev->ethtool_ops->set_rxnfc(dev, &info);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
if (cmd == ETHTOOL_SRXCLSRLINS &&
|
|
|
|
|
copy_to_user(useraddr, &info, info_size))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
2008-07-02 10:47:41 +00:00
|
|
|
}
|
|
|
|
|
|
2010-04-08 04:54:42 +00:00
|
|
|
static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
|
2010-06-28 08:45:58 +00:00
|
|
|
u32 cmd, void __user *useraddr)
|
2008-07-02 10:47:41 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_rxnfc info;
|
2010-06-28 08:45:58 +00:00
|
|
|
size_t info_size = sizeof(info);
|
2009-02-20 08:58:13 +00:00
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
int ret;
|
|
|
|
|
void *rule_buf = NULL;
|
2008-07-02 10:47:41 +00:00
|
|
|
|
2009-02-20 08:58:13 +00:00
|
|
|
if (!ops->get_rxnfc)
|
2008-07-02 10:47:41 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2010-06-28 08:45:58 +00:00
|
|
|
/* struct ethtool_rxnfc was originally defined for
|
|
|
|
|
* ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
|
|
|
|
|
* members. User-space might still be using that
|
|
|
|
|
* definition. */
|
|
|
|
|
if (cmd == ETHTOOL_GRXFH)
|
|
|
|
|
info_size = (offsetof(struct ethtool_rxnfc, data) +
|
|
|
|
|
sizeof(info.data));
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&info, useraddr, info_size))
|
2008-07-02 10:47:41 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2009-02-20 08:58:13 +00:00
|
|
|
if (info.cmd == ETHTOOL_GRXCLSRLALL) {
|
|
|
|
|
if (info.rule_cnt > 0) {
|
2010-06-28 08:44:07 +00:00
|
|
|
if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
|
2010-10-07 10:03:48 +00:00
|
|
|
rule_buf = kzalloc(info.rule_cnt * sizeof(u32),
|
2010-06-28 08:44:07 +00:00
|
|
|
GFP_USER);
|
2009-02-20 08:58:13 +00:00
|
|
|
if (!rule_buf)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-07-02 10:47:41 +00:00
|
|
|
|
2009-02-20 08:58:13 +00:00
|
|
|
ret = ops->get_rxnfc(dev, &info, rule_buf);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
|
|
ret = -EFAULT;
|
2010-06-28 08:45:58 +00:00
|
|
|
if (copy_to_user(useraddr, &info, info_size))
|
2009-02-20 08:58:13 +00:00
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
|
|
if (rule_buf) {
|
|
|
|
|
useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
|
|
|
|
|
if (copy_to_user(useraddr, rule_buf,
|
|
|
|
|
info.rule_cnt * sizeof(u32)))
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
|
|
err_out:
|
2009-03-31 22:06:26 +00:00
|
|
|
kfree(rule_buf);
|
2009-02-20 08:58:13 +00:00
|
|
|
|
|
|
|
|
return ret;
|
2008-07-02 10:47:41 +00:00
|
|
|
}
|
|
|
|
|
|
2014-04-21 10:07:59 +00:00
|
|
|
static int ethtool_copy_validate_indir(u32 *indir, void __user *useraddr,
|
|
|
|
|
struct ethtool_rxnfc *rx_rings,
|
|
|
|
|
u32 size)
|
|
|
|
|
{
|
2014-05-14 23:46:45 +00:00
|
|
|
int i;
|
2014-04-21 10:07:59 +00:00
|
|
|
|
|
|
|
|
if (copy_from_user(indir, useraddr, size * sizeof(indir[0])))
|
2014-05-14 23:46:45 +00:00
|
|
|
return -EFAULT;
|
2014-04-21 10:07:59 +00:00
|
|
|
|
|
|
|
|
/* Validate ring indices */
|
2014-05-14 23:46:45 +00:00
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
|
if (indir[i] >= rx_rings->data)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
return 0;
|
2014-04-21 10:07:59 +00:00
|
|
|
}
|
|
|
|
|
|
2016-02-02 03:51:16 +00:00
|
|
|
u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
|
2014-11-16 14:23:05 +00:00
|
|
|
|
|
|
|
|
void netdev_rss_key_fill(void *buffer, size_t len)
|
|
|
|
|
{
|
|
|
|
|
BUG_ON(len > sizeof(netdev_rss_key));
|
|
|
|
|
net_get_random_once(netdev_rss_key, sizeof(netdev_rss_key));
|
|
|
|
|
memcpy(buffer, netdev_rss_key, len);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(netdev_rss_key_fill);
|
|
|
|
|
|
2016-02-09 00:05:03 +00:00
|
|
|
static int ethtool_get_max_rxfh_channel(struct net_device *dev, u32 *max)
|
|
|
|
|
{
|
|
|
|
|
u32 dev_size, current_max = 0;
|
|
|
|
|
u32 *indir;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_rxfh_indir_size ||
|
|
|
|
|
!dev->ethtool_ops->get_rxfh)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
dev_size = dev->ethtool_ops->get_rxfh_indir_size(dev);
|
|
|
|
|
if (dev_size == 0)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
indir = kcalloc(dev_size, sizeof(indir[0]), GFP_USER);
|
|
|
|
|
if (!indir)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
ret = dev->ethtool_ops->get_rxfh(dev, indir, NULL, NULL);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
while (dev_size--)
|
|
|
|
|
current_max = max(current_max, indir[dev_size]);
|
|
|
|
|
|
|
|
|
|
*max = current_max;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(indir);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-30 05:05:23 +00:00
|
|
|
static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
2011-12-15 13:55:01 +00:00
|
|
|
u32 user_size, dev_size;
|
|
|
|
|
u32 *indir;
|
2010-06-30 05:05:23 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2011-12-15 13:55:01 +00:00
|
|
|
if (!dev->ethtool_ops->get_rxfh_indir_size ||
|
2014-05-15 00:25:27 +00:00
|
|
|
!dev->ethtool_ops->get_rxfh)
|
2011-12-15 13:55:01 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
dev_size = dev->ethtool_ops->get_rxfh_indir_size(dev);
|
|
|
|
|
if (dev_size == 0)
|
2010-06-30 05:05:23 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2011-12-15 13:55:01 +00:00
|
|
|
if (copy_from_user(&user_size,
|
2010-06-30 05:05:23 +00:00
|
|
|
useraddr + offsetof(struct ethtool_rxfh_indir, size),
|
2011-12-15 13:55:01 +00:00
|
|
|
sizeof(user_size)))
|
2010-06-30 05:05:23 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2011-12-15 13:55:01 +00:00
|
|
|
if (copy_to_user(useraddr + offsetof(struct ethtool_rxfh_indir, size),
|
|
|
|
|
&dev_size, sizeof(dev_size)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
/* If the user buffer size is 0, this is just a query for the
|
|
|
|
|
* device table size. Otherwise, if it's smaller than the
|
|
|
|
|
* device table size it's an error.
|
|
|
|
|
*/
|
|
|
|
|
if (user_size < dev_size)
|
|
|
|
|
return user_size == 0 ? 0 : -EINVAL;
|
|
|
|
|
|
|
|
|
|
indir = kcalloc(dev_size, sizeof(indir[0]), GFP_USER);
|
2010-06-30 05:05:23 +00:00
|
|
|
if (!indir)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
ret = dev->ethtool_ops->get_rxfh(dev, indir, NULL, NULL);
|
2010-06-30 05:05:23 +00:00
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2011-12-15 13:55:01 +00:00
|
|
|
if (copy_to_user(useraddr +
|
|
|
|
|
offsetof(struct ethtool_rxfh_indir, ring_index[0]),
|
|
|
|
|
indir, dev_size * sizeof(indir[0])))
|
2010-06-30 05:05:23 +00:00
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(indir);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
2011-12-15 13:55:01 +00:00
|
|
|
struct ethtool_rxnfc rx_rings;
|
|
|
|
|
u32 user_size, dev_size, i;
|
|
|
|
|
u32 *indir;
|
2013-01-07 09:02:08 +00:00
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
2010-06-30 05:05:23 +00:00
|
|
|
int ret;
|
2014-04-21 10:07:59 +00:00
|
|
|
u32 ringidx_offset = offsetof(struct ethtool_rxfh_indir, ring_index[0]);
|
2010-06-30 05:05:23 +00:00
|
|
|
|
2014-05-15 00:25:27 +00:00
|
|
|
if (!ops->get_rxfh_indir_size || !ops->set_rxfh ||
|
2013-01-07 09:02:08 +00:00
|
|
|
!ops->get_rxnfc)
|
2011-12-15 13:55:01 +00:00
|
|
|
return -EOPNOTSUPP;
|
2013-01-07 09:02:08 +00:00
|
|
|
|
|
|
|
|
dev_size = ops->get_rxfh_indir_size(dev);
|
2011-12-15 13:55:01 +00:00
|
|
|
if (dev_size == 0)
|
2010-06-30 05:05:23 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2011-12-15 13:55:01 +00:00
|
|
|
if (copy_from_user(&user_size,
|
2010-06-30 05:05:23 +00:00
|
|
|
useraddr + offsetof(struct ethtool_rxfh_indir, size),
|
2011-12-15 13:55:01 +00:00
|
|
|
sizeof(user_size)))
|
2010-06-30 05:05:23 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2011-12-15 13:56:49 +00:00
|
|
|
if (user_size != 0 && user_size != dev_size)
|
2011-12-15 13:55:01 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
indir = kcalloc(dev_size, sizeof(indir[0]), GFP_USER);
|
2010-06-30 05:05:23 +00:00
|
|
|
if (!indir)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2011-12-15 13:55:01 +00:00
|
|
|
rx_rings.cmd = ETHTOOL_GRXRINGS;
|
2013-01-07 09:02:08 +00:00
|
|
|
ret = ops->get_rxnfc(dev, &rx_rings, NULL);
|
2011-12-15 13:55:01 +00:00
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
2011-12-15 13:56:49 +00:00
|
|
|
|
|
|
|
|
if (user_size == 0) {
|
|
|
|
|
for (i = 0; i < dev_size; i++)
|
|
|
|
|
indir[i] = ethtool_rxfh_indir_default(i, rx_rings.data);
|
|
|
|
|
} else {
|
2014-04-21 10:07:59 +00:00
|
|
|
ret = ethtool_copy_validate_indir(indir,
|
|
|
|
|
useraddr + ringidx_offset,
|
|
|
|
|
&rx_rings,
|
|
|
|
|
dev_size);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
ret = ops->set_rxfh(dev, indir, NULL, ETH_RSS_HASH_NO_CHANGE);
|
2016-02-09 00:05:03 +00:00
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
/* indicate whether rxfh was set to default */
|
|
|
|
|
if (user_size == 0)
|
|
|
|
|
dev->priv_flags &= ~IFF_RXFH_CONFIGURED;
|
|
|
|
|
else
|
|
|
|
|
dev->priv_flags |= IFF_RXFH_CONFIGURED;
|
2014-04-21 10:07:59 +00:00
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(indir);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline_for_stack int ethtool_get_rxfh(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
2014-05-15 15:28:07 +00:00
|
|
|
u32 user_indir_size, user_key_size;
|
2014-04-21 10:07:59 +00:00
|
|
|
u32 dev_indir_size = 0, dev_key_size = 0;
|
2014-05-15 15:28:07 +00:00
|
|
|
struct ethtool_rxfh rxfh;
|
2014-04-21 10:07:59 +00:00
|
|
|
u32 total_size;
|
2014-05-15 15:28:07 +00:00
|
|
|
u32 indir_bytes;
|
2014-04-21 10:07:59 +00:00
|
|
|
u32 *indir = NULL;
|
2014-12-02 16:12:10 +00:00
|
|
|
u8 dev_hfunc = 0;
|
2014-04-21 10:07:59 +00:00
|
|
|
u8 *hkey = NULL;
|
|
|
|
|
u8 *rss_config;
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
if (!ops->get_rxfh)
|
2014-04-21 10:07:59 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (ops->get_rxfh_indir_size)
|
|
|
|
|
dev_indir_size = ops->get_rxfh_indir_size(dev);
|
|
|
|
|
if (ops->get_rxfh_key_size)
|
|
|
|
|
dev_key_size = ops->get_rxfh_key_size(dev);
|
|
|
|
|
|
2014-05-15 15:28:07 +00:00
|
|
|
if (copy_from_user(&rxfh, useraddr, sizeof(rxfh)))
|
2014-04-21 10:07:59 +00:00
|
|
|
return -EFAULT;
|
2014-05-15 15:28:07 +00:00
|
|
|
user_indir_size = rxfh.indir_size;
|
|
|
|
|
user_key_size = rxfh.key_size;
|
2014-04-21 10:07:59 +00:00
|
|
|
|
2014-05-15 15:28:07 +00:00
|
|
|
/* Check that reserved fields are 0 for now */
|
2014-12-02 16:12:10 +00:00
|
|
|
if (rxfh.rss_context || rxfh.rsvd8[0] || rxfh.rsvd8[1] ||
|
|
|
|
|
rxfh.rsvd8[2] || rxfh.rsvd32)
|
2014-05-15 15:28:07 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
rxfh.indir_size = dev_indir_size;
|
|
|
|
|
rxfh.key_size = dev_key_size;
|
|
|
|
|
if (copy_to_user(useraddr, &rxfh, sizeof(rxfh)))
|
2014-04-21 10:07:59 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if ((user_indir_size && (user_indir_size != dev_indir_size)) ||
|
|
|
|
|
(user_key_size && (user_key_size != dev_key_size)))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
indir_bytes = user_indir_size * sizeof(indir[0]);
|
|
|
|
|
total_size = indir_bytes + user_key_size;
|
|
|
|
|
rss_config = kzalloc(total_size, GFP_USER);
|
|
|
|
|
if (!rss_config)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
if (user_indir_size)
|
|
|
|
|
indir = (u32 *)rss_config;
|
|
|
|
|
|
|
|
|
|
if (user_key_size)
|
|
|
|
|
hkey = rss_config + indir_bytes;
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
ret = dev->ethtool_ops->get_rxfh(dev, indir, hkey, &dev_hfunc);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
2014-04-21 10:07:59 +00:00
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
if (copy_to_user(useraddr + offsetof(struct ethtool_rxfh, hfunc),
|
|
|
|
|
&dev_hfunc, sizeof(rxfh.hfunc))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
} else if (copy_to_user(useraddr +
|
|
|
|
|
offsetof(struct ethtool_rxfh, rss_config[0]),
|
|
|
|
|
rss_config, total_size)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
out:
|
2014-04-21 10:07:59 +00:00
|
|
|
kfree(rss_config);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline_for_stack int ethtool_set_rxfh(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
struct ethtool_rxnfc rx_rings;
|
2014-05-15 15:28:07 +00:00
|
|
|
struct ethtool_rxfh rxfh;
|
|
|
|
|
u32 dev_indir_size = 0, dev_key_size = 0, i;
|
2014-04-21 10:07:59 +00:00
|
|
|
u32 *indir = NULL, indir_bytes = 0;
|
|
|
|
|
u8 *hkey = NULL;
|
|
|
|
|
u8 *rss_config;
|
|
|
|
|
u32 rss_cfg_offset = offsetof(struct ethtool_rxfh, rss_config[0]);
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
if (!ops->get_rxnfc || !ops->set_rxfh)
|
2014-04-21 10:07:59 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (ops->get_rxfh_indir_size)
|
|
|
|
|
dev_indir_size = ops->get_rxfh_indir_size(dev);
|
|
|
|
|
if (ops->get_rxfh_key_size)
|
2015-02-20 10:54:05 +00:00
|
|
|
dev_key_size = ops->get_rxfh_key_size(dev);
|
2014-04-21 10:07:59 +00:00
|
|
|
|
2014-05-15 15:28:07 +00:00
|
|
|
if (copy_from_user(&rxfh, useraddr, sizeof(rxfh)))
|
2014-04-21 10:07:59 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2014-05-15 15:28:07 +00:00
|
|
|
/* Check that reserved fields are 0 for now */
|
2014-12-02 16:12:10 +00:00
|
|
|
if (rxfh.rss_context || rxfh.rsvd8[0] || rxfh.rsvd8[1] ||
|
|
|
|
|
rxfh.rsvd8[2] || rxfh.rsvd32)
|
2014-05-15 15:28:07 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
/* If either indir, hash key or function is valid, proceed further.
|
|
|
|
|
* Must request at least one change: indir size, hash key or function.
|
2014-04-21 10:07:59 +00:00
|
|
|
*/
|
2014-05-15 15:28:07 +00:00
|
|
|
if ((rxfh.indir_size &&
|
|
|
|
|
rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE &&
|
|
|
|
|
rxfh.indir_size != dev_indir_size) ||
|
|
|
|
|
(rxfh.key_size && (rxfh.key_size != dev_key_size)) ||
|
|
|
|
|
(rxfh.indir_size == ETH_RXFH_INDIR_NO_CHANGE &&
|
2014-12-02 16:12:10 +00:00
|
|
|
rxfh.key_size == 0 && rxfh.hfunc == ETH_RSS_HASH_NO_CHANGE))
|
2014-04-21 10:07:59 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2014-05-15 15:28:07 +00:00
|
|
|
if (rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE)
|
2014-04-21 10:07:59 +00:00
|
|
|
indir_bytes = dev_indir_size * sizeof(indir[0]);
|
|
|
|
|
|
2014-05-15 15:28:07 +00:00
|
|
|
rss_config = kzalloc(indir_bytes + rxfh.key_size, GFP_USER);
|
2014-04-21 10:07:59 +00:00
|
|
|
if (!rss_config)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
rx_rings.cmd = ETHTOOL_GRXRINGS;
|
|
|
|
|
ret = ops->get_rxnfc(dev, &rx_rings, NULL);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2014-05-15 15:28:07 +00:00
|
|
|
/* rxfh.indir_size == 0 means reset the indir table to default.
|
|
|
|
|
* rxfh.indir_size == ETH_RXFH_INDIR_NO_CHANGE means leave it unchanged.
|
2014-04-21 10:07:59 +00:00
|
|
|
*/
|
2014-05-15 15:28:07 +00:00
|
|
|
if (rxfh.indir_size &&
|
|
|
|
|
rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE) {
|
2014-04-21 10:07:59 +00:00
|
|
|
indir = (u32 *)rss_config;
|
|
|
|
|
ret = ethtool_copy_validate_indir(indir,
|
|
|
|
|
useraddr + rss_cfg_offset,
|
|
|
|
|
&rx_rings,
|
2014-05-15 15:28:07 +00:00
|
|
|
rxfh.indir_size);
|
2014-04-21 10:07:59 +00:00
|
|
|
if (ret)
|
2011-12-15 13:55:01 +00:00
|
|
|
goto out;
|
2014-05-15 15:28:07 +00:00
|
|
|
} else if (rxfh.indir_size == 0) {
|
2014-04-21 10:07:59 +00:00
|
|
|
indir = (u32 *)rss_config;
|
|
|
|
|
for (i = 0; i < dev_indir_size; i++)
|
|
|
|
|
indir[i] = ethtool_rxfh_indir_default(i, rx_rings.data);
|
|
|
|
|
}
|
2011-12-15 13:56:49 +00:00
|
|
|
|
2014-05-15 15:28:07 +00:00
|
|
|
if (rxfh.key_size) {
|
2014-04-21 10:07:59 +00:00
|
|
|
hkey = rss_config + indir_bytes;
|
|
|
|
|
if (copy_from_user(hkey,
|
|
|
|
|
useraddr + rss_cfg_offset + indir_bytes,
|
2014-05-15 15:28:07 +00:00
|
|
|
rxfh.key_size)) {
|
2014-04-21 10:07:59 +00:00
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
2011-12-15 13:56:49 +00:00
|
|
|
}
|
2011-12-15 13:55:01 +00:00
|
|
|
}
|
|
|
|
|
|
2014-12-02 16:12:10 +00:00
|
|
|
ret = ops->set_rxfh(dev, indir, hkey, rxfh.hfunc);
|
2016-02-09 00:05:03 +00:00
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
/* indicate whether rxfh was set to default */
|
|
|
|
|
if (rxfh.indir_size == 0)
|
|
|
|
|
dev->priv_flags &= ~IFF_RXFH_CONFIGURED;
|
|
|
|
|
else if (rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE)
|
|
|
|
|
dev->priv_flags |= IFF_RXFH_CONFIGURED;
|
2010-06-30 05:05:23 +00:00
|
|
|
|
|
|
|
|
out:
|
2014-04-21 10:07:59 +00:00
|
|
|
kfree(rss_config);
|
2010-06-30 05:05:23 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_regs regs;
|
2006-09-08 18:16:13 +00:00
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
void *regbuf;
|
|
|
|
|
int reglen, ret;
|
|
|
|
|
|
|
|
|
|
if (!ops->get_regs || !ops->get_regs_len)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(®s, useraddr, sizeof(regs)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
reglen = ops->get_regs_len(dev);
|
|
|
|
|
if (regs.len > reglen)
|
|
|
|
|
regs.len = reglen;
|
|
|
|
|
|
2011-01-25 05:05:17 +00:00
|
|
|
regbuf = vzalloc(reglen);
|
2011-07-21 22:25:30 +00:00
|
|
|
if (reglen && !regbuf)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
ops->get_regs(dev, ®s, regbuf);
|
|
|
|
|
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
if (copy_to_user(useraddr, ®s, sizeof(regs)))
|
|
|
|
|
goto out;
|
|
|
|
|
useraddr += offsetof(struct ethtool_regs, data);
|
2011-07-21 22:25:30 +00:00
|
|
|
if (regbuf && copy_to_user(useraddr, regbuf, regs.len))
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
|
|
out:
|
2010-09-20 08:42:17 +00:00
|
|
|
vfree(regbuf);
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2009-10-05 10:59:58 +00:00
|
|
|
static int ethtool_reset(struct net_device *dev, char __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_value reset;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->reset)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&reset, useraddr, sizeof(reset)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
ret = dev->ethtool_ops->reset(dev, &reset.data);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &reset, sizeof(reset)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
|
|
|
|
|
{
|
2010-02-11 20:14:23 +00:00
|
|
|
struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_wol)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
dev->ethtool_ops->get_wol(dev, &wol);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &wol, sizeof(wol)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_wolinfo wol;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->set_wol)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&wol, useraddr, sizeof(wol)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return dev->ethtool_ops->set_wol(dev, &wol);
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-06 17:13:06 +00:00
|
|
|
static int ethtool_get_eee(struct net_device *dev, char __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_eee edata;
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_eee)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
memset(&edata, 0, sizeof(struct ethtool_eee));
|
|
|
|
|
edata.cmd = ETHTOOL_GEEE;
|
|
|
|
|
rc = dev->ethtool_ops->get_eee(dev, &edata);
|
|
|
|
|
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &edata, sizeof(edata)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_set_eee(struct net_device *dev, char __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_eee edata;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->set_eee)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&edata, useraddr, sizeof(edata)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return dev->ethtool_ops->set_eee(dev, &edata);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ethtool_nway_reset(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
if (!dev->ethtool_ops->nway_reset)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
return dev->ethtool_ops->nway_reset(dev);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-09 12:08:35 +00:00
|
|
|
static int ethtool_get_link(struct net_device *dev, char __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_value edata = { .cmd = ETHTOOL_GLINK };
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_link)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
edata.data = netif_running(dev) && dev->ethtool_ops->get_link(dev);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &edata, sizeof(edata)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-12 00:42:12 +00:00
|
|
|
static int ethtool_get_any_eeprom(struct net_device *dev, void __user *useraddr,
|
|
|
|
|
int (*getter)(struct net_device *,
|
|
|
|
|
struct ethtool_eeprom *, u8 *),
|
|
|
|
|
u32 total_len)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_eeprom eeprom;
|
2008-04-16 02:24:17 +00:00
|
|
|
void __user *userbuf = useraddr + sizeof(eeprom);
|
|
|
|
|
u32 bytes_remaining;
|
2005-04-16 22:20:36 +00:00
|
|
|
u8 *data;
|
2008-04-16 02:24:17 +00:00
|
|
|
int ret = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
/* Check for wrap and zero */
|
|
|
|
|
if (eeprom.offset + eeprom.len <= eeprom.offset)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Check for exceeding total eeprom len */
|
2012-04-12 00:42:12 +00:00
|
|
|
if (eeprom.offset + eeprom.len > total_len)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2008-04-16 02:24:17 +00:00
|
|
|
data = kmalloc(PAGE_SIZE, GFP_USER);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2008-04-16 02:24:17 +00:00
|
|
|
bytes_remaining = eeprom.len;
|
|
|
|
|
while (bytes_remaining > 0) {
|
|
|
|
|
eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
|
|
|
|
|
|
2012-04-12 00:42:12 +00:00
|
|
|
ret = getter(dev, &eeprom, data);
|
2008-04-16 02:24:17 +00:00
|
|
|
if (ret)
|
|
|
|
|
break;
|
|
|
|
|
if (copy_to_user(userbuf, data, eeprom.len)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
userbuf += eeprom.len;
|
|
|
|
|
eeprom.offset += eeprom.len;
|
|
|
|
|
bytes_remaining -= eeprom.len;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-25 03:55:56 +00:00
|
|
|
eeprom.len = userbuf - (useraddr + sizeof(eeprom));
|
|
|
|
|
eeprom.offset -= eeprom.len;
|
|
|
|
|
if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-12 00:42:12 +00:00
|
|
|
static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
|
2014-10-31 03:50:15 +00:00
|
|
|
if (!ops->get_eeprom || !ops->get_eeprom_len ||
|
|
|
|
|
!ops->get_eeprom_len(dev))
|
2012-04-12 00:42:12 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
return ethtool_get_any_eeprom(dev, useraddr, ops->get_eeprom,
|
|
|
|
|
ops->get_eeprom_len(dev));
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_eeprom eeprom;
|
2006-09-08 18:16:13 +00:00
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
2008-04-16 02:24:17 +00:00
|
|
|
void __user *userbuf = useraddr + sizeof(eeprom);
|
|
|
|
|
u32 bytes_remaining;
|
2005-04-16 22:20:36 +00:00
|
|
|
u8 *data;
|
2008-04-16 02:24:17 +00:00
|
|
|
int ret = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-10-31 03:50:15 +00:00
|
|
|
if (!ops->set_eeprom || !ops->get_eeprom_len ||
|
|
|
|
|
!ops->get_eeprom_len(dev))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
/* Check for wrap and zero */
|
|
|
|
|
if (eeprom.offset + eeprom.len <= eeprom.offset)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Check for exceeding total eeprom len */
|
|
|
|
|
if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2008-04-16 02:24:17 +00:00
|
|
|
data = kmalloc(PAGE_SIZE, GFP_USER);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2008-04-16 02:24:17 +00:00
|
|
|
bytes_remaining = eeprom.len;
|
|
|
|
|
while (bytes_remaining > 0) {
|
|
|
|
|
eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(data, userbuf, eeprom.len)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
ret = ops->set_eeprom(dev, &eeprom, data);
|
|
|
|
|
if (ret)
|
|
|
|
|
break;
|
|
|
|
|
userbuf += eeprom.len;
|
|
|
|
|
eeprom.offset += eeprom.len;
|
|
|
|
|
bytes_remaining -= eeprom.len;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
kfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-08 04:54:42 +00:00
|
|
|
static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-02-11 20:14:23 +00:00
|
|
|
struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_coalesce)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
dev->ethtool_ops->get_coalesce(dev, &coalesce);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-08 04:54:42 +00:00
|
|
|
static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_coalesce coalesce;
|
|
|
|
|
|
2005-06-06 22:07:19 +00:00
|
|
|
if (!dev->ethtool_ops->set_coalesce)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return dev->ethtool_ops->set_coalesce(dev, &coalesce);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
2010-02-11 20:14:23 +00:00
|
|
|
struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_ringparam)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
dev->ethtool_ops->get_ringparam(dev, &ringparam);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_ringparam ringparam;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->set_ringparam)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return dev->ethtool_ops->set_ringparam(dev, &ringparam);
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-07 01:58:42 +00:00
|
|
|
static noinline_for_stack int ethtool_get_channels(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_channels channels = { .cmd = ETHTOOL_GCHANNELS };
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_channels)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
dev->ethtool_ops->get_channels(dev, &channels);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &channels, sizeof(channels)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static noinline_for_stack int ethtool_set_channels(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
2016-02-09 00:05:04 +00:00
|
|
|
struct ethtool_channels channels, max;
|
2016-02-09 00:05:03 +00:00
|
|
|
u32 max_rx_in_use = 0;
|
2011-04-07 01:58:42 +00:00
|
|
|
|
2016-02-09 00:05:04 +00:00
|
|
|
if (!dev->ethtool_ops->set_channels || !dev->ethtool_ops->get_channels)
|
2011-04-07 01:58:42 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&channels, useraddr, sizeof(channels)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2016-02-09 00:05:04 +00:00
|
|
|
dev->ethtool_ops->get_channels(dev, &max);
|
|
|
|
|
|
|
|
|
|
/* ensure new counts are within the maximums */
|
|
|
|
|
if ((channels.rx_count > max.max_rx) ||
|
|
|
|
|
(channels.tx_count > max.max_tx) ||
|
|
|
|
|
(channels.combined_count > max.max_combined) ||
|
|
|
|
|
(channels.other_count > max.max_other))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2016-02-09 00:05:03 +00:00
|
|
|
/* ensure the new Rx count fits within the configured Rx flow
|
|
|
|
|
* indirection table settings */
|
|
|
|
|
if (netif_is_rxfh_configured(dev) &&
|
|
|
|
|
!ethtool_get_max_rxfh_channel(dev, &max_rx_in_use) &&
|
|
|
|
|
(channels.combined_count + channels.rx_count) <= max_rx_in_use)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-04-07 01:58:42 +00:00
|
|
|
return dev->ethtool_ops->set_channels(dev, &channels);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_pauseparam)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_pauseparam pauseparam;
|
|
|
|
|
|
2006-07-17 16:54:40 +00:00
|
|
|
if (!dev->ethtool_ops->set_pauseparam)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_test test;
|
2006-09-08 18:16:13 +00:00
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
u64 *data;
|
2007-08-15 23:01:08 +00:00
|
|
|
int ret, test_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-10-01 11:33:03 +00:00
|
|
|
if (!ops->self_test || !ops->get_sset_count)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2009-10-01 11:33:03 +00:00
|
|
|
test_len = ops->get_sset_count(dev, ETH_SS_TEST);
|
2007-08-15 23:01:08 +00:00
|
|
|
if (test_len < 0)
|
|
|
|
|
return test_len;
|
|
|
|
|
WARN_ON(test_len == 0);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (copy_from_user(&test, useraddr, sizeof(test)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2007-08-15 23:01:08 +00:00
|
|
|
test.len = test_len;
|
|
|
|
|
data = kmalloc(test_len * sizeof(u64), GFP_USER);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
ops->self_test(dev, &test, data);
|
|
|
|
|
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
if (copy_to_user(useraddr, &test, sizeof(test)))
|
|
|
|
|
goto out;
|
|
|
|
|
useraddr += sizeof(test);
|
|
|
|
|
if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
|
|
|
|
|
goto out;
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_gstrings gstrings;
|
|
|
|
|
u8 *data;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2011-02-15 16:59:16 +00:00
|
|
|
ret = __ethtool_get_sset_count(dev, gstrings.string_set);
|
2009-10-01 11:33:03 +00:00
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
gstrings.len = ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-10-14 08:09:40 +00:00
|
|
|
data = kcalloc(gstrings.len, ETH_GSTRING_LEN, GFP_USER);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2011-02-15 16:59:16 +00:00
|
|
|
__ethtool_get_strings(dev, gstrings.string_set, data);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
|
|
|
|
|
goto out;
|
|
|
|
|
useraddr += sizeof(gstrings);
|
|
|
|
|
if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
|
|
|
|
|
goto out;
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
2011-02-15 16:59:16 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_value id;
|
2011-04-01 23:35:15 +00:00
|
|
|
static bool busy;
|
2013-01-07 09:02:08 +00:00
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
2011-04-01 23:35:15 +00:00
|
|
|
int rc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-01-07 09:02:08 +00:00
|
|
|
if (!ops->set_phys_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2011-04-01 23:35:15 +00:00
|
|
|
if (busy)
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (copy_from_user(&id, useraddr, sizeof(id)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2013-01-07 09:02:08 +00:00
|
|
|
rc = ops->set_phys_id(dev, ETHTOOL_ID_ACTIVE);
|
2011-04-13 13:09:10 +00:00
|
|
|
if (rc < 0)
|
2011-04-01 23:35:15 +00:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
/* Drop the RTNL lock while waiting, but prevent reentry or
|
|
|
|
|
* removal of the device.
|
|
|
|
|
*/
|
|
|
|
|
busy = true;
|
|
|
|
|
dev_hold(dev);
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
|
|
if (rc == 0) {
|
|
|
|
|
/* Driver will handle this itself */
|
|
|
|
|
schedule_timeout_interruptible(
|
2011-04-11 13:01:59 +00:00
|
|
|
id.data ? (id.data * HZ) : MAX_SCHEDULE_TIMEOUT);
|
2011-04-01 23:35:15 +00:00
|
|
|
} else {
|
2011-04-13 13:09:10 +00:00
|
|
|
/* Driver expects to be called at twice the frequency in rc */
|
|
|
|
|
int n = rc * 2, i, interval = HZ / n;
|
|
|
|
|
|
|
|
|
|
/* Count down seconds */
|
2011-04-01 23:35:15 +00:00
|
|
|
do {
|
2011-04-13 13:09:10 +00:00
|
|
|
/* Count down iterations per second */
|
|
|
|
|
i = n;
|
|
|
|
|
do {
|
|
|
|
|
rtnl_lock();
|
2013-01-07 09:02:08 +00:00
|
|
|
rc = ops->set_phys_id(dev,
|
2011-04-13 13:09:10 +00:00
|
|
|
(i & 1) ? ETHTOOL_ID_OFF : ETHTOOL_ID_ON);
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
if (rc)
|
|
|
|
|
break;
|
|
|
|
|
schedule_timeout_interruptible(interval);
|
|
|
|
|
} while (!signal_pending(current) && --i != 0);
|
2011-04-01 23:35:15 +00:00
|
|
|
} while (!signal_pending(current) &&
|
|
|
|
|
(id.data == 0 || --id.data != 0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
dev_put(dev);
|
|
|
|
|
busy = false;
|
|
|
|
|
|
2013-01-07 09:02:08 +00:00
|
|
|
(void) ops->set_phys_id(dev, ETHTOOL_ID_INACTIVE);
|
2011-04-01 23:35:15 +00:00
|
|
|
return rc;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_stats stats;
|
2006-09-08 18:16:13 +00:00
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
u64 *data;
|
2007-08-15 23:01:08 +00:00
|
|
|
int ret, n_stats;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-10-01 11:33:03 +00:00
|
|
|
if (!ops->get_ethtool_stats || !ops->get_sset_count)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2009-10-01 11:33:03 +00:00
|
|
|
n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
|
2007-08-15 23:01:08 +00:00
|
|
|
if (n_stats < 0)
|
|
|
|
|
return n_stats;
|
|
|
|
|
WARN_ON(n_stats == 0);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (copy_from_user(&stats, useraddr, sizeof(stats)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2007-08-15 23:01:08 +00:00
|
|
|
stats.n_stats = n_stats;
|
|
|
|
|
data = kmalloc(n_stats * sizeof(u64), GFP_USER);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
ops->get_ethtool_stats(dev, &stats, data);
|
|
|
|
|
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
if (copy_to_user(useraddr, &stats, sizeof(stats)))
|
|
|
|
|
goto out;
|
|
|
|
|
useraddr += sizeof(stats);
|
|
|
|
|
if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
|
|
|
|
|
goto out;
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-30 15:28:25 +00:00
|
|
|
static int ethtool_get_phy_stats(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_stats stats;
|
|
|
|
|
struct phy_device *phydev = dev->phydev;
|
|
|
|
|
u64 *data;
|
|
|
|
|
int ret, n_stats;
|
|
|
|
|
|
|
|
|
|
if (!phydev)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
n_stats = phy_get_sset_count(phydev);
|
|
|
|
|
|
|
|
|
|
if (n_stats < 0)
|
|
|
|
|
return n_stats;
|
|
|
|
|
WARN_ON(n_stats == 0);
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&stats, useraddr, sizeof(stats)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
stats.n_stats = n_stats;
|
|
|
|
|
data = kmalloc_array(n_stats, sizeof(u64), GFP_USER);
|
|
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&phydev->lock);
|
|
|
|
|
phydev->drv->get_stats(phydev, &stats, data);
|
|
|
|
|
mutex_unlock(&phydev->lock);
|
|
|
|
|
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
if (copy_to_user(useraddr, &stats, sizeof(stats)))
|
|
|
|
|
goto out;
|
|
|
|
|
useraddr += sizeof(stats);
|
|
|
|
|
if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
|
|
|
|
|
goto out;
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2005-09-05 02:26:18 +00:00
|
|
|
static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
|
2005-08-21 00:15:54 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_perm_addr epaddr;
|
|
|
|
|
|
2007-07-31 21:00:29 +00:00
|
|
|
if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
|
2005-08-21 00:15:54 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2007-07-31 21:00:29 +00:00
|
|
|
if (epaddr.size < dev->addr_len)
|
|
|
|
|
return -ETOOSMALL;
|
|
|
|
|
epaddr.size = dev->addr_len;
|
2005-08-21 00:15:54 +00:00
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
|
2007-07-31 21:00:29 +00:00
|
|
|
return -EFAULT;
|
2005-08-21 00:15:54 +00:00
|
|
|
useraddr += sizeof(epaddr);
|
2007-07-31 21:00:29 +00:00
|
|
|
if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
2005-08-21 00:15:54 +00:00
|
|
|
}
|
|
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
|
|
|
|
|
u32 cmd, u32 (*actor)(struct net_device *))
|
2007-08-15 23:00:51 +00:00
|
|
|
{
|
2010-02-11 20:14:23 +00:00
|
|
|
struct ethtool_value edata = { .cmd = cmd };
|
2007-08-15 23:00:51 +00:00
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
if (!actor)
|
2007-08-15 23:00:51 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
edata.data = actor(dev);
|
2007-08-15 23:00:51 +00:00
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &edata, sizeof(edata)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
|
|
|
|
|
void (*actor)(struct net_device *, u32))
|
2007-08-15 23:00:51 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_value edata;
|
|
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
if (!actor)
|
2007-08-15 23:00:51 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&edata, useraddr, sizeof(edata)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
actor(dev, edata.data);
|
2007-08-15 23:01:32 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
|
|
|
|
|
int (*actor)(struct net_device *, u32))
|
2007-08-15 23:01:32 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_value edata;
|
|
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
if (!actor)
|
2007-08-15 23:01:32 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&edata, useraddr, sizeof(edata)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2007-08-15 23:01:56 +00:00
|
|
|
return actor(dev, edata.data);
|
2007-08-15 23:01:32 +00:00
|
|
|
}
|
|
|
|
|
|
2010-04-08 04:54:42 +00:00
|
|
|
static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
|
|
|
|
|
char __user *useraddr)
|
2009-09-02 17:02:55 +00:00
|
|
|
{
|
|
|
|
|
struct ethtool_flash efl;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&efl, useraddr, sizeof(efl)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->flash_device)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2012-02-01 09:32:25 +00:00
|
|
|
efl.data[ETHTOOL_FLASH_MAX_FILENAME - 1] = 0;
|
|
|
|
|
|
2009-09-02 17:02:55 +00:00
|
|
|
return dev->ethtool_ops->flash_device(dev, &efl);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-12 12:48:32 +00:00
|
|
|
static int ethtool_set_dump(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_dump dump;
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->set_dump)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&dump, useraddr, sizeof(dump)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return dev->ethtool_ops->set_dump(dev, &dump);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_get_dump_flag(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct ethtool_dump dump;
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
|
2013-01-07 09:02:08 +00:00
|
|
|
if (!ops->get_dump_flag)
|
2011-05-12 12:48:32 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&dump, useraddr, sizeof(dump)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
ret = ops->get_dump_flag(dev, &dump);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &dump, sizeof(dump)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_get_dump_data(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
__u32 len;
|
|
|
|
|
struct ethtool_dump dump, tmp;
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
void *data = NULL;
|
|
|
|
|
|
2013-01-07 09:02:08 +00:00
|
|
|
if (!ops->get_dump_data || !ops->get_dump_flag)
|
2011-05-12 12:48:32 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&dump, useraddr, sizeof(dump)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
memset(&tmp, 0, sizeof(tmp));
|
|
|
|
|
tmp.cmd = ETHTOOL_GET_DUMP_FLAG;
|
|
|
|
|
ret = ops->get_dump_flag(dev, &tmp);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2013-07-01 15:23:30 +00:00
|
|
|
len = min(tmp.len, dump.len);
|
2011-05-12 12:48:32 +00:00
|
|
|
if (!len)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2013-07-01 15:23:30 +00:00
|
|
|
/* Don't ever let the driver think there's more space available
|
|
|
|
|
* than it requested with .get_dump_flag().
|
|
|
|
|
*/
|
|
|
|
|
dump.len = len;
|
|
|
|
|
|
|
|
|
|
/* Always allocate enough space to hold the whole thing so that the
|
|
|
|
|
* driver does not need to check the length and bother with partial
|
|
|
|
|
* dumping.
|
|
|
|
|
*/
|
2011-05-12 12:48:32 +00:00
|
|
|
data = vzalloc(tmp.len);
|
|
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
ret = ops->get_dump_data(dev, &dump, data);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2013-07-01 15:23:30 +00:00
|
|
|
/* There are two sane possibilities:
|
|
|
|
|
* 1. The driver's .get_dump_data() does not touch dump.len.
|
|
|
|
|
* 2. Or it may set dump.len to how much it really writes, which
|
|
|
|
|
* should be tmp.len (or len if it can do a partial dump).
|
|
|
|
|
* In any case respond to userspace with the actual length of data
|
|
|
|
|
* it's receiving.
|
|
|
|
|
*/
|
|
|
|
|
WARN_ON(dump.len != len && dump.len != tmp.len);
|
|
|
|
|
dump.len = len;
|
|
|
|
|
|
2011-05-12 12:48:32 +00:00
|
|
|
if (copy_to_user(useraddr, &dump, sizeof(dump))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
useraddr += offsetof(struct ethtool_dump, data);
|
|
|
|
|
if (copy_to_user(useraddr, data, len))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
out:
|
|
|
|
|
vfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-03 22:59:17 +00:00
|
|
|
static int ethtool_get_ts_info(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int err = 0;
|
|
|
|
|
struct ethtool_ts_info info;
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
struct phy_device *phydev = dev->phydev;
|
|
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
|
info.cmd = ETHTOOL_GET_TS_INFO;
|
|
|
|
|
|
|
|
|
|
if (phydev && phydev->drv && phydev->drv->ts_info) {
|
|
|
|
|
err = phydev->drv->ts_info(phydev, &info);
|
2013-01-07 09:02:08 +00:00
|
|
|
} else if (ops->get_ts_info) {
|
2012-04-03 22:59:17 +00:00
|
|
|
err = ops->get_ts_info(dev, &info);
|
|
|
|
|
} else {
|
|
|
|
|
info.so_timestamping =
|
|
|
|
|
SOF_TIMESTAMPING_RX_SOFTWARE |
|
|
|
|
|
SOF_TIMESTAMPING_SOFTWARE;
|
|
|
|
|
info.phc_index = -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &info, sizeof(info)))
|
|
|
|
|
err = -EFAULT;
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-03 01:27:56 +00:00
|
|
|
static int __ethtool_get_module_info(struct net_device *dev,
|
|
|
|
|
struct ethtool_modinfo *modinfo)
|
|
|
|
|
{
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
struct phy_device *phydev = dev->phydev;
|
|
|
|
|
|
|
|
|
|
if (phydev && phydev->drv && phydev->drv->module_info)
|
|
|
|
|
return phydev->drv->module_info(phydev, modinfo);
|
|
|
|
|
|
|
|
|
|
if (ops->get_module_info)
|
|
|
|
|
return ops->get_module_info(dev, modinfo);
|
|
|
|
|
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-19 08:44:42 +00:00
|
|
|
static int ethtool_get_module_info(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct ethtool_modinfo modinfo;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&modinfo, useraddr, sizeof(modinfo)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2015-01-03 01:27:56 +00:00
|
|
|
ret = __ethtool_get_module_info(dev, &modinfo);
|
2012-04-19 08:44:42 +00:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(useraddr, &modinfo, sizeof(modinfo)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-03 01:27:56 +00:00
|
|
|
static int __ethtool_get_module_eeprom(struct net_device *dev,
|
|
|
|
|
struct ethtool_eeprom *ee, u8 *data)
|
|
|
|
|
{
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
struct phy_device *phydev = dev->phydev;
|
|
|
|
|
|
|
|
|
|
if (phydev && phydev->drv && phydev->drv->module_eeprom)
|
|
|
|
|
return phydev->drv->module_eeprom(phydev, ee, data);
|
|
|
|
|
|
|
|
|
|
if (ops->get_module_eeprom)
|
|
|
|
|
return ops->get_module_eeprom(dev, ee, data);
|
|
|
|
|
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-19 08:44:42 +00:00
|
|
|
static int ethtool_get_module_eeprom(struct net_device *dev,
|
|
|
|
|
void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct ethtool_modinfo modinfo;
|
|
|
|
|
|
2015-01-03 01:27:56 +00:00
|
|
|
ret = __ethtool_get_module_info(dev, &modinfo);
|
2012-04-19 08:44:42 +00:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2015-01-03 01:27:56 +00:00
|
|
|
return ethtool_get_any_eeprom(dev, useraddr,
|
|
|
|
|
__ethtool_get_module_eeprom,
|
2012-04-19 08:44:42 +00:00
|
|
|
modinfo.eeprom_len);
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-02 21:47:20 +00:00
|
|
|
static int ethtool_tunable_valid(const struct ethtool_tunable *tuna)
|
|
|
|
|
{
|
|
|
|
|
switch (tuna->id) {
|
|
|
|
|
case ETHTOOL_RX_COPYBREAK:
|
2014-10-05 09:35:21 +00:00
|
|
|
case ETHTOOL_TX_COPYBREAK:
|
2014-09-02 21:47:20 +00:00
|
|
|
if (tuna->len != sizeof(u32) ||
|
|
|
|
|
tuna->type_id != ETHTOOL_TUNABLE_U32)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_get_tunable(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct ethtool_tunable tuna;
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
|
|
if (!ops->get_tunable)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
if (copy_from_user(&tuna, useraddr, sizeof(tuna)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
ret = ethtool_tunable_valid(&tuna);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
data = kmalloc(tuna.len, GFP_USER);
|
|
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
ret = ops->get_tunable(dev, &tuna, data);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
useraddr += sizeof(tuna);
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
if (copy_to_user(useraddr, data, tuna.len))
|
|
|
|
|
goto out;
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ethtool_set_tunable(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct ethtool_tunable tuna;
|
|
|
|
|
const struct ethtool_ops *ops = dev->ethtool_ops;
|
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
|
|
if (!ops->set_tunable)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
if (copy_from_user(&tuna, useraddr, sizeof(tuna)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
ret = ethtool_tunable_valid(&tuna);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
data = kmalloc(tuna.len, GFP_USER);
|
|
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
useraddr += sizeof(tuna);
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
if (copy_from_user(data, useraddr, tuna.len))
|
|
|
|
|
goto out;
|
|
|
|
|
ret = ops->set_tunable(dev, &tuna, data);
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
kfree(data);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-19 14:24:02 +00:00
|
|
|
static int ethtool_get_per_queue_coalesce(struct net_device *dev,
|
|
|
|
|
void __user *useraddr,
|
|
|
|
|
struct ethtool_per_queue_op *per_queue_opt)
|
|
|
|
|
{
|
|
|
|
|
u32 bit;
|
|
|
|
|
int ret;
|
|
|
|
|
DECLARE_BITMAP(queue_mask, MAX_NUM_QUEUE);
|
|
|
|
|
|
|
|
|
|
if (!dev->ethtool_ops->get_per_queue_coalesce)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
useraddr += sizeof(*per_queue_opt);
|
|
|
|
|
|
|
|
|
|
bitmap_from_u32array(queue_mask,
|
|
|
|
|
MAX_NUM_QUEUE,
|
|
|
|
|
per_queue_opt->queue_mask,
|
|
|
|
|
DIV_ROUND_UP(MAX_NUM_QUEUE, 32));
|
|
|
|
|
|
|
|
|
|
for_each_set_bit(bit, queue_mask, MAX_NUM_QUEUE) {
|
|
|
|
|
struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
|
|
|
|
|
|
|
|
|
|
ret = dev->ethtool_ops->get_per_queue_coalesce(dev, bit, &coalesce);
|
|
|
|
|
if (ret != 0)
|
|
|
|
|
return ret;
|
|
|
|
|
if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
useraddr += sizeof(coalesce);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-19 14:24:03 +00:00
|
|
|
static int ethtool_set_per_queue_coalesce(struct net_device *dev,
|
|
|
|
|
void __user *useraddr,
|
|
|
|
|
struct ethtool_per_queue_op *per_queue_opt)
|
|
|
|
|
{
|
|
|
|
|
u32 bit;
|
|
|
|
|
int i, ret = 0;
|
|
|
|
|
int n_queue;
|
|
|
|
|
struct ethtool_coalesce *backup = NULL, *tmp = NULL;
|
|
|
|
|
DECLARE_BITMAP(queue_mask, MAX_NUM_QUEUE);
|
|
|
|
|
|
|
|
|
|
if ((!dev->ethtool_ops->set_per_queue_coalesce) ||
|
|
|
|
|
(!dev->ethtool_ops->get_per_queue_coalesce))
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
useraddr += sizeof(*per_queue_opt);
|
|
|
|
|
|
|
|
|
|
bitmap_from_u32array(queue_mask,
|
|
|
|
|
MAX_NUM_QUEUE,
|
|
|
|
|
per_queue_opt->queue_mask,
|
|
|
|
|
DIV_ROUND_UP(MAX_NUM_QUEUE, 32));
|
|
|
|
|
n_queue = bitmap_weight(queue_mask, MAX_NUM_QUEUE);
|
|
|
|
|
tmp = backup = kmalloc_array(n_queue, sizeof(*backup), GFP_KERNEL);
|
|
|
|
|
if (!backup)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
for_each_set_bit(bit, queue_mask, MAX_NUM_QUEUE) {
|
|
|
|
|
struct ethtool_coalesce coalesce;
|
|
|
|
|
|
|
|
|
|
ret = dev->ethtool_ops->get_per_queue_coalesce(dev, bit, tmp);
|
|
|
|
|
if (ret != 0)
|
|
|
|
|
goto roll_back;
|
|
|
|
|
|
|
|
|
|
tmp++;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&coalesce, useraddr, sizeof(coalesce))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto roll_back;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = dev->ethtool_ops->set_per_queue_coalesce(dev, bit, &coalesce);
|
|
|
|
|
if (ret != 0)
|
|
|
|
|
goto roll_back;
|
|
|
|
|
|
|
|
|
|
useraddr += sizeof(coalesce);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
roll_back:
|
|
|
|
|
if (ret != 0) {
|
|
|
|
|
tmp = backup;
|
|
|
|
|
for_each_set_bit(i, queue_mask, bit) {
|
|
|
|
|
dev->ethtool_ops->set_per_queue_coalesce(dev, i, tmp);
|
|
|
|
|
tmp++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
kfree(backup);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-19 14:24:01 +00:00
|
|
|
static int ethtool_set_per_queue(struct net_device *dev, void __user *useraddr)
|
|
|
|
|
{
|
|
|
|
|
struct ethtool_per_queue_op per_queue_opt;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&per_queue_opt, useraddr, sizeof(per_queue_opt)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
switch (per_queue_opt.sub_command) {
|
2016-02-19 14:24:02 +00:00
|
|
|
case ETHTOOL_GCOALESCE:
|
|
|
|
|
return ethtool_get_per_queue_coalesce(dev, useraddr, &per_queue_opt);
|
2016-02-19 14:24:03 +00:00
|
|
|
case ETHTOOL_SCOALESCE:
|
|
|
|
|
return ethtool_set_per_queue_coalesce(dev, useraddr, &per_queue_opt);
|
2016-02-19 14:24:01 +00:00
|
|
|
default:
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-03 02:03:34 +00:00
|
|
|
/* The main entry point in this file. Called from net/core/dev_ioctl.c */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-17 18:56:21 +00:00
|
|
|
int dev_ethtool(struct net *net, struct ifreq *ifr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-17 18:56:21 +00:00
|
|
|
struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
|
2005-04-16 22:20:36 +00:00
|
|
|
void __user *useraddr = ifr->ifr_data;
|
2016-02-19 14:24:01 +00:00
|
|
|
u32 ethcmd, sub_cmd;
|
2005-04-16 22:20:36 +00:00
|
|
|
int rc;
|
2013-05-01 23:06:42 +00:00
|
|
|
netdev_features_t old_features;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
if (!dev || !netif_device_present(dev))
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
2010-04-08 04:54:42 +00:00
|
|
|
if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2016-02-19 14:24:01 +00:00
|
|
|
if (ethcmd == ETHTOOL_PERQUEUE) {
|
|
|
|
|
if (copy_from_user(&sub_cmd, useraddr + sizeof(ethcmd), sizeof(sub_cmd)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
} else {
|
|
|
|
|
sub_cmd = ethcmd;
|
|
|
|
|
}
|
2006-09-28 22:13:37 +00:00
|
|
|
/* Allow some commands to be done by anyone */
|
2016-02-19 14:24:01 +00:00
|
|
|
switch (sub_cmd) {
|
2010-08-23 10:24:18 +00:00
|
|
|
case ETHTOOL_GSET:
|
2006-09-28 22:13:37 +00:00
|
|
|
case ETHTOOL_GDRVINFO:
|
|
|
|
|
case ETHTOOL_GMSGLVL:
|
2012-06-12 13:05:41 +00:00
|
|
|
case ETHTOOL_GLINK:
|
2006-09-28 22:13:37 +00:00
|
|
|
case ETHTOOL_GCOALESCE:
|
|
|
|
|
case ETHTOOL_GRINGPARAM:
|
|
|
|
|
case ETHTOOL_GPAUSEPARAM:
|
|
|
|
|
case ETHTOOL_GRXCSUM:
|
|
|
|
|
case ETHTOOL_GTXCSUM:
|
|
|
|
|
case ETHTOOL_GSG:
|
2012-01-22 00:20:40 +00:00
|
|
|
case ETHTOOL_GSSET_INFO:
|
2006-09-28 22:13:37 +00:00
|
|
|
case ETHTOOL_GSTRINGS:
|
2012-06-12 13:05:41 +00:00
|
|
|
case ETHTOOL_GSTATS:
|
2015-12-30 15:28:25 +00:00
|
|
|
case ETHTOOL_GPHYSTATS:
|
2006-09-28 22:13:37 +00:00
|
|
|
case ETHTOOL_GTSO:
|
|
|
|
|
case ETHTOOL_GPERMADDR:
|
|
|
|
|
case ETHTOOL_GUFO:
|
|
|
|
|
case ETHTOOL_GGSO:
|
2010-02-11 13:48:29 +00:00
|
|
|
case ETHTOOL_GGRO:
|
2007-08-15 23:01:32 +00:00
|
|
|
case ETHTOOL_GFLAGS:
|
|
|
|
|
case ETHTOOL_GPFLAGS:
|
2008-07-02 10:47:41 +00:00
|
|
|
case ETHTOOL_GRXFH:
|
2009-02-20 08:58:13 +00:00
|
|
|
case ETHTOOL_GRXRINGS:
|
|
|
|
|
case ETHTOOL_GRXCLSRLCNT:
|
|
|
|
|
case ETHTOOL_GRXCLSRULE:
|
|
|
|
|
case ETHTOOL_GRXCLSRLALL:
|
2012-06-12 13:05:41 +00:00
|
|
|
case ETHTOOL_GRXFHINDIR:
|
2014-04-21 10:07:59 +00:00
|
|
|
case ETHTOOL_GRSSH:
|
2011-02-15 16:59:17 +00:00
|
|
|
case ETHTOOL_GFEATURES:
|
2012-06-12 13:05:41 +00:00
|
|
|
case ETHTOOL_GCHANNELS:
|
2012-04-03 22:59:17 +00:00
|
|
|
case ETHTOOL_GET_TS_INFO:
|
2012-06-12 13:05:41 +00:00
|
|
|
case ETHTOOL_GEEE:
|
2014-09-02 21:47:20 +00:00
|
|
|
case ETHTOOL_GTUNABLE:
|
2006-09-28 22:13:37 +00:00
|
|
|
break;
|
|
|
|
|
default:
|
2012-11-16 03:03:04 +00:00
|
|
|
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
|
2006-09-28 22:13:37 +00:00
|
|
|
return -EPERM;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-08 04:54:42 +00:00
|
|
|
if (dev->ethtool_ops->begin) {
|
|
|
|
|
rc = dev->ethtool_ops->begin(dev);
|
|
|
|
|
if (rc < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return rc;
|
2010-04-08 04:54:42 +00:00
|
|
|
}
|
2005-05-29 21:13:47 +00:00
|
|
|
old_features = dev->features;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (ethcmd) {
|
|
|
|
|
case ETHTOOL_GSET:
|
|
|
|
|
rc = ethtool_get_settings(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SSET:
|
|
|
|
|
rc = ethtool_set_settings(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GDRVINFO:
|
|
|
|
|
rc = ethtool_get_drvinfo(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GREGS:
|
|
|
|
|
rc = ethtool_get_regs(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GWOL:
|
|
|
|
|
rc = ethtool_get_wol(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SWOL:
|
|
|
|
|
rc = ethtool_set_wol(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GMSGLVL:
|
2007-08-15 23:01:56 +00:00
|
|
|
rc = ethtool_get_value(dev, useraddr, ethcmd,
|
|
|
|
|
dev->ethtool_ops->get_msglevel);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SMSGLVL:
|
2007-08-15 23:01:56 +00:00
|
|
|
rc = ethtool_set_value_void(dev, useraddr,
|
|
|
|
|
dev->ethtool_ops->set_msglevel);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2012-06-06 17:13:06 +00:00
|
|
|
case ETHTOOL_GEEE:
|
|
|
|
|
rc = ethtool_get_eee(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SEEE:
|
|
|
|
|
rc = ethtool_set_eee(dev, useraddr);
|
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
case ETHTOOL_NWAY_RST:
|
|
|
|
|
rc = ethtool_nway_reset(dev);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GLINK:
|
2010-12-09 12:08:35 +00:00
|
|
|
rc = ethtool_get_link(dev, useraddr);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GEEPROM:
|
|
|
|
|
rc = ethtool_get_eeprom(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SEEPROM:
|
|
|
|
|
rc = ethtool_set_eeprom(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GCOALESCE:
|
|
|
|
|
rc = ethtool_get_coalesce(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SCOALESCE:
|
|
|
|
|
rc = ethtool_set_coalesce(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GRINGPARAM:
|
|
|
|
|
rc = ethtool_get_ringparam(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SRINGPARAM:
|
|
|
|
|
rc = ethtool_set_ringparam(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GPAUSEPARAM:
|
|
|
|
|
rc = ethtool_get_pauseparam(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SPAUSEPARAM:
|
|
|
|
|
rc = ethtool_set_pauseparam(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_TEST:
|
|
|
|
|
rc = ethtool_self_test(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GSTRINGS:
|
|
|
|
|
rc = ethtool_get_strings(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_PHYS_ID:
|
|
|
|
|
rc = ethtool_phys_id(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GSTATS:
|
|
|
|
|
rc = ethtool_get_stats(dev, useraddr);
|
|
|
|
|
break;
|
2005-08-21 00:15:54 +00:00
|
|
|
case ETHTOOL_GPERMADDR:
|
|
|
|
|
rc = ethtool_get_perm_addr(dev, useraddr);
|
|
|
|
|
break;
|
2007-08-15 23:00:51 +00:00
|
|
|
case ETHTOOL_GFLAGS:
|
2007-08-15 23:01:56 +00:00
|
|
|
rc = ethtool_get_value(dev, useraddr, ethcmd,
|
2011-11-15 15:29:55 +00:00
|
|
|
__ethtool_get_flags);
|
2007-08-15 23:00:51 +00:00
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SFLAGS:
|
2011-02-15 16:59:18 +00:00
|
|
|
rc = ethtool_set_value(dev, useraddr, __ethtool_set_flags);
|
2007-08-15 23:00:51 +00:00
|
|
|
break;
|
2007-08-15 23:01:32 +00:00
|
|
|
case ETHTOOL_GPFLAGS:
|
2007-08-15 23:01:56 +00:00
|
|
|
rc = ethtool_get_value(dev, useraddr, ethcmd,
|
|
|
|
|
dev->ethtool_ops->get_priv_flags);
|
2007-08-15 23:01:32 +00:00
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SPFLAGS:
|
2007-08-15 23:01:56 +00:00
|
|
|
rc = ethtool_set_value(dev, useraddr,
|
|
|
|
|
dev->ethtool_ops->set_priv_flags);
|
2007-08-15 23:01:32 +00:00
|
|
|
break;
|
2008-07-02 10:47:41 +00:00
|
|
|
case ETHTOOL_GRXFH:
|
2009-02-20 08:58:13 +00:00
|
|
|
case ETHTOOL_GRXRINGS:
|
|
|
|
|
case ETHTOOL_GRXCLSRLCNT:
|
|
|
|
|
case ETHTOOL_GRXCLSRULE:
|
|
|
|
|
case ETHTOOL_GRXCLSRLALL:
|
2010-06-28 08:45:58 +00:00
|
|
|
rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
|
2008-07-02 10:47:41 +00:00
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SRXFH:
|
2009-02-20 08:58:13 +00:00
|
|
|
case ETHTOOL_SRXCLSRLDEL:
|
|
|
|
|
case ETHTOOL_SRXCLSRLINS:
|
2010-06-28 08:45:58 +00:00
|
|
|
rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
|
2008-07-02 10:47:41 +00:00
|
|
|
break;
|
2009-09-02 17:02:55 +00:00
|
|
|
case ETHTOOL_FLASHDEV:
|
|
|
|
|
rc = ethtool_flash_device(dev, useraddr);
|
|
|
|
|
break;
|
2009-10-05 10:59:58 +00:00
|
|
|
case ETHTOOL_RESET:
|
|
|
|
|
rc = ethtool_reset(dev, useraddr);
|
|
|
|
|
break;
|
2010-03-03 22:51:50 +00:00
|
|
|
case ETHTOOL_GSSET_INFO:
|
|
|
|
|
rc = ethtool_get_sset_info(dev, useraddr);
|
|
|
|
|
break;
|
2010-06-30 05:05:23 +00:00
|
|
|
case ETHTOOL_GRXFHINDIR:
|
|
|
|
|
rc = ethtool_get_rxfh_indir(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SRXFHINDIR:
|
|
|
|
|
rc = ethtool_set_rxfh_indir(dev, useraddr);
|
|
|
|
|
break;
|
2014-04-21 10:07:59 +00:00
|
|
|
case ETHTOOL_GRSSH:
|
|
|
|
|
rc = ethtool_get_rxfh(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SRSSH:
|
|
|
|
|
rc = ethtool_set_rxfh(dev, useraddr);
|
|
|
|
|
break;
|
2011-02-15 16:59:17 +00:00
|
|
|
case ETHTOOL_GFEATURES:
|
|
|
|
|
rc = ethtool_get_features(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SFEATURES:
|
|
|
|
|
rc = ethtool_set_features(dev, useraddr);
|
|
|
|
|
break;
|
2011-02-15 16:59:17 +00:00
|
|
|
case ETHTOOL_GTXCSUM:
|
2011-02-15 16:59:18 +00:00
|
|
|
case ETHTOOL_GRXCSUM:
|
2011-02-15 16:59:17 +00:00
|
|
|
case ETHTOOL_GSG:
|
|
|
|
|
case ETHTOOL_GTSO:
|
|
|
|
|
case ETHTOOL_GUFO:
|
|
|
|
|
case ETHTOOL_GGSO:
|
|
|
|
|
case ETHTOOL_GGRO:
|
|
|
|
|
rc = ethtool_get_one_feature(dev, useraddr, ethcmd);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_STXCSUM:
|
2011-02-15 16:59:18 +00:00
|
|
|
case ETHTOOL_SRXCSUM:
|
2011-02-15 16:59:17 +00:00
|
|
|
case ETHTOOL_SSG:
|
|
|
|
|
case ETHTOOL_STSO:
|
|
|
|
|
case ETHTOOL_SUFO:
|
|
|
|
|
case ETHTOOL_SGSO:
|
|
|
|
|
case ETHTOOL_SGRO:
|
|
|
|
|
rc = ethtool_set_one_feature(dev, useraddr, ethcmd);
|
|
|
|
|
break;
|
2011-04-07 01:58:42 +00:00
|
|
|
case ETHTOOL_GCHANNELS:
|
|
|
|
|
rc = ethtool_get_channels(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SCHANNELS:
|
|
|
|
|
rc = ethtool_set_channels(dev, useraddr);
|
|
|
|
|
break;
|
2011-05-12 12:48:32 +00:00
|
|
|
case ETHTOOL_SET_DUMP:
|
|
|
|
|
rc = ethtool_set_dump(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GET_DUMP_FLAG:
|
|
|
|
|
rc = ethtool_get_dump_flag(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GET_DUMP_DATA:
|
|
|
|
|
rc = ethtool_get_dump_data(dev, useraddr);
|
|
|
|
|
break;
|
2012-04-03 22:59:17 +00:00
|
|
|
case ETHTOOL_GET_TS_INFO:
|
|
|
|
|
rc = ethtool_get_ts_info(dev, useraddr);
|
|
|
|
|
break;
|
2012-04-19 08:44:42 +00:00
|
|
|
case ETHTOOL_GMODULEINFO:
|
|
|
|
|
rc = ethtool_get_module_info(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_GMODULEEEPROM:
|
|
|
|
|
rc = ethtool_get_module_eeprom(dev, useraddr);
|
|
|
|
|
break;
|
2014-09-02 21:47:20 +00:00
|
|
|
case ETHTOOL_GTUNABLE:
|
|
|
|
|
rc = ethtool_get_tunable(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_STUNABLE:
|
|
|
|
|
rc = ethtool_set_tunable(dev, useraddr);
|
|
|
|
|
break;
|
2015-12-30 15:28:25 +00:00
|
|
|
case ETHTOOL_GPHYSTATS:
|
|
|
|
|
rc = ethtool_get_phy_stats(dev, useraddr);
|
|
|
|
|
break;
|
2016-02-19 14:24:01 +00:00
|
|
|
case ETHTOOL_PERQUEUE:
|
|
|
|
|
rc = ethtool_set_per_queue(dev, useraddr);
|
|
|
|
|
break;
|
net: ethtool: add new ETHTOOL_xLINKSETTINGS API
This patch defines a new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API,
handled by the new get_link_ksettings/set_link_ksettings callbacks.
This API provides support for most legacy ethtool_cmd fields, adds
support for larger link mode masks (up to 4064 bits, variable length),
and removes ethtool_cmd deprecated
fields (transceiver/maxrxpkt/maxtxpkt).
This API is deprecating the legacy ETHTOOL_GSET/SSET API and provides
the following backward compatibility properties:
- legacy ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks.
- legacy ethtool with new get/set_link_ksettings drivers: the new
driver callbacks are used, data internally converted to legacy
ethtool_cmd. ETHTOOL_GSET will return only the 1st 32b of each link
mode mask. ETHTOOL_SSET will fail if user tries to set the
ethtool_cmd deprecated fields to
non-0 (transceiver/maxrxpkt/maxtxpkt). A kernel warning is logged if
driver sets higher bits.
- future ethtool with legacy drivers: no change, still using the
get_settings/set_settings callbacks, internally converted to new data
structure. Deprecated fields (transceiver/maxrxpkt/maxtxpkt) will be
ignored and seen as 0 from user space. Note that that "future"
ethtool tool will not allow changes to these deprecated fields.
- future ethtool with new drivers: direct call to the new callbacks.
By "future" ethtool, what is meant is:
- query: first try ETHTOOL_GLINKSETTINGS, and revert to ETHTOOL_GSET if
fails
- set: query first and remember which of ETHTOOL_GLINKSETTINGS or
ETHTOOL_GSET was successful
+ if ETHTOOL_GLINKSETTINGS was successful, then change config with
ETHTOOL_SLINKSETTINGS. A failure there is final (do not try
ETHTOOL_SSET).
+ otherwise ETHTOOL_GSET was successful, change config with
ETHTOOL_SSET. A failure there is final (do not try
ETHTOOL_SLINKSETTINGS).
The interaction user/kernel via the new API requires a small
ETHTOOL_GLINKSETTINGS handshake first to agree on the length of the link
mode bitmaps. If kernel doesn't agree with user, it returns the bitmap
length it is expecting from user as a negative length (and cmd field is
0). When kernel and user agree, kernel returns valid info in all
fields (ie. link mode length > 0 and cmd is ETHTOOL_GLINKSETTINGS).
Data structure crossing user/kernel boundary is 32/64-bit
agnostic. Converted internally to a legal kernel bitmap.
The internal __ethtool_get_settings kernel helper will gradually be
replaced by __ethtool_get_link_ksettings by the time the first
"link_settings" drivers start to appear. So this patch doesn't change
it, it will be removed before it needs to be changed.
Signed-off-by: David Decotigny <decot@googlers.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-02-24 18:57:59 +00:00
|
|
|
case ETHTOOL_GLINKSETTINGS:
|
|
|
|
|
rc = ethtool_get_link_ksettings(dev, useraddr);
|
|
|
|
|
break;
|
|
|
|
|
case ETHTOOL_SLINKSETTINGS:
|
|
|
|
|
rc = ethtool_set_link_ksettings(dev, useraddr);
|
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
default:
|
2007-07-31 21:00:02 +00:00
|
|
|
rc = -EOPNOTSUPP;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-02-09 14:24:36 +00:00
|
|
|
|
2007-04-11 03:10:33 +00:00
|
|
|
if (dev->ethtool_ops->complete)
|
2005-04-16 22:20:36 +00:00
|
|
|
dev->ethtool_ops->complete(dev);
|
2005-05-29 21:13:47 +00:00
|
|
|
|
|
|
|
|
if (old_features != dev->features)
|
|
|
|
|
netdev_features_change(dev);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return rc;
|
|
|
|
|
}
|
