/* * 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.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_TSO6_BIT] =             "tx-tcp6-segmentation",	[NETIF_F_FSO_BIT] =              "tx-fcoe-segmentation",	[NETIF_F_GSO_GRE_BIT] =		 "tx-gre-segmentation",	[NETIF_F_GSO_IPIP_BIT] =	 "tx-ipip-segmentation",	[NETIF_F_GSO_SIT_BIT] =		 "tx-sit-segmentation",	[NETIF_F_GSO_UDP_TUNNEL_BIT] =	 "tx-udp_tnl-segmentation",	[NETIF_F_GSO_MPLS_BIT] =	 "tx-mpls-segmentation", 	[NETIF_F_FCOE_CRC_BIT] =         "tx-checksum-fcoe-crc",	[NETIF_F_SCTP_CSUM_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",}; 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 __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 (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		/* 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_ALL_CSUM | NETIF_F_SCTP_CSUM;	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;} int __ethtool_get_settings(struct net_device *dev, struct ethtool_cmd *cmd){	ASSERT_RTNL(); 	if (!dev->ethtool_ops->get_settings)		return -EOPNOTSUPP; 	memset(cmd, 0, sizeof(struct ethtool_cmd));	cmd->cmd = ETHTOOL_GSET;	return dev->ethtool_ops->get_settings(dev, cmd);}EXPORT_SYMBOL(__ethtool_get_settings); static int ethtool_get_settings(struct net_device *dev, void __user *useraddr){	int err;	struct ethtool_cmd cmd; 	err = __ethtool_get_settings(dev, &cmd);	if (err < 0)		return err; 	if (copy_to_user(useraddr, &cmd, sizeof(cmd)))		return -EFAULT;	return 0;} static int ethtool_set_settings(struct net_device *dev, void __user *useraddr){	struct ethtool_cmd cmd; 	if (!dev->ethtool_ops->set_settings)		return -EOPNOTSUPP; 	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))		return -EFAULT; 	return dev->ethtool_ops->set_settings(dev, &cmd);} static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,						  void __user *useraddr){	struct ethtool_drvinfo info;	const struct ethtool_ops *ops = dev->ethtool_ops; 	memset(&info, 0, sizeof(info));	info.cmd = ETHTOOL_GDRVINFO;	if (ops->get_drvinfo) {		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;	} 	/*	 * this method of obtaining string set info is deprecated;	 * Use ETHTOOL_GSSET_INFO instead.	 */	if (ops->get_sset_count) {		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;		rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);		if (rc >= 0)			info.n_priv_flags = rc;	}	if (ops->get_regs_len)		info.regdump_len = ops->get_regs_len(dev);	if (ops->get_eeprom_len)		info.eedump_len = ops->get_eeprom_len(dev); 	if (copy_to_user(useraddr, &info, sizeof(info)))		return -EFAULT;	return 0;} static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,						    void __user *useraddr){	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 */	n_bits = hweight64(sset_mask); 	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; 		rc = __ethtool_get_sset_count(dev, i);		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;} static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,						u32 cmd, void __user *useraddr){	struct ethtool_rxnfc info;	size_t info_size = sizeof(info);	int rc; 	if (!dev->ethtool_ops->set_rxnfc)		return -EOPNOTSUPP; 	/* 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))		return -EFAULT; 	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; 

Lines 1–500 of 1689. Load more