/* * 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 * the information ethtool needs. * * 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. */ #include <linux/module.h>#include <linux/types.h>#include <linux/capability.h>#include <linux/errno.h>#include <linux/ethtool.h>#include <linux/netdevice.h>#include <linux/net_tstamp.h>#include <linux/phy.h>#include <linux/bitops.h>#include <linux/uaccess.h>#include <linux/vmalloc.h>#include <linux/slab.h>#include <linux/rtnetlink.h>#include <linux/sched/signal.h>#include <linux/net.h> /* * 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;}EXPORT_SYMBOL(ethtool_op_get_link); 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); /* Handlers for each ethtool command */ #define ETHTOOL_DEV_FEATURE_WORDS	((NETDEV_FEATURE_COUNT + 31) / 32) 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",	[NETIF_F_HW_VLAN_CTAG_TX_BIT] =  "tx-vlan-hw-insert", 	[NETIF_F_HW_VLAN_CTAG_RX_BIT] =  "rx-vlan-hw-parse",	[NETIF_F_HW_VLAN_CTAG_FILTER_BIT] = "rx-vlan-filter",	[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",	[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_TSO_MANGLEID_BIT] =	 "tx-tcp-mangleid-segmentation",	[NETIF_F_TSO6_BIT] =             "tx-tcp6-segmentation",	[NETIF_F_FSO_BIT] =              "tx-fcoe-segmentation",	[NETIF_F_GSO_GRE_BIT] =		 "tx-gre-segmentation",	[NETIF_F_GSO_GRE_CSUM_BIT] =	 "tx-gre-csum-segmentation",	[NETIF_F_GSO_IPXIP4_BIT] =	 "tx-ipxip4-segmentation",	[NETIF_F_GSO_IPXIP6_BIT] =	 "tx-ipxip6-segmentation",	[NETIF_F_GSO_UDP_TUNNEL_BIT] =	 "tx-udp_tnl-segmentation",	[NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT] = "tx-udp_tnl-csum-segmentation",	[NETIF_F_GSO_PARTIAL_BIT] =	 "tx-gso-partial",	[NETIF_F_GSO_SCTP_BIT] =	 "tx-sctp-segmentation",	[NETIF_F_GSO_ESP_BIT] =		 "tx-esp-segmentation", 	[NETIF_F_FCOE_CRC_BIT] =         "tx-checksum-fcoe-crc",	[NETIF_F_SCTP_CRC_BIT] =        "tx-checksum-sctp",	[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",	[NETIF_F_RXFCS_BIT] =            "rx-fcs",	[NETIF_F_RXALL_BIT] =            "rx-all",	[NETIF_F_HW_L2FW_DOFFLOAD_BIT] = "l2-fwd-offload",	[NETIF_F_HW_TC_BIT] =		 "hw-tc-offload",	[NETIF_F_HW_ESP_BIT] =		 "esp-hw-offload",	[NETIF_F_HW_ESP_TX_CSUM_BIT] =	 "esp-tx-csum-hw-offload",}; static const charrss_hash_func_strings[ETH_RSS_HASH_FUNCS_COUNT][ETH_GSTRING_LEN] = {	[ETH_RSS_HASH_TOP_BIT] =	"toeplitz",	[ETH_RSS_HASH_XOR_BIT] =	"xor",	[ETH_RSS_HASH_CRC32_BIT] =	"crc32",}; static const chartunable_strings[__ETHTOOL_TUNABLE_COUNT][ETH_GSTRING_LEN] = {	[ETHTOOL_ID_UNSPEC]     = "Unspec",	[ETHTOOL_RX_COPYBREAK]	= "rx-copybreak",	[ETHTOOL_TX_COPYBREAK]	= "tx-copybreak",}; static const charphy_tunable_strings[__ETHTOOL_PHY_TUNABLE_COUNT][ETH_GSTRING_LEN] = {	[ETHTOOL_ID_UNSPEC]     = "Unspec",	[ETHTOOL_PHY_DOWNSHIFT]	= "phy-downshift",}; static int ethtool_get_features(struct net_device *dev, void __user *useraddr){	struct ethtool_gfeatures cmd = {		.cmd = ETHTOOL_GFEATURES,		.size = ETHTOOL_DEV_FEATURE_WORDS,	};	struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS];	u32 __user *sizeaddr;	u32 copy_size;	int i; 	/* in case feature bits run out again */	BUILD_BUG_ON(ETHTOOL_DEV_FEATURE_WORDS * sizeof(u32) > sizeof(netdev_features_t)); 	for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; ++i) {		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));	} 	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];	netdev_features_t wanted = 0, valid = 0;	int i, ret = 0; 	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; 	for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; ++i) {		valid |= (netdev_features_t)features[i].valid << (32 * i);		wanted |= (netdev_features_t)features[i].requested << (32 * i);	} 	if (valid & ~NETIF_F_ETHTOOL_BITS)		return -EINVAL; 	if (valid & ~dev->hw_features) {		valid &= dev->hw_features;		ret |= ETHTOOL_F_UNSUPPORTED;	} 	dev->wanted_features &= ~valid;	dev->wanted_features |= wanted & valid;	__netdev_update_features(dev); 	if ((dev->wanted_features ^ dev->features) & valid)		ret |= ETHTOOL_F_WISH; 	return ret;} 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;} static int __ethtool_get_sset_count(struct net_device *dev, int sset){	const struct ethtool_ops *ops = dev->ethtool_ops; 	if (sset == ETH_SS_FEATURES)		return ARRAY_SIZE(netdev_features_strings); 	if (sset == ETH_SS_RSS_HASH_FUNCS)		return ARRAY_SIZE(rss_hash_func_strings); 	if (sset == ETH_SS_TUNABLES)		return ARRAY_SIZE(tunable_strings); 	if (sset == ETH_SS_PHY_TUNABLES)		return ARRAY_SIZE(phy_tunable_strings); 	if (sset == ETH_SS_PHY_STATS) {		if (dev->phydev)			return phy_get_sset_count(dev->phydev);		else			return -EOPNOTSUPP;	} 	if (ops->get_sset_count && ops->get_strings)		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; 	if (stringset == ETH_SS_FEATURES)		memcpy(data, netdev_features_strings,			sizeof(netdev_features_strings));	else if (stringset == ETH_SS_RSS_HASH_FUNCS)		memcpy(data, rss_hash_func_strings,		       sizeof(rss_hash_func_strings));	else if (stringset == ETH_SS_TUNABLES)		memcpy(data, tunable_strings, sizeof(tunable_strings));	else if (stringset == ETH_SS_PHY_TUNABLES)		memcpy(data, phy_tunable_strings, sizeof(phy_tunable_strings));	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		/* ops->get_strings is valid because checked earlier */		ops->get_strings(dev, stringset, data);} static netdev_features_t ethtool_get_feature_mask(u32 eth_cmd){	/* feature masks of legacy discrete ethtool ops */ 	switch (eth_cmd) {	case ETHTOOL_GTXCSUM:	case ETHTOOL_STXCSUM:		return NETIF_F_CSUM_MASK | NETIF_F_SCTP_CRC;	case ETHTOOL_GRXCSUM:	case ETHTOOL_SRXCSUM:		return NETIF_F_RXCSUM;	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){	netdev_features_t mask = ethtool_get_feature_mask(ethcmd);	struct ethtool_value edata = {		.cmd = ethcmd,		.data = !!(dev->features & mask),	}; 	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;	netdev_features_t mask; 	if (copy_from_user(&edata, useraddr, sizeof(edata)))		return -EFAULT; 	mask = ethtool_get_feature_mask(ethcmd);	mask &= dev->hw_features;	if (!mask)		return -EOPNOTSUPP; 	if (edata.data)		dev->wanted_features |= mask;	else		dev->wanted_features &= ~mask; 	__netdev_update_features(dev); 	return 0;} #define ETH_ALL_FLAGS    (ETH_FLAG_LRO | ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN | \			  ETH_FLAG_NTUPLE | ETH_FLAG_RXHASH)#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) static u32 __ethtool_get_flags(struct net_device *dev){	u32 flags = 0; 	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; 	return flags;} static int __ethtool_set_flags(struct net_device *dev, u32 data){	netdev_features_t features = 0, changed; 	if (data & ~ETH_ALL_FLAGS)		return -EINVAL; 	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; 	/* allow changing only bits set in hw_features */	changed = (features ^ dev->features) & ETH_ALL_FEATURES;	if (changed & ~dev->hw_features)		return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP; 	dev->wanted_features =		(dev->wanted_features & ~changed) | (features & changed); 	__netdev_update_features(dev); 	return 0;} void ethtool_convert_legacy_u32_to_link_mode(unsigned long *dst,					     u32 legacy_u32){	bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);	dst[0] = legacy_u32;}EXPORT_SYMBOL(ethtool_convert_legacy_u32_to_link_mode); /* return false if src had higher bits set. lower bits always updated. */bool ethtool_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;}EXPORT_SYMBOL(ethtool_convert_link_mode_to_legacy_u32); /* return false if legacy contained non-0 deprecated fields * transceiver/maxtxpkt/maxrxpkt. rest of ksettings always updated */static boolconvert_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; 	ethtool_convert_legacy_u32_to_link_mode(		link_ksettings->link_modes.supported,		legacy_settings->supported);	ethtool_convert_legacy_u32_to_link_mode(		link_ksettings->link_modes.advertising,		legacy_settings->advertising);	ethtool_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 boolconvert_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));

Lines 1–500 of 2799. Load more