Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit eed2a12f1ed9aabf0676f4d0db34aad51976c5c6

Authored by Mahesh Bandewar 2011-05-04 23:30:11 +0800

Committed by David S. Miller 2011-05-09 06:59:12 +0800

Exists in master and in 7 other branches

net: Allow ethtool to set interface in loopback mode.

This patch enables ethtool to set the loopback mode on a given interface.
By configuring the interface in loopback mode in conjunction with a policy
route / rule, a userland application can stress the egress / ingress path
exposing the flows of the change in progress and potentially help developer(s)
understand the impact of those changes without even sending a packet out
on the network.

Following set of commands illustrates one such example -
    a) ip -4 addr add 192.168.1.1/24 dev eth1
    b) ip -4 rule add from all iif eth1 lookup 250
    c) ip -4 route add local 0/0 dev lo proto kernel scope host table 250
    d) arp -Ds 192.168.1.100 eth1
    e) arp -Ds 192.168.1.200 eth1
    f) sysctl -w net.ipv4.ip_nonlocal_bind=1
    g) sysctl -w net.ipv4.conf.all.accept_local=1
    # Assuming that the machine has 8 cores
    h) taskset 000f netserver -L 192.168.1.200
    i) taskset 00f0 netperf -t TCP_CRR -L 192.168.1.100 -H 192.168.1.200 -l 30

Signed-off-by: Mahesh Bandewar <maheshb@google.com>
Acked-by: Ben Hutchings <bhutchings@solarflare.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 3 changed files with 5 additions and 3 deletions Inline Diff

drivers/net/loopback.c
include/linux/netdevice.h
net/core/ethtool.c

drivers/net/loopback.c

Diff comments View file @ eed2a12

 /*
  * INET		An implementation of the TCP/IP protocol suite for the LINUX
  *		operating system.  INET is implemented using the  BSD Socket
  *		interface as the means of communication with the user level.
  *
  *		Pseudo-driver for the loopback interface.
  *
  * Version:	@(#)loopback.c	1.0.4b	08/16/93
  *
  * Authors:	Ross Biro
  *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  *		Donald Becker, <becker@scyld.com>
  *
  *		Alan Cox	:	Fixed oddments for NET3.014
  *		Alan Cox	:	Rejig for NET3.029 snap #3
  *		Alan Cox	: 	Fixed NET3.029 bugs and sped up
  *		Larry McVoy	:	Tiny tweak to double performance
  *		Alan Cox	:	Backed out LMV's tweak - the linux mm
  *					can't take it...
  *              Michael Griffith:       Don't bother computing the checksums
  *                                      on packets received on the loopback
  *                                      interface.
  *		Alexey Kuznetsov:	Potential hang under some extreme
  *					cases removed.
  *
  *		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/kernel.h>
 #include <linux/jiffies.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/fs.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/errno.h>
 #include <linux/fcntl.h>
 #include <linux/in.h>
 #include <linux/init.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/skbuff.h>
 #include <linux/ethtool.h>
 #include <net/sock.h>
 #include <net/checksum.h>
 #include <linux/if_ether.h>	/* For the statistics structure. */
 #include <linux/if_arp.h>	/* For ARPHRD_ETHER */
 #include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/percpu.h>
 #include <net/net_namespace.h>
 #include <linux/u64_stats_sync.h>
 struct pcpu_lstats {
 	u64			packets;
 	u64			bytes;
 	struct u64_stats_sync	syncp;
 };
 /*
  * The higher levels take care of making this non-reentrant (it's
  * called with bh's disabled).
  */
 static netdev_tx_t loopback_xmit(struct sk_buff *skb,
 				 struct net_device *dev)
 {
 	struct pcpu_lstats *lb_stats;
 	int len;
 	skb_orphan(skb);
 	skb->protocol = eth_type_trans(skb, dev);
 	/* it's OK to use per_cpu_ptr() because BHs are off */
 	lb_stats = this_cpu_ptr(dev->lstats);
 	len = skb->len;
 	if (likely(netif_rx(skb) == NET_RX_SUCCESS)) {
 		u64_stats_update_begin(&lb_stats->syncp);
 		lb_stats->bytes += len;
 		lb_stats->packets++;
 		u64_stats_update_end(&lb_stats->syncp);
 	}
 	return NETDEV_TX_OK;
 }
 static struct rtnl_link_stats64 *loopback_get_stats64(struct net_device *dev,
 						      struct rtnl_link_stats64 *stats)
 {
 	u64 bytes = 0;
 	u64 packets = 0;
 	int i;
 	for_each_possible_cpu(i) {
 		const struct pcpu_lstats *lb_stats;
 		u64 tbytes, tpackets;
 		unsigned int start;
 		lb_stats = per_cpu_ptr(dev->lstats, i);
 		do {
 			start = u64_stats_fetch_begin(&lb_stats->syncp);
 			tbytes = lb_stats->bytes;
 			tpackets = lb_stats->packets;
 		} while (u64_stats_fetch_retry(&lb_stats->syncp, start));
 		bytes   += tbytes;
 		packets += tpackets;
 	}
 	stats->rx_packets = packets;
 	stats->tx_packets = packets;
 	stats->rx_bytes   = bytes;
 	stats->tx_bytes   = bytes;
 	return stats;
 }
 static u32 always_on(struct net_device *dev)
 {
 	return 1;
 }
 static const struct ethtool_ops loopback_ethtool_ops = {
 	.get_link		= always_on,
 };
 static int loopback_dev_init(struct net_device *dev)
 {
 	dev->lstats = alloc_percpu(struct pcpu_lstats);
 	if (!dev->lstats)
 		return -ENOMEM;
 	return 0;
 }
 static void loopback_dev_free(struct net_device *dev)
 {
 	free_percpu(dev->lstats);
 	free_netdev(dev);
 }
 static const struct net_device_ops loopback_ops = {
 	.ndo_init      = loopback_dev_init,
 	.ndo_start_xmit= loopback_xmit,
 	.ndo_get_stats64 = loopback_get_stats64,
 };
 /*
  * The loopback device is special. There is only one instance
  * per network namespace.
  */
 static void loopback_setup(struct net_device *dev)
 {
 	dev->mtu		= (16 * 1024) + 20 + 20 + 12;
 	dev->hard_header_len	= ETH_HLEN;	/* 14	*/
 	dev->addr_len		= ETH_ALEN;	/* 6	*/
 	dev->tx_queue_len	= 0;
 	dev->type		= ARPHRD_LOOPBACK;	/* 0x0001*/
 	dev->flags		= IFF_LOOPBACK;
 	dev->priv_flags	       &= ~IFF_XMIT_DST_RELEASE;
 	dev->hw_features	= NETIF_F_ALL_TSO | NETIF_F_UFO;
 	dev->features 		= NETIF_F_SG | NETIF_F_FRAGLIST
 		| NETIF_F_ALL_TSO
 		| NETIF_F_UFO
 		| NETIF_F_NO_CSUM
 		| NETIF_F_RXCSUM
 		| NETIF_F_HIGHDMA
 		| NETIF_F_LLTX
 		| NETIF_F_NETNS_LOCAL
-		| NETIF_F_VLAN_CHALLENGED;
+		| NETIF_F_VLAN_CHALLENGED
+		| NETIF_F_LOOPBACK;
 	dev->ethtool_ops	= &loopback_ethtool_ops;
 	dev->header_ops		= &eth_header_ops;
 	dev->netdev_ops		= &loopback_ops;
 	dev->destructor		= loopback_dev_free;
 }
 /* Setup and register the loopback device. */
 static __net_init int loopback_net_init(struct net *net)
 {
 	struct net_device *dev;
 	int err;
 	err = -ENOMEM;
 	dev = alloc_netdev(0, "lo", loopback_setup);
 	if (!dev)
 		goto out;
 	dev_net_set(dev, net);
 	err = register_netdev(dev);
 	if (err)
 		goto out_free_netdev;
 	net->loopback_dev = dev;
 	return 0;
 out_free_netdev:
 	free_netdev(dev);
 out:
 	if (net_eq(net, &init_net))
 		panic("loopback: Failed to register netdevice: %d\n", err);
 	return err;
 }
 /* Registered in net/core/dev.c */
 struct pernet_operations __net_initdata loopback_net_ops = {
        .init = loopback_net_init,
 };

include/linux/netdevice.h

Diff comments View file @ eed2a12

 /*
  * INET		An implementation of the TCP/IP protocol suite for the LINUX
  *		operating system.  INET is implemented using the  BSD Socket
  *		interface as the means of communication with the user level.
  *
  *		Definitions for the Interfaces handler.
  *
  * Version:	@(#)dev.h	1.0.10	08/12/93
  *
  * Authors:	Ross Biro
  *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  *		Corey Minyard <wf-rch!minyard@relay.EU.net>
  *		Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
  *		Alan Cox, <alan@lxorguk.ukuu.org.uk>
  *		Bjorn Ekwall. <bj0rn@blox.se>
  *              Pekka Riikonen <priikone@poseidon.pspt.fi>
  *
  *		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.
  *
  *		Moved to /usr/include/linux for NET3
  */
 #ifndef _LINUX_NETDEVICE_H
 #define _LINUX_NETDEVICE_H
 #include <linux/if.h>
 #include <linux/if_ether.h>
 #include <linux/if_packet.h>
 #include <linux/if_link.h>
 #ifdef __KERNEL__
 #include <linux/pm_qos_params.h>
 #include <linux/timer.h>
 #include <linux/delay.h>
 #include <linux/mm.h>
 #include <asm/atomic.h>
 #include <asm/cache.h>
 #include <asm/byteorder.h>
 #include <linux/device.h>
 #include <linux/percpu.h>
 #include <linux/rculist.h>
 #include <linux/dmaengine.h>
 #include <linux/workqueue.h>
 #include <linux/ethtool.h>
 #include <net/net_namespace.h>
 #include <net/dsa.h>
 #ifdef CONFIG_DCB
 #include <net/dcbnl.h>
 #endif
 struct vlan_group;
 struct netpoll_info;
 struct phy_device;
 /* 802.11 specific */
 struct wireless_dev;
 					/* source back-compat hooks */
 #define SET_ETHTOOL_OPS(netdev,ops) \
 	( (netdev)->ethtool_ops = (ops) )
 #define HAVE_ALLOC_NETDEV		/* feature macro: alloc_xxxdev
 					   functions are available. */
 #define HAVE_FREE_NETDEV		/* free_netdev() */
 #define HAVE_NETDEV_PRIV		/* netdev_priv() */
 /* hardware address assignment types */
 #define NET_ADDR_PERM		0	/* address is permanent (default) */
 #define NET_ADDR_RANDOM		1	/* address is generated randomly */
 #define NET_ADDR_STOLEN		2	/* address is stolen from other device */
 /* Backlog congestion levels */
 #define NET_RX_SUCCESS		0	/* keep 'em coming, baby */
 #define NET_RX_DROP		1	/* packet dropped */
 /*
  * Transmit return codes: transmit return codes originate from three different
  * namespaces:
  *
  * - qdisc return codes
  * - driver transmit return codes
  * - errno values
  *
  * Drivers are allowed to return any one of those in their hard_start_xmit()
  * function. Real network devices commonly used with qdiscs should only return
  * the driver transmit return codes though - when qdiscs are used, the actual
  * transmission happens asynchronously, so the value is not propagated to
  * higher layers. Virtual network devices transmit synchronously, in this case
  * the driver transmit return codes are consumed by dev_queue_xmit(), all
  * others are propagated to higher layers.
  */
 /* qdisc ->enqueue() return codes. */
 #define NET_XMIT_SUCCESS	0x00
 #define NET_XMIT_DROP		0x01	/* skb dropped			*/
 #define NET_XMIT_CN		0x02	/* congestion notification	*/
 #define NET_XMIT_POLICED	0x03	/* skb is shot by police	*/
 #define NET_XMIT_MASK		0x0f	/* qdisc flags in net/sch_generic.h */
 /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
  * indicates that the device will soon be dropping packets, or already drops
  * some packets of the same priority; prompting us to send less aggressively. */
 #define net_xmit_eval(e)	((e) == NET_XMIT_CN ? 0 : (e))
 #define net_xmit_errno(e)	((e) != NET_XMIT_CN ? -ENOBUFS : 0)
 /* Driver transmit return codes */
 #define NETDEV_TX_MASK		0xf0
 enum netdev_tx {
 	__NETDEV_TX_MIN	 = INT_MIN,	/* make sure enum is signed */
 	NETDEV_TX_OK	 = 0x00,	/* driver took care of packet */
 	NETDEV_TX_BUSY	 = 0x10,	/* driver tx path was busy*/
 	NETDEV_TX_LOCKED = 0x20,	/* driver tx lock was already taken */
 };
 typedef enum netdev_tx netdev_tx_t;
 /*
  * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
  * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
  */
 static inline bool dev_xmit_complete(int rc)
 {
 	/*
 	 * Positive cases with an skb consumed by a driver:
 	 * - successful transmission (rc == NETDEV_TX_OK)
 	 * - error while transmitting (rc < 0)
 	 * - error while queueing to a different device (rc & NET_XMIT_MASK)
 	 */
 	if (likely(rc < NET_XMIT_MASK))
 		return true;
 	return false;
 }
 #endif
 #define MAX_ADDR_LEN	32		/* Largest hardware address length */
 /* Initial net device group. All devices belong to group 0 by default. */
 #define INIT_NETDEV_GROUP	0
 #ifdef  __KERNEL__
 /*
  *	Compute the worst case header length according to the protocols
  *	used.
  */
 #if defined(CONFIG_WLAN) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 # if defined(CONFIG_MAC80211_MESH)
 #  define LL_MAX_HEADER 128
 # else
 #  define LL_MAX_HEADER 96
 # endif
 #elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
 # define LL_MAX_HEADER 48
 #else
 # define LL_MAX_HEADER 32
 #endif
 #if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
     !defined(CONFIG_NET_IPGRE) &&  !defined(CONFIG_NET_IPGRE_MODULE) && \
     !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
     !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
 #define MAX_HEADER LL_MAX_HEADER
 #else
 #define MAX_HEADER (LL_MAX_HEADER + 48)
 #endif
 /*
  *	Old network device statistics. Fields are native words
  *	(unsigned long) so they can be read and written atomically.
  */
 struct net_device_stats {
 	unsigned long	rx_packets;
 	unsigned long	tx_packets;
 	unsigned long	rx_bytes;
 	unsigned long	tx_bytes;
 	unsigned long	rx_errors;
 	unsigned long	tx_errors;
 	unsigned long	rx_dropped;
 	unsigned long	tx_dropped;
 	unsigned long	multicast;
 	unsigned long	collisions;
 	unsigned long	rx_length_errors;
 	unsigned long	rx_over_errors;
 	unsigned long	rx_crc_errors;
 	unsigned long	rx_frame_errors;
 	unsigned long	rx_fifo_errors;
 	unsigned long	rx_missed_errors;
 	unsigned long	tx_aborted_errors;
 	unsigned long	tx_carrier_errors;
 	unsigned long	tx_fifo_errors;
 	unsigned long	tx_heartbeat_errors;
 	unsigned long	tx_window_errors;
 	unsigned long	rx_compressed;
 	unsigned long	tx_compressed;
 };
 #endif  /*  __KERNEL__  */
 /* Media selection options. */
 enum {
         IF_PORT_UNKNOWN = 0,
         IF_PORT_10BASE2,
         IF_PORT_10BASET,
         IF_PORT_AUI,
         IF_PORT_100BASET,
         IF_PORT_100BASETX,
         IF_PORT_100BASEFX
 };
 #ifdef __KERNEL__
 #include <linux/cache.h>
 #include <linux/skbuff.h>
 struct neighbour;
 struct neigh_parms;
 struct sk_buff;
 struct netdev_hw_addr {
 	struct list_head	list;
 	unsigned char		addr[MAX_ADDR_LEN];
 	unsigned char		type;
 #define NETDEV_HW_ADDR_T_LAN		1
 #define NETDEV_HW_ADDR_T_SAN		2
 #define NETDEV_HW_ADDR_T_SLAVE		3
 #define NETDEV_HW_ADDR_T_UNICAST	4
 #define NETDEV_HW_ADDR_T_MULTICAST	5
 	bool			synced;
 	bool			global_use;
 	int			refcount;
 	struct rcu_head		rcu_head;
 };
 struct netdev_hw_addr_list {
 	struct list_head	list;
 	int			count;
 };
 #define netdev_hw_addr_list_count(l) ((l)->count)
 #define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
 #define netdev_hw_addr_list_for_each(ha, l) \
 	list_for_each_entry(ha, &(l)->list, list)
 #define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
 #define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
 #define netdev_for_each_uc_addr(ha, dev) \
 	netdev_hw_addr_list_for_each(ha, &(dev)->uc)
 #define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
 #define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
 #define netdev_for_each_mc_addr(ha, dev) \
 	netdev_hw_addr_list_for_each(ha, &(dev)->mc)
 struct hh_cache {
 	struct hh_cache *hh_next;	/* Next entry			     */
 	atomic_t	hh_refcnt;	/* number of users                   */
 /*
  * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
  * cache line on SMP.
  * They are mostly read, but hh_refcnt may be changed quite frequently,
  * incurring cache line ping pongs.
  */
 	__be16		hh_type ____cacheline_aligned_in_smp;
 					/* protocol identifier, f.e ETH_P_IP
                                          *  NOTE:  For VLANs, this will be the
                                          *  encapuslated type. --BLG
                                          */
 	u16		hh_len;		/* length of header */
 	int		(*hh_output)(struct sk_buff *skb);
 	seqlock_t	hh_lock;
 	/* cached hardware header; allow for machine alignment needs.        */
 #define HH_DATA_MOD	16
 #define HH_DATA_OFF(__len) \
 	(HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
 #define HH_DATA_ALIGN(__len) \
 	(((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
 	unsigned long	hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
 };
 static inline void hh_cache_put(struct hh_cache *hh)
 {
 	if (atomic_dec_and_test(&hh->hh_refcnt))
 		kfree(hh);
 }
 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  * Alternative is:
  *   dev->hard_header_len ? (dev->hard_header_len +
  *                           (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  *
  * We could use other alignment values, but we must maintain the
  * relationship HH alignment <= LL alignment.
  *
  * LL_ALLOCATED_SPACE also takes into account the tailroom the device
  * may need.
  */
 #define LL_RESERVED_SPACE(dev) \
 	((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
 	((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 #define LL_ALLOCATED_SPACE(dev) \
 	((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 struct header_ops {
 	int	(*create) (struct sk_buff *skb, struct net_device *dev,
 			   unsigned short type, const void *daddr,
 			   const void *saddr, unsigned len);
 	int	(*parse)(const struct sk_buff *skb, unsigned char *haddr);
 	int	(*rebuild)(struct sk_buff *skb);
 #define HAVE_HEADER_CACHE
 	int	(*cache)(const struct neighbour *neigh, struct hh_cache *hh);
 	void	(*cache_update)(struct hh_cache *hh,
 				const struct net_device *dev,
 				const unsigned char *haddr);
 };
 /* These flag bits are private to the generic network queueing
  * layer, they may not be explicitly referenced by any other
  * code.
  */
 enum netdev_state_t {
 	__LINK_STATE_START,
 	__LINK_STATE_PRESENT,
 	__LINK_STATE_NOCARRIER,
 	__LINK_STATE_LINKWATCH_PENDING,
 	__LINK_STATE_DORMANT,
 };
 /*
  * This structure holds at boot time configured netdevice settings. They
  * are then used in the device probing.
  */
 struct netdev_boot_setup {
 	char name[IFNAMSIZ];
 	struct ifmap map;
 };
 #define NETDEV_BOOT_SETUP_MAX 8
 extern int __init netdev_boot_setup(char *str);
 /*
  * Structure for NAPI scheduling similar to tasklet but with weighting
  */
 struct napi_struct {
 	/* The poll_list must only be managed by the entity which
 	 * changes the state of the NAPI_STATE_SCHED bit.  This means
 	 * whoever atomically sets that bit can add this napi_struct
 	 * to the per-cpu poll_list, and whoever clears that bit
 	 * can remove from the list right before clearing the bit.
 	 */
 	struct list_head	poll_list;
 	unsigned long		state;
 	int			weight;
 	int			(*poll)(struct napi_struct *, int);
 #ifdef CONFIG_NETPOLL
 	spinlock_t		poll_lock;
 	int			poll_owner;
 #endif
 	unsigned int		gro_count;
 	struct net_device	*dev;
 	struct list_head	dev_list;
 	struct sk_buff		*gro_list;
 	struct sk_buff		*skb;
 };
 enum {
 	NAPI_STATE_SCHED,	/* Poll is scheduled */
 	NAPI_STATE_DISABLE,	/* Disable pending */
 	NAPI_STATE_NPSVC,	/* Netpoll - don't dequeue from poll_list */
 };
 enum gro_result {
 	GRO_MERGED,
 	GRO_MERGED_FREE,
 	GRO_HELD,
 	GRO_NORMAL,
 	GRO_DROP,
 };
 typedef enum gro_result gro_result_t;
 /*
  * enum rx_handler_result - Possible return values for rx_handlers.
  * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
  * further.
  * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
  * case skb->dev was changed by rx_handler.
  * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
  * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called.
  *
  * rx_handlers are functions called from inside __netif_receive_skb(), to do
  * special processing of the skb, prior to delivery to protocol handlers.
  *
  * Currently, a net_device can only have a single rx_handler registered. Trying
  * to register a second rx_handler will return -EBUSY.
  *
  * To register a rx_handler on a net_device, use netdev_rx_handler_register().
  * To unregister a rx_handler on a net_device, use
  * netdev_rx_handler_unregister().
  *
  * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
  * do with the skb.
  *
  * If the rx_handler consumed to skb in some way, it should return
  * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
  * the skb to be delivered in some other ways.
  *
  * If the rx_handler changed skb->dev, to divert the skb to another
  * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
  * new device will be called if it exists.
  *
  * If the rx_handler consider the skb should be ignored, it should return
  * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
  * are registred on exact device (ptype->dev == skb->dev).
  *
  * If the rx_handler didn't changed skb->dev, but want the skb to be normally
  * delivered, it should return RX_HANDLER_PASS.
  *
  * A device without a registered rx_handler will behave as if rx_handler
  * returned RX_HANDLER_PASS.
  */
 enum rx_handler_result {
 	RX_HANDLER_CONSUMED,
 	RX_HANDLER_ANOTHER,
 	RX_HANDLER_EXACT,
 	RX_HANDLER_PASS,
 };
 typedef enum rx_handler_result rx_handler_result_t;
 typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
 extern void __napi_schedule(struct napi_struct *n);
 static inline int napi_disable_pending(struct napi_struct *n)
 {
 	return test_bit(NAPI_STATE_DISABLE, &n->state);
 }
 /**
  *	napi_schedule_prep - check if napi can be scheduled
  *	@n: napi context
  *
  * Test if NAPI routine is already running, and if not mark
  * it as running.  This is used as a condition variable
  * insure only one NAPI poll instance runs.  We also make
  * sure there is no pending NAPI disable.
  */
 static inline int napi_schedule_prep(struct napi_struct *n)
 {
 	return !napi_disable_pending(n) &&
 		!test_and_set_bit(NAPI_STATE_SCHED, &n->state);
 }
 /**
  *	napi_schedule - schedule NAPI poll
  *	@n: napi context
  *
  * Schedule NAPI poll routine to be called if it is not already
  * running.
  */
 static inline void napi_schedule(struct napi_struct *n)
 {
 	if (napi_schedule_prep(n))
 		__napi_schedule(n);
 }
 /* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
 static inline int napi_reschedule(struct napi_struct *napi)
 {
 	if (napi_schedule_prep(napi)) {
 		__napi_schedule(napi);
 		return 1;
 	}
 	return 0;
 }
 /**
  *	napi_complete - NAPI processing complete
  *	@n: napi context
  *
  * Mark NAPI processing as complete.
  */
 extern void __napi_complete(struct napi_struct *n);
 extern void napi_complete(struct napi_struct *n);
 /**
  *	napi_disable - prevent NAPI from scheduling
  *	@n: napi context
  *
  * Stop NAPI from being scheduled on this context.
  * Waits till any outstanding processing completes.
  */
 static inline void napi_disable(struct napi_struct *n)
 {
 	set_bit(NAPI_STATE_DISABLE, &n->state);
 	while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
 		msleep(1);
 	clear_bit(NAPI_STATE_DISABLE, &n->state);
 }
 /**
  *	napi_enable - enable NAPI scheduling
  *	@n: napi context
  *
  * Resume NAPI from being scheduled on this context.
  * Must be paired with napi_disable.
  */
 static inline void napi_enable(struct napi_struct *n)
 {
 	BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
 	smp_mb__before_clear_bit();
 	clear_bit(NAPI_STATE_SCHED, &n->state);
 }
 #ifdef CONFIG_SMP
 /**
  *	napi_synchronize - wait until NAPI is not running
  *	@n: napi context
  *
  * Wait until NAPI is done being scheduled on this context.
  * Waits till any outstanding processing completes but
  * does not disable future activations.
  */
 static inline void napi_synchronize(const struct napi_struct *n)
 {
 	while (test_bit(NAPI_STATE_SCHED, &n->state))
 		msleep(1);
 }
 #else
 # define napi_synchronize(n)	barrier()
 #endif
 enum netdev_queue_state_t {
 	__QUEUE_STATE_XOFF,
 	__QUEUE_STATE_FROZEN,
 #define QUEUE_STATE_XOFF_OR_FROZEN ((1 << __QUEUE_STATE_XOFF)		| \
 				    (1 << __QUEUE_STATE_FROZEN))
 };
 struct netdev_queue {
 /*
  * read mostly part
  */
 	struct net_device	*dev;
 	struct Qdisc		*qdisc;
 	unsigned long		state;
 	struct Qdisc		*qdisc_sleeping;
 #ifdef CONFIG_RPS
 	struct kobject		kobj;
 #endif
 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
 	int			numa_node;
 #endif
 /*
  * write mostly part
  */
 	spinlock_t		_xmit_lock ____cacheline_aligned_in_smp;
 	int			xmit_lock_owner;
 	/*
 	 * please use this field instead of dev->trans_start
 	 */
 	unsigned long		trans_start;
 } ____cacheline_aligned_in_smp;
 static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
 {
 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
 	return q->numa_node;
 #else
 	return NUMA_NO_NODE;
 #endif
 }
 static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
 {
 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
 	q->numa_node = node;
 #endif
 }
 #ifdef CONFIG_RPS
 /*
  * This structure holds an RPS map which can be of variable length.  The
  * map is an array of CPUs.
  */
 struct rps_map {
 	unsigned int len;
 	struct rcu_head rcu;
 	u16 cpus[0];
 };
 #define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + (_num * sizeof(u16)))
 /*
  * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
  * tail pointer for that CPU's input queue at the time of last enqueue, and
  * a hardware filter index.
  */
 struct rps_dev_flow {
 	u16 cpu;
 	u16 filter;
 	unsigned int last_qtail;
 };
 #define RPS_NO_FILTER 0xffff
 /*
  * The rps_dev_flow_table structure contains a table of flow mappings.
  */
 struct rps_dev_flow_table {
 	unsigned int mask;
 	struct rcu_head rcu;
 	struct work_struct free_work;
 	struct rps_dev_flow flows[0];
 };
 #define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
     (_num * sizeof(struct rps_dev_flow)))
 /*
  * The rps_sock_flow_table contains mappings of flows to the last CPU
  * on which they were processed by the application (set in recvmsg).
  */
 struct rps_sock_flow_table {
 	unsigned int mask;
 	u16 ents[0];
 };
 #define	RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
     (_num * sizeof(u16)))
 #define RPS_NO_CPU 0xffff
 static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
 					u32 hash)
 {
 	if (table && hash) {
 		unsigned int cpu, index = hash & table->mask;
 		/* We only give a hint, preemption can change cpu under us */
 		cpu = raw_smp_processor_id();
 		if (table->ents[index] != cpu)
 			table->ents[index] = cpu;
 	}
 }
 static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
 				       u32 hash)
 {
 	if (table && hash)
 		table->ents[hash & table->mask] = RPS_NO_CPU;
 }
 extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
 #ifdef CONFIG_RFS_ACCEL
 extern bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
 				u32 flow_id, u16 filter_id);
 #endif
 /* This structure contains an instance of an RX queue. */
 struct netdev_rx_queue {
 	struct rps_map __rcu		*rps_map;
 	struct rps_dev_flow_table __rcu	*rps_flow_table;
 	struct kobject			kobj;
 	struct net_device		*dev;
 } ____cacheline_aligned_in_smp;
 #endif /* CONFIG_RPS */
 #ifdef CONFIG_XPS
 /*
  * This structure holds an XPS map which can be of variable length.  The
  * map is an array of queues.
  */
 struct xps_map {
 	unsigned int len;
 	unsigned int alloc_len;
 	struct rcu_head rcu;
 	u16 queues[0];
 };
 #define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + (_num * sizeof(u16)))
 #define XPS_MIN_MAP_ALLOC ((L1_CACHE_BYTES - sizeof(struct xps_map))	\
     / sizeof(u16))
 /*
  * This structure holds all XPS maps for device.  Maps are indexed by CPU.
  */
 struct xps_dev_maps {
 	struct rcu_head rcu;
 	struct xps_map __rcu *cpu_map[0];
 };
 #define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) +		\
     (nr_cpu_ids * sizeof(struct xps_map *)))
 #endif /* CONFIG_XPS */
 #define TC_MAX_QUEUE	16
 #define TC_BITMASK	15
 /* HW offloaded queuing disciplines txq count and offset maps */
 struct netdev_tc_txq {
 	u16 count;
 	u16 offset;
 };
 /*
  * This structure defines the management hooks for network devices.
  * The following hooks can be defined; unless noted otherwise, they are
  * optional and can be filled with a null pointer.
  *
  * int (*ndo_init)(struct net_device *dev);
  *     This function is called once when network device is registered.
  *     The network device can use this to any late stage initializaton
  *     or semantic validattion. It can fail with an error code which will
  *     be propogated back to register_netdev
  *
  * void (*ndo_uninit)(struct net_device *dev);
  *     This function is called when device is unregistered or when registration
  *     fails. It is not called if init fails.
  *
  * int (*ndo_open)(struct net_device *dev);
  *     This function is called when network device transistions to the up
  *     state.
  *
  * int (*ndo_stop)(struct net_device *dev);
  *     This function is called when network device transistions to the down
  *     state.
  *
  * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
  *                               struct net_device *dev);
  *	Called when a packet needs to be transmitted.
  *	Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
  *        (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
  *	Required can not be NULL.
  *
  * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
  *	Called to decide which queue to when device supports multiple
  *	transmit queues.
  *
  * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
  *	This function is called to allow device receiver to make
  *	changes to configuration when multicast or promiscious is enabled.
  *
  * void (*ndo_set_rx_mode)(struct net_device *dev);
  *	This function is called device changes address list filtering.
  *
  * void (*ndo_set_multicast_list)(struct net_device *dev);
  *	This function is called when the multicast address list changes.
  *
  * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
  *	This function  is called when the Media Access Control address
  *	needs to be changed. If this interface is not defined, the
  *	mac address can not be changed.
  *
  * int (*ndo_validate_addr)(struct net_device *dev);
  *	Test if Media Access Control address is valid for the device.
  *
  * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
  *	Called when a user request an ioctl which can't be handled by
  *	the generic interface code. If not defined ioctl's return
  *	not supported error code.
  *
  * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
  *	Used to set network devices bus interface parameters. This interface
  *	is retained for legacy reason, new devices should use the bus
  *	interface (PCI) for low level management.
  *
  * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
  *	Called when a user wants to change the Maximum Transfer Unit
  *	of a device. If not defined, any request to change MTU will
  *	will return an error.
  *
  * void (*ndo_tx_timeout)(struct net_device *dev);
  *	Callback uses when the transmitter has not made any progress
  *	for dev->watchdog ticks.
  *
  * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
  *                      struct rtnl_link_stats64 *storage);
  * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
  *	Called when a user wants to get the network device usage
  *	statistics. Drivers must do one of the following:
  *	1. Define @ndo_get_stats64 to fill in a zero-initialised
  *	   rtnl_link_stats64 structure passed by the caller.
  *	2. Define @ndo_get_stats to update a net_device_stats structure
  *	   (which should normally be dev->stats) and return a pointer to
  *	   it. The structure may be changed asynchronously only if each
  *	   field is written atomically.
  *	3. Update dev->stats asynchronously and atomically, and define
  *	   neither operation.
  *
  * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
  *	If device support VLAN receive acceleration
  *	(ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
  *	when vlan groups for the device changes.  Note: grp is NULL
  *	if no vlan's groups are being used.
  *
  * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
  *	If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
  *	this function is called when a VLAN id is registered.
  *
  * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
  *	If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
  *	this function is called when a VLAN id is unregistered.
  *
  * void (*ndo_poll_controller)(struct net_device *dev);
  *
  *	SR-IOV management functions.
  * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
  * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
  * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate);
  * int (*ndo_get_vf_config)(struct net_device *dev,
  *			    int vf, struct ifla_vf_info *ivf);
  * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
  *			  struct nlattr *port[]);
  * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
  * int (*ndo_setup_tc)(struct net_device *dev, u8 tc)
  * 	Called to setup 'tc' number of traffic classes in the net device. This
  * 	is always called from the stack with the rtnl lock held and netif tx
  * 	queues stopped. This allows the netdevice to perform queue management
  * 	safely.
  *
  *	Fiber Channel over Ethernet (FCoE) offload functions.
  * int (*ndo_fcoe_enable)(struct net_device *dev);
  *	Called when the FCoE protocol stack wants to start using LLD for FCoE
  *	so the underlying device can perform whatever needed configuration or
  *	initialization to support acceleration of FCoE traffic.
  *
  * int (*ndo_fcoe_disable)(struct net_device *dev);
  *	Called when the FCoE protocol stack wants to stop using LLD for FCoE
  *	so the underlying device can perform whatever needed clean-ups to
  *	stop supporting acceleration of FCoE traffic.
  *
  * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
  *			     struct scatterlist *sgl, unsigned int sgc);
  *	Called when the FCoE Initiator wants to initialize an I/O that
  *	is a possible candidate for Direct Data Placement (DDP). The LLD can
  *	perform necessary setup and returns 1 to indicate the device is set up
  *	successfully to perform DDP on this I/O, otherwise this returns 0.
  *
  * int (*ndo_fcoe_ddp_done)(struct net_device *dev,  u16 xid);
  *	Called when the FCoE Initiator/Target is done with the DDPed I/O as
  *	indicated by the FC exchange id 'xid', so the underlying device can
  *	clean up and reuse resources for later DDP requests.
  *
  * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
  *			      struct scatterlist *sgl, unsigned int sgc);
  *	Called when the FCoE Target wants to initialize an I/O that
  *	is a possible candidate for Direct Data Placement (DDP). The LLD can
  *	perform necessary setup and returns 1 to indicate the device is set up
  *	successfully to perform DDP on this I/O, otherwise this returns 0.
  *
  * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
  *	Called when the underlying device wants to override default World Wide
  *	Name (WWN) generation mechanism in FCoE protocol stack to pass its own
  *	World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
  *	protocol stack to use.
  *
  *	RFS acceleration.
  * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
  *			    u16 rxq_index, u32 flow_id);
  *	Set hardware filter for RFS.  rxq_index is the target queue index;
  *	flow_id is a flow ID to be passed to rps_may_expire_flow() later.
  *	Return the filter ID on success, or a negative error code.
  *
  *	Slave management functions (for bridge, bonding, etc). User should
  *	call netdev_set_master() to set dev->master properly.
  * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
  *	Called to make another netdev an underling.
  *
  * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
  *	Called to release previously enslaved netdev.
  *
  *      Feature/offload setting functions.
  * u32 (*ndo_fix_features)(struct net_device *dev, u32 features);
  *	Adjusts the requested feature flags according to device-specific
  *	constraints, and returns the resulting flags. Must not modify
  *	the device state.
  *
  * int (*ndo_set_features)(struct net_device *dev, u32 features);
  *	Called to update device configuration to new features. Passed
  *	feature set might be less than what was returned by ndo_fix_features()).
  *	Must return >0 or -errno if it changed dev->features itself.
  *
  */
 #define HAVE_NET_DEVICE_OPS
 struct net_device_ops {
 	int			(*ndo_init)(struct net_device *dev);
 	void			(*ndo_uninit)(struct net_device *dev);
 	int			(*ndo_open)(struct net_device *dev);
 	int			(*ndo_stop)(struct net_device *dev);
 	netdev_tx_t		(*ndo_start_xmit) (struct sk_buff *skb,
 						   struct net_device *dev);
 	u16			(*ndo_select_queue)(struct net_device *dev,
 						    struct sk_buff *skb);
 	void			(*ndo_change_rx_flags)(struct net_device *dev,
 						       int flags);
 	void			(*ndo_set_rx_mode)(struct net_device *dev);
 	void			(*ndo_set_multicast_list)(struct net_device *dev);
 	int			(*ndo_set_mac_address)(struct net_device *dev,
 						       void *addr);
 	int			(*ndo_validate_addr)(struct net_device *dev);
 	int			(*ndo_do_ioctl)(struct net_device *dev,
 					        struct ifreq *ifr, int cmd);
 	int			(*ndo_set_config)(struct net_device *dev,
 					          struct ifmap *map);
 	int			(*ndo_change_mtu)(struct net_device *dev,
 						  int new_mtu);
 	int			(*ndo_neigh_setup)(struct net_device *dev,
 						   struct neigh_parms *);
 	void			(*ndo_tx_timeout) (struct net_device *dev);
 	struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
 						     struct rtnl_link_stats64 *storage);
 	struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
 	void			(*ndo_vlan_rx_register)(struct net_device *dev,
 						        struct vlan_group *grp);
 	void			(*ndo_vlan_rx_add_vid)(struct net_device *dev,
 						       unsigned short vid);
 	void			(*ndo_vlan_rx_kill_vid)(struct net_device *dev,
 						        unsigned short vid);
 #ifdef CONFIG_NET_POLL_CONTROLLER
 	void                    (*ndo_poll_controller)(struct net_device *dev);
 	int			(*ndo_netpoll_setup)(struct net_device *dev,
 						     struct netpoll_info *info);
 	void			(*ndo_netpoll_cleanup)(struct net_device *dev);
 #endif
 	int			(*ndo_set_vf_mac)(struct net_device *dev,
 						  int queue, u8 *mac);
 	int			(*ndo_set_vf_vlan)(struct net_device *dev,
 						   int queue, u16 vlan, u8 qos);
 	int			(*ndo_set_vf_tx_rate)(struct net_device *dev,
 						      int vf, int rate);
 	int			(*ndo_get_vf_config)(struct net_device *dev,
 						     int vf,
 						     struct ifla_vf_info *ivf);
 	int			(*ndo_set_vf_port)(struct net_device *dev,
 						   int vf,
 						   struct nlattr *port[]);
 	int			(*ndo_get_vf_port)(struct net_device *dev,
 						   int vf, struct sk_buff *skb);
 	int			(*ndo_setup_tc)(struct net_device *dev, u8 tc);
 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
 	int			(*ndo_fcoe_enable)(struct net_device *dev);
 	int			(*ndo_fcoe_disable)(struct net_device *dev);
 	int			(*ndo_fcoe_ddp_setup)(struct net_device *dev,
 						      u16 xid,
 						      struct scatterlist *sgl,
 						      unsigned int sgc);
 	int			(*ndo_fcoe_ddp_done)(struct net_device *dev,
 						     u16 xid);
 	int			(*ndo_fcoe_ddp_target)(struct net_device *dev,
 						       u16 xid,
 						       struct scatterlist *sgl,
 						       unsigned int sgc);
 #define NETDEV_FCOE_WWNN 0
 #define NETDEV_FCOE_WWPN 1
 	int			(*ndo_fcoe_get_wwn)(struct net_device *dev,
 						    u64 *wwn, int type);
 #endif
 #ifdef CONFIG_RFS_ACCEL
 	int			(*ndo_rx_flow_steer)(struct net_device *dev,
 						     const struct sk_buff *skb,
 						     u16 rxq_index,
 						     u32 flow_id);
 #endif
 	int			(*ndo_add_slave)(struct net_device *dev,
 						 struct net_device *slave_dev);
 	int			(*ndo_del_slave)(struct net_device *dev,
 						 struct net_device *slave_dev);
 	u32			(*ndo_fix_features)(struct net_device *dev,
 						    u32 features);
 	int			(*ndo_set_features)(struct net_device *dev,
 						    u32 features);
 };
 /*
  *	The DEVICE structure.
  *	Actually, this whole structure is a big mistake.  It mixes I/O
  *	data with strictly "high-level" data, and it has to know about
  *	almost every data structure used in the INET module.
  *
  *	FIXME: cleanup struct net_device such that network protocol info
  *	moves out.
  */
 struct net_device {
 	/*
 	 * This is the first field of the "visible" part of this structure
 	 * (i.e. as seen by users in the "Space.c" file).  It is the name
 	 * of the interface.
 	 */
 	char			name[IFNAMSIZ];
 	struct pm_qos_request_list pm_qos_req;
 	/* device name hash chain */
 	struct hlist_node	name_hlist;
 	/* snmp alias */
 	char 			*ifalias;
 	/*
 	 *	I/O specific fields
 	 *	FIXME: Merge these and struct ifmap into one
 	 */
 	unsigned long		mem_end;	/* shared mem end	*/
 	unsigned long		mem_start;	/* shared mem start	*/
 	unsigned long		base_addr;	/* device I/O address	*/
 	unsigned int		irq;		/* device IRQ number	*/
 	/*
 	 *	Some hardware also needs these fields, but they are not
 	 *	part of the usual set specified in Space.c.
 	 */
 	unsigned char		if_port;	/* Selectable AUI, TP,..*/
 	unsigned char		dma;		/* DMA channel		*/
 	unsigned long		state;
 	struct list_head	dev_list;
 	struct list_head	napi_list;
 	struct list_head	unreg_list;
 	/* currently active device features */
 	u32			features;
 	/* user-changeable features */
 	u32			hw_features;
 	/* user-requested features */
 	u32			wanted_features;
 	/* mask of features inheritable by VLAN devices */
 	u32			vlan_features;
 	/* Net device feature bits; if you change something,
 	 * also update netdev_features_strings[] in ethtool.c */
 #define NETIF_F_SG		1	/* Scatter/gather IO. */
 #define NETIF_F_IP_CSUM		2	/* Can checksum TCP/UDP over IPv4. */
 #define NETIF_F_NO_CSUM		4	/* Does not require checksum. F.e. loopack. */
 #define NETIF_F_HW_CSUM		8	/* Can checksum all the packets. */
 #define NETIF_F_IPV6_CSUM	16	/* Can checksum TCP/UDP over IPV6 */
 #define NETIF_F_HIGHDMA		32	/* Can DMA to high memory. */
 #define NETIF_F_FRAGLIST	64	/* Scatter/gather IO. */
 #define NETIF_F_HW_VLAN_TX	128	/* Transmit VLAN hw acceleration */
 #define NETIF_F_HW_VLAN_RX	256	/* Receive VLAN hw acceleration */
 #define NETIF_F_HW_VLAN_FILTER	512	/* Receive filtering on VLAN */
 #define NETIF_F_VLAN_CHALLENGED	1024	/* Device cannot handle VLAN packets */
 #define NETIF_F_GSO		2048	/* Enable software GSO. */
 #define NETIF_F_LLTX		4096	/* LockLess TX - deprecated. Please */
 					/* do not use LLTX in new drivers */
 #define NETIF_F_NETNS_LOCAL	8192	/* Does not change network namespaces */
 #define NETIF_F_GRO		16384	/* Generic receive offload */
 #define NETIF_F_LRO		32768	/* large receive offload */
 /* the GSO_MASK reserves bits 16 through 23 */
 #define NETIF_F_FCOE_CRC	(1 << 24) /* FCoE CRC32 */
 #define NETIF_F_SCTP_CSUM	(1 << 25) /* SCTP checksum offload */
 #define NETIF_F_FCOE_MTU	(1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
 #define NETIF_F_NTUPLE		(1 << 27) /* N-tuple filters supported */
 #define NETIF_F_RXHASH		(1 << 28) /* Receive hashing offload */
 #define NETIF_F_RXCSUM		(1 << 29) /* Receive checksumming offload */
 #define NETIF_F_NOCACHE_COPY	(1 << 30) /* Use no-cache copyfromuser */
+#define NETIF_F_LOOPBACK	(1 << 31) /* Enable loopback */
 	/* Segmentation offload features */
 #define NETIF_F_GSO_SHIFT	16
 #define NETIF_F_GSO_MASK	0x00ff0000
 #define NETIF_F_TSO		(SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
 #define NETIF_F_UFO		(SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
 #define NETIF_F_GSO_ROBUST	(SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
 #define NETIF_F_TSO_ECN		(SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
 #define NETIF_F_TSO6		(SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
 #define NETIF_F_FSO		(SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
 	/* Features valid for ethtool to change */
 	/* = all defined minus driver/device-class-related */
 #define NETIF_F_NEVER_CHANGE	(NETIF_F_VLAN_CHALLENGED | \
 				  NETIF_F_LLTX | NETIF_F_NETNS_LOCAL)
-#define NETIF_F_ETHTOOL_BITS	(0x7f3fffff & ~NETIF_F_NEVER_CHANGE)
+#define NETIF_F_ETHTOOL_BITS	(0xff3fffff & ~NETIF_F_NEVER_CHANGE)
 	/* List of features with software fallbacks. */
 #define NETIF_F_GSO_SOFTWARE	(NETIF_F_TSO | NETIF_F_TSO_ECN | \
 				 NETIF_F_TSO6 | NETIF_F_UFO)
 #define NETIF_F_GEN_CSUM	(NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
 #define NETIF_F_V4_CSUM		(NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
 #define NETIF_F_V6_CSUM		(NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
 #define NETIF_F_ALL_CSUM	(NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
 #define NETIF_F_ALL_TSO 	(NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
 #define NETIF_F_ALL_TX_OFFLOADS	(NETIF_F_ALL_CSUM | NETIF_F_SG | \
 				 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
 				 NETIF_F_HIGHDMA | \
 				 NETIF_F_SCTP_CSUM | NETIF_F_FCOE_CRC)
 	/*
 	 * If one device supports one of these features, then enable them
 	 * for all in netdev_increment_features.
 	 */
 #define NETIF_F_ONE_FOR_ALL	(NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
 				 NETIF_F_SG | NETIF_F_HIGHDMA |		\
 				 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED)
 	/*
 	 * If one device doesn't support one of these features, then disable it
 	 * for all in netdev_increment_features.
 	 */
 #define NETIF_F_ALL_FOR_ALL	(NETIF_F_NOCACHE_COPY | NETIF_F_FSO)
 	/* changeable features with no special hardware requirements */
 #define NETIF_F_SOFT_FEATURES	(NETIF_F_GSO | NETIF_F_GRO)
 	/* Interface index. Unique device identifier	*/
 	int			ifindex;
 	int			iflink;
 	struct net_device_stats	stats;
 	atomic_long_t		rx_dropped; /* dropped packets by core network
 					     * Do not use this in drivers.
 					     */
 #ifdef CONFIG_WIRELESS_EXT
 	/* List of functions to handle Wireless Extensions (instead of ioctl).
 	 * See <net/iw_handler.h> for details. Jean II */
 	const struct iw_handler_def *	wireless_handlers;
 	/* Instance data managed by the core of Wireless Extensions. */
 	struct iw_public_data *	wireless_data;
 #endif
 	/* Management operations */
 	const struct net_device_ops *netdev_ops;
 	const struct ethtool_ops *ethtool_ops;
 	/* Hardware header description */
 	const struct header_ops *header_ops;
 	unsigned int		flags;	/* interface flags (a la BSD)	*/
 	unsigned short		gflags;
         unsigned int            priv_flags; /* Like 'flags' but invisible to userspace. */
 	unsigned short		padded;	/* How much padding added by alloc_netdev() */
 	unsigned char		operstate; /* RFC2863 operstate */
 	unsigned char		link_mode; /* mapping policy to operstate */
 	unsigned int		mtu;	/* interface MTU value		*/
 	unsigned short		type;	/* interface hardware type	*/
 	unsigned short		hard_header_len;	/* hardware hdr length	*/
 	/* extra head- and tailroom the hardware may need, but not in all cases
 	 * can this be guaranteed, especially tailroom. Some cases also use
 	 * LL_MAX_HEADER instead to allocate the skb.
 	 */
 	unsigned short		needed_headroom;
 	unsigned short		needed_tailroom;
 	/* Interface address info. */
 	unsigned char		perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
 	unsigned char		addr_assign_type; /* hw address assignment type */
 	unsigned char		addr_len;	/* hardware address length	*/
 	unsigned short          dev_id;		/* for shared network cards */
 	spinlock_t		addr_list_lock;
 	struct netdev_hw_addr_list	uc;	/* Unicast mac addresses */
 	struct netdev_hw_addr_list	mc;	/* Multicast mac addresses */
 	int			uc_promisc;
 	unsigned int		promiscuity;
 	unsigned int		allmulti;
 	/* Protocol specific pointers */
 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
 	struct vlan_group __rcu	*vlgrp;		/* VLAN group */
 #endif
 #ifdef CONFIG_NET_DSA
 	void			*dsa_ptr;	/* dsa specific data */
 #endif
 	void 			*atalk_ptr;	/* AppleTalk link 	*/
 	struct in_device __rcu	*ip_ptr;	/* IPv4 specific data	*/
 	struct dn_dev __rcu     *dn_ptr;        /* DECnet specific data */
 	struct inet6_dev __rcu	*ip6_ptr;       /* IPv6 specific data */
 	void			*ec_ptr;	/* Econet specific data	*/
 	void			*ax25_ptr;	/* AX.25 specific data */
 	struct wireless_dev	*ieee80211_ptr;	/* IEEE 802.11 specific data,
 						   assign before registering */
 /*
  * Cache lines mostly used on receive path (including eth_type_trans())
  */
 	unsigned long		last_rx;	/* Time of last Rx
 						 * This should not be set in
 						 * drivers, unless really needed,
 						 * because network stack (bonding)
 						 * use it if/when necessary, to
 						 * avoid dirtying this cache line.
 						 */
 	struct net_device	*master; /* Pointer to master device of a group,
 					  * which this device is member of.
 					  */
 	/* Interface address info used in eth_type_trans() */
 	unsigned char		*dev_addr;	/* hw address, (before bcast
 						   because most packets are
 						   unicast) */
 	struct netdev_hw_addr_list	dev_addrs; /* list of device
 						      hw addresses */
 	unsigned char		broadcast[MAX_ADDR_LEN];	/* hw bcast add	*/
 #ifdef CONFIG_RPS
 	struct kset		*queues_kset;
 	struct netdev_rx_queue	*_rx;
 	/* Number of RX queues allocated at register_netdev() time */
 	unsigned int		num_rx_queues;
 	/* Number of RX queues currently active in device */
 	unsigned int		real_num_rx_queues;
 #ifdef CONFIG_RFS_ACCEL
 	/* CPU reverse-mapping for RX completion interrupts, indexed
 	 * by RX queue number.  Assigned by driver.  This must only be
 	 * set if the ndo_rx_flow_steer operation is defined. */
 	struct cpu_rmap		*rx_cpu_rmap;
 #endif
 #endif
 	rx_handler_func_t __rcu	*rx_handler;
 	void __rcu		*rx_handler_data;
 	struct netdev_queue __rcu *ingress_queue;
 /*
  * Cache lines mostly used on transmit path
  */
 	struct netdev_queue	*_tx ____cacheline_aligned_in_smp;
 	/* Number of TX queues allocated at alloc_netdev_mq() time  */
 	unsigned int		num_tx_queues;
 	/* Number of TX queues currently active in device  */
 	unsigned int		real_num_tx_queues;
 	/* root qdisc from userspace point of view */
 	struct Qdisc		*qdisc;
 	unsigned long		tx_queue_len;	/* Max frames per queue allowed */
 	spinlock_t		tx_global_lock;
 #ifdef CONFIG_XPS
 	struct xps_dev_maps __rcu *xps_maps;
 #endif
 	/* These may be needed for future network-power-down code. */
 	/*
 	 * trans_start here is expensive for high speed devices on SMP,
 	 * please use netdev_queue->trans_start instead.
 	 */
 	unsigned long		trans_start;	/* Time (in jiffies) of last Tx	*/
 	int			watchdog_timeo; /* used by dev_watchdog() */
 	struct timer_list	watchdog_timer;
 	/* Number of references to this device */
 	int __percpu		*pcpu_refcnt;
 	/* delayed register/unregister */
 	struct list_head	todo_list;
 	/* device index hash chain */
 	struct hlist_node	index_hlist;
 	struct list_head	link_watch_list;
 	/* register/unregister state machine */
 	enum { NETREG_UNINITIALIZED=0,
 	       NETREG_REGISTERED,	/* completed register_netdevice */
 	       NETREG_UNREGISTERING,	/* called unregister_netdevice */
 	       NETREG_UNREGISTERED,	/* completed unregister todo */
 	       NETREG_RELEASED,		/* called free_netdev */
 	       NETREG_DUMMY,		/* dummy device for NAPI poll */
 	} reg_state:16;
 	enum {
 		RTNL_LINK_INITIALIZED,
 		RTNL_LINK_INITIALIZING,
 	} rtnl_link_state:16;
 	/* Called from unregister, can be used to call free_netdev */
 	void (*destructor)(struct net_device *dev);
 #ifdef CONFIG_NETPOLL
 	struct netpoll_info	*npinfo;
 #endif
 #ifdef CONFIG_NET_NS
 	/* Network namespace this network device is inside */
 	struct net		*nd_net;
 #endif
 	/* mid-layer private */
 	union {
 		void				*ml_priv;
 		struct pcpu_lstats __percpu	*lstats; /* loopback stats */
 		struct pcpu_tstats __percpu	*tstats; /* tunnel stats */
 		struct pcpu_dstats __percpu	*dstats; /* dummy stats */
 	};
 	/* GARP */
 	struct garp_port __rcu	*garp_port;
 	/* class/net/name entry */
 	struct device		dev;
 	/* space for optional device, statistics, and wireless sysfs groups */
 	const struct attribute_group *sysfs_groups[4];
 	/* rtnetlink link ops */
 	const struct rtnl_link_ops *rtnl_link_ops;
 	/* for setting kernel sock attribute on TCP connection setup */
 #define GSO_MAX_SIZE		65536
 	unsigned int		gso_max_size;
 #ifdef CONFIG_DCB
 	/* Data Center Bridging netlink ops */
 	const struct dcbnl_rtnl_ops *dcbnl_ops;
 #endif
 	u8 num_tc;
 	struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
 	u8 prio_tc_map[TC_BITMASK + 1];
 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
 	/* max exchange id for FCoE LRO by ddp */
 	unsigned int		fcoe_ddp_xid;
 #endif
 	/* n-tuple filter list attached to this device */
 	struct ethtool_rx_ntuple_list ethtool_ntuple_list;
 	/* phy device may attach itself for hardware timestamping */
 	struct phy_device *phydev;
 	/* group the device belongs to */
 	int group;
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 #define	NETDEV_ALIGN		32
 static inline
 int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
 {
 	return dev->prio_tc_map[prio & TC_BITMASK];
 }
 static inline
 int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
 {
 	if (tc >= dev->num_tc)
 		return -EINVAL;
 	dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
 	return 0;
 }
 static inline
 void netdev_reset_tc(struct net_device *dev)
 {
 	dev->num_tc = 0;
 	memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
 	memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
 }
 static inline
 int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
 {
 	if (tc >= dev->num_tc)
 		return -EINVAL;
 	dev->tc_to_txq[tc].count = count;
 	dev->tc_to_txq[tc].offset = offset;
 	return 0;
 }
 static inline
 int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
 {
 	if (num_tc > TC_MAX_QUEUE)
 		return -EINVAL;
 	dev->num_tc = num_tc;
 	return 0;
 }
 static inline
 int netdev_get_num_tc(struct net_device *dev)
 {
 	return dev->num_tc;
 }
 static inline
 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
 					 unsigned int index)
 {
 	return &dev->_tx[index];
 }
 static inline void netdev_for_each_tx_queue(struct net_device *dev,
 					    void (*f)(struct net_device *,
 						      struct netdev_queue *,
 						      void *),
 					    void *arg)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++)
 		f(dev, &dev->_tx[i], arg);
 }
 /*
  * Net namespace inlines
  */
 static inline
 struct net *dev_net(const struct net_device *dev)
 {
 	return read_pnet(&dev->nd_net);
 }
 static inline
 void dev_net_set(struct net_device *dev, struct net *net)
 {
 #ifdef CONFIG_NET_NS
 	release_net(dev->nd_net);
 	dev->nd_net = hold_net(net);
 #endif
 }
 static inline bool netdev_uses_dsa_tags(struct net_device *dev)
 {
 #ifdef CONFIG_NET_DSA_TAG_DSA
 	if (dev->dsa_ptr != NULL)
 		return dsa_uses_dsa_tags(dev->dsa_ptr);
 #endif
 	return 0;
 }
 #ifndef CONFIG_NET_NS
 static inline void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
 {
 	skb->dev = dev;
 }
 #else /* CONFIG_NET_NS */
 void skb_set_dev(struct sk_buff *skb, struct net_device *dev);
 #endif
 static inline bool netdev_uses_trailer_tags(struct net_device *dev)
 {
 #ifdef CONFIG_NET_DSA_TAG_TRAILER
 	if (dev->dsa_ptr != NULL)
 		return dsa_uses_trailer_tags(dev->dsa_ptr);
 #endif
 	return 0;
 }
 /**
  *	netdev_priv - access network device private data
  *	@dev: network device
  *
  * Get network device private data
  */
 static inline void *netdev_priv(const struct net_device *dev)
 {
 	return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
 }
 /* Set the sysfs physical device reference for the network logical device
  * if set prior to registration will cause a symlink during initialization.
  */
 #define SET_NETDEV_DEV(net, pdev)	((net)->dev.parent = (pdev))
 /* Set the sysfs device type for the network logical device to allow
  * fin grained indentification of different network device types. For
  * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
  */
 #define SET_NETDEV_DEVTYPE(net, devtype)	((net)->dev.type = (devtype))
 /**
  *	netif_napi_add - initialize a napi context
  *	@dev:  network device
  *	@napi: napi context
  *	@poll: polling function
  *	@weight: default weight
  *
  * netif_napi_add() must be used to initialize a napi context prior to calling
  * *any* of the other napi related functions.
  */
 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
 		    int (*poll)(struct napi_struct *, int), int weight);
 /**
  *  netif_napi_del - remove a napi context
  *  @napi: napi context
  *
  *  netif_napi_del() removes a napi context from the network device napi list
  */
 void netif_napi_del(struct napi_struct *napi);
 struct napi_gro_cb {
 	/* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
 	void *frag0;
 	/* Length of frag0. */
 	unsigned int frag0_len;
 	/* This indicates where we are processing relative to skb->data. */
 	int data_offset;
 	/* This is non-zero if the packet may be of the same flow. */
 	int same_flow;
 	/* This is non-zero if the packet cannot be merged with the new skb. */
 	int flush;
 	/* Number of segments aggregated. */
 	int count;
 	/* Free the skb? */
 	int free;
 };
 #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
 struct packet_type {
 	__be16			type;	/* This is really htons(ether_type). */
 	struct net_device	*dev;	/* NULL is wildcarded here	     */
 	int			(*func) (struct sk_buff *,
 					 struct net_device *,
 					 struct packet_type *,
 					 struct net_device *);
 	struct sk_buff		*(*gso_segment)(struct sk_buff *skb,
 						u32 features);
 	int			(*gso_send_check)(struct sk_buff *skb);
 	struct sk_buff		**(*gro_receive)(struct sk_buff **head,
 					       struct sk_buff *skb);
 	int			(*gro_complete)(struct sk_buff *skb);
 	void			*af_packet_priv;
 	struct list_head	list;
 };
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 extern rwlock_t				dev_base_lock;		/* Device list lock */
 #define for_each_netdev(net, d)		\
 		list_for_each_entry(d, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_reverse(net, d)	\
 		list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_rcu(net, d)		\
 		list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_safe(net, d, n)	\
 		list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_continue(net, d)		\
 		list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_continue_rcu(net, d)		\
 	list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
 #define net_device_entry(lh)	list_entry(lh, struct net_device, dev_list)
 static inline struct net_device *next_net_device(struct net_device *dev)
 {
 	struct list_head *lh;
 	struct net *net;
 	net = dev_net(dev);
 	lh = dev->dev_list.next;
 	return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
 }
 static inline struct net_device *next_net_device_rcu(struct net_device *dev)
 {
 	struct list_head *lh;
 	struct net *net;
 	net = dev_net(dev);
 	lh = rcu_dereference(list_next_rcu(&dev->dev_list));
 	return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
 }
 static inline struct net_device *first_net_device(struct net *net)
 {
 	return list_empty(&net->dev_base_head) ? NULL :
 		net_device_entry(net->dev_base_head.next);
 }
 static inline struct net_device *first_net_device_rcu(struct net *net)
 {
 	struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
 	return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
 }
 extern int 			netdev_boot_setup_check(struct net_device *dev);
 extern unsigned long		netdev_boot_base(const char *prefix, int unit);
 extern struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
 					      const char *hwaddr);
 extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
 extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
 extern void		dev_add_pack(struct packet_type *pt);
 extern void		dev_remove_pack(struct packet_type *pt);
 extern void		__dev_remove_pack(struct packet_type *pt);
 extern struct net_device	*dev_get_by_flags_rcu(struct net *net, unsigned short flags,
 						      unsigned short mask);
 extern struct net_device	*dev_get_by_name(struct net *net, const char *name);
 extern struct net_device	*dev_get_by_name_rcu(struct net *net, const char *name);
 extern struct net_device	*__dev_get_by_name(struct net *net, const char *name);
 extern int		dev_alloc_name(struct net_device *dev, const char *name);
 extern int		dev_open(struct net_device *dev);
 extern int		dev_close(struct net_device *dev);
 extern void		dev_disable_lro(struct net_device *dev);
 extern int		dev_queue_xmit(struct sk_buff *skb);
 extern int		register_netdevice(struct net_device *dev);
 extern void		unregister_netdevice_queue(struct net_device *dev,
 						   struct list_head *head);
 extern void		unregister_netdevice_many(struct list_head *head);
 static inline void unregister_netdevice(struct net_device *dev)
 {
 	unregister_netdevice_queue(dev, NULL);
 }
 extern int 		netdev_refcnt_read(const struct net_device *dev);
 extern void		free_netdev(struct net_device *dev);
 extern void		synchronize_net(void);
 extern int 		register_netdevice_notifier(struct notifier_block *nb);
 extern int		unregister_netdevice_notifier(struct notifier_block *nb);
 extern int		init_dummy_netdev(struct net_device *dev);
 extern void		netdev_resync_ops(struct net_device *dev);
 extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
 extern struct net_device	*dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device	*__dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device	*dev_get_by_index_rcu(struct net *net, int ifindex);
 extern int		dev_restart(struct net_device *dev);
 #ifdef CONFIG_NETPOLL_TRAP
 extern int		netpoll_trap(void);
 #endif
 extern int	       skb_gro_receive(struct sk_buff **head,
 				       struct sk_buff *skb);
 extern void	       skb_gro_reset_offset(struct sk_buff *skb);
 static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
 {
 	return NAPI_GRO_CB(skb)->data_offset;
 }
 static inline unsigned int skb_gro_len(const struct sk_buff *skb)
 {
 	return skb->len - NAPI_GRO_CB(skb)->data_offset;
 }
 static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
 {
 	NAPI_GRO_CB(skb)->data_offset += len;
 }
 static inline void *skb_gro_header_fast(struct sk_buff *skb,
 					unsigned int offset)
 {
 	return NAPI_GRO_CB(skb)->frag0 + offset;
 }
 static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
 {
 	return NAPI_GRO_CB(skb)->frag0_len < hlen;
 }
 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
 					unsigned int offset)
 {
 	NAPI_GRO_CB(skb)->frag0 = NULL;
 	NAPI_GRO_CB(skb)->frag0_len = 0;
 	return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
 }
 static inline void *skb_gro_mac_header(struct sk_buff *skb)
 {
 	return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
 }
 static inline void *skb_gro_network_header(struct sk_buff *skb)
 {
 	return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
 	       skb_network_offset(skb);
 }
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
 				  unsigned short type,
 				  const void *daddr, const void *saddr,
 				  unsigned len)
 {
 	if (!dev->header_ops || !dev->header_ops->create)
 		return 0;
 	return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
 }
 static inline int dev_parse_header(const struct sk_buff *skb,
 				   unsigned char *haddr)
 {
 	const struct net_device *dev = skb->dev;
 	if (!dev->header_ops || !dev->header_ops->parse)
 		return 0;
 	return dev->header_ops->parse(skb, haddr);
 }
 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
 extern int		register_gifconf(unsigned int family, gifconf_func_t * gifconf);
 static inline int unregister_gifconf(unsigned int family)
 {
 	return register_gifconf(family, NULL);
 }
 /*
  * Incoming packets are placed on per-cpu queues
  */
 struct softnet_data {
 	struct Qdisc		*output_queue;
 	struct Qdisc		**output_queue_tailp;
 	struct list_head	poll_list;
 	struct sk_buff		*completion_queue;
 	struct sk_buff_head	process_queue;
 	/* stats */
 	unsigned int		processed;
 	unsigned int		time_squeeze;
 	unsigned int		cpu_collision;
 	unsigned int		received_rps;
 #ifdef CONFIG_RPS
 	struct softnet_data	*rps_ipi_list;
 	/* Elements below can be accessed between CPUs for RPS */
 	struct call_single_data	csd ____cacheline_aligned_in_smp;
 	struct softnet_data	*rps_ipi_next;
 	unsigned int		cpu;
 	unsigned int		input_queue_head;
 	unsigned int		input_queue_tail;
 #endif
 	unsigned		dropped;
 	struct sk_buff_head	input_pkt_queue;
 	struct napi_struct	backlog;
 };
 static inline void input_queue_head_incr(struct softnet_data *sd)
 {
 #ifdef CONFIG_RPS
 	sd->input_queue_head++;
 #endif
 }
 static inline void input_queue_tail_incr_save(struct softnet_data *sd,
 					      unsigned int *qtail)
 {
 #ifdef CONFIG_RPS
 	*qtail = ++sd->input_queue_tail;
 #endif
 }
 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
 #define HAVE_NETIF_QUEUE
 extern void __netif_schedule(struct Qdisc *q);
 static inline void netif_schedule_queue(struct netdev_queue *txq)
 {
 	if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
 		__netif_schedule(txq->qdisc);
 }
 static inline void netif_tx_schedule_all(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++)
 		netif_schedule_queue(netdev_get_tx_queue(dev, i));
 }
 static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
 {
 	clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
 }
 /**
  *	netif_start_queue - allow transmit
  *	@dev: network device
  *
  *	Allow upper layers to call the device hard_start_xmit routine.
  */
 static inline void netif_start_queue(struct net_device *dev)
 {
 	netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
 }
 static inline void netif_tx_start_all_queues(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		netif_tx_start_queue(txq);
 	}
 }
 static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
 {
 #ifdef CONFIG_NETPOLL_TRAP
 	if (netpoll_trap()) {
 		netif_tx_start_queue(dev_queue);
 		return;
 	}
 #endif
 	if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
 		__netif_schedule(dev_queue->qdisc);
 }
 /**
  *	netif_wake_queue - restart transmit
  *	@dev: network device
  *
  *	Allow upper layers to call the device hard_start_xmit routine.
  *	Used for flow control when transmit resources are available.
  */
 static inline void netif_wake_queue(struct net_device *dev)
 {
 	netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
 }
 static inline void netif_tx_wake_all_queues(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		netif_tx_wake_queue(txq);
 	}
 }
 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
 {
 	if (WARN_ON(!dev_queue)) {
 		pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
 		return;
 	}
 	set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
 }
 /**
  *	netif_stop_queue - stop transmitted packets
  *	@dev: network device
  *
  *	Stop upper layers calling the device hard_start_xmit routine.
  *	Used for flow control when transmit resources are unavailable.
  */
 static inline void netif_stop_queue(struct net_device *dev)
 {
 	netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
 }
 static inline void netif_tx_stop_all_queues(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		netif_tx_stop_queue(txq);
 	}
 }
 static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
 {
 	return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
 }
 /**
  *	netif_queue_stopped - test if transmit queue is flowblocked
  *	@dev: network device
  *
  *	Test if transmit queue on device is currently unable to send.
  */
 static inline int netif_queue_stopped(const struct net_device *dev)
 {
 	return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
 }
 static inline int netif_tx_queue_frozen_or_stopped(const struct netdev_queue *dev_queue)
 {
 	return dev_queue->state & QUEUE_STATE_XOFF_OR_FROZEN;
 }
 /**
  *	netif_running - test if up
  *	@dev: network device
  *
  *	Test if the device has been brought up.
  */
 static inline int netif_running(const struct net_device *dev)
 {
 	return test_bit(__LINK_STATE_START, &dev->state);
 }
 /*
  * Routines to manage the subqueues on a device.  We only need start
  * stop, and a check if it's stopped.  All other device management is
  * done at the overall netdevice level.
  * Also test the device if we're multiqueue.
  */
 /**
  *	netif_start_subqueue - allow sending packets on subqueue
  *	@dev: network device
  *	@queue_index: sub queue index
  *
  * Start individual transmit queue of a device with multiple transmit queues.
  */
 static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
 {
 	struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 	netif_tx_start_queue(txq);
 }
 /**
  *	netif_stop_subqueue - stop sending packets on subqueue
  *	@dev: network device
  *	@queue_index: sub queue index
  *
  * Stop individual transmit queue of a device with multiple transmit queues.
  */
 static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
 {
 	struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 #ifdef CONFIG_NETPOLL_TRAP
 	if (netpoll_trap())
 		return;
 #endif
 	netif_tx_stop_queue(txq);
 }
 /**
  *	netif_subqueue_stopped - test status of subqueue
  *	@dev: network device
  *	@queue_index: sub queue index
  *
  * Check individual transmit queue of a device with multiple transmit queues.
  */
 static inline int __netif_subqueue_stopped(const struct net_device *dev,
 					 u16 queue_index)
 {
 	struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 	return netif_tx_queue_stopped(txq);
 }
 static inline int netif_subqueue_stopped(const struct net_device *dev,
 					 struct sk_buff *skb)
 {
 	return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
 }
 /**
  *	netif_wake_subqueue - allow sending packets on subqueue
  *	@dev: network device
  *	@queue_index: sub queue index
  *
  * Resume individual transmit queue of a device with multiple transmit queues.
  */
 static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
 {
 	struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 #ifdef CONFIG_NETPOLL_TRAP
 	if (netpoll_trap())
 		return;
 #endif
 	if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
 		__netif_schedule(txq->qdisc);
 }
 /*
  * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
  * as a distribution range limit for the returned value.
  */
 static inline u16 skb_tx_hash(const struct net_device *dev,
 			      const struct sk_buff *skb)
 {
 	return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
 }
 /**
  *	netif_is_multiqueue - test if device has multiple transmit queues
  *	@dev: network device
  *
  * Check if device has multiple transmit queues
  */
 static inline int netif_is_multiqueue(const struct net_device *dev)
 {
 	return dev->num_tx_queues > 1;
 }
 extern int netif_set_real_num_tx_queues(struct net_device *dev,
 					unsigned int txq);
 #ifdef CONFIG_RPS
 extern int netif_set_real_num_rx_queues(struct net_device *dev,
 					unsigned int rxq);
 #else
 static inline int netif_set_real_num_rx_queues(struct net_device *dev,
 						unsigned int rxq)
 {
 	return 0;
 }
 #endif
 static inline int netif_copy_real_num_queues(struct net_device *to_dev,
 					     const struct net_device *from_dev)
 {
 	netif_set_real_num_tx_queues(to_dev, from_dev->real_num_tx_queues);
 #ifdef CONFIG_RPS
 	return netif_set_real_num_rx_queues(to_dev,
 					    from_dev->real_num_rx_queues);
 #else
 	return 0;
 #endif
 }
 /* Use this variant when it is known for sure that it
  * is executing from hardware interrupt context or with hardware interrupts
  * disabled.
  */
 extern void dev_kfree_skb_irq(struct sk_buff *skb);
 /* Use this variant in places where it could be invoked
  * from either hardware interrupt or other context, with hardware interrupts
  * either disabled or enabled.
  */
 extern void dev_kfree_skb_any(struct sk_buff *skb);
 #define HAVE_NETIF_RX 1
 extern int		netif_rx(struct sk_buff *skb);
 extern int		netif_rx_ni(struct sk_buff *skb);
 #define HAVE_NETIF_RECEIVE_SKB 1
 extern int		netif_receive_skb(struct sk_buff *skb);
 extern gro_result_t	dev_gro_receive(struct napi_struct *napi,
 					struct sk_buff *skb);
 extern gro_result_t	napi_skb_finish(gro_result_t ret, struct sk_buff *skb);
 extern gro_result_t	napi_gro_receive(struct napi_struct *napi,
 					 struct sk_buff *skb);
 extern void		napi_gro_flush(struct napi_struct *napi);
 extern struct sk_buff *	napi_get_frags(struct napi_struct *napi);
 extern gro_result_t	napi_frags_finish(struct napi_struct *napi,
 					  struct sk_buff *skb,
 					  gro_result_t ret);
 extern struct sk_buff *	napi_frags_skb(struct napi_struct *napi);
 extern gro_result_t	napi_gro_frags(struct napi_struct *napi);
 static inline void napi_free_frags(struct napi_struct *napi)
 {
 	kfree_skb(napi->skb);
 	napi->skb = NULL;
 }
 extern int netdev_rx_handler_register(struct net_device *dev,
 				      rx_handler_func_t *rx_handler,
 				      void *rx_handler_data);
 extern void netdev_rx_handler_unregister(struct net_device *dev);
 extern int		dev_valid_name(const char *name);
 extern int		dev_ioctl(struct net *net, unsigned int cmd, void __user *);
 extern int		dev_ethtool(struct net *net, struct ifreq *);
 extern unsigned		dev_get_flags(const struct net_device *);
 extern int		__dev_change_flags(struct net_device *, unsigned int flags);
 extern int		dev_change_flags(struct net_device *, unsigned);
 extern void		__dev_notify_flags(struct net_device *, unsigned int old_flags);
 extern int		dev_change_name(struct net_device *, const char *);
 extern int		dev_set_alias(struct net_device *, const char *, size_t);
 extern int		dev_change_net_namespace(struct net_device *,
 						 struct net *, const char *);
 extern int		dev_set_mtu(struct net_device *, int);
 extern void		dev_set_group(struct net_device *, int);
 extern int		dev_set_mac_address(struct net_device *,
 					    struct sockaddr *);
 extern int		dev_hard_start_xmit(struct sk_buff *skb,
 					    struct net_device *dev,
 					    struct netdev_queue *txq);
 extern int		dev_forward_skb(struct net_device *dev,
 					struct sk_buff *skb);
 extern int		netdev_budget;
 /* Called by rtnetlink.c:rtnl_unlock() */
 extern void netdev_run_todo(void);
 /**
  *	dev_put - release reference to device
  *	@dev: network device
  *
  * Release reference to device to allow it to be freed.
  */
 static inline void dev_put(struct net_device *dev)
 {
 	irqsafe_cpu_dec(*dev->pcpu_refcnt);
 }
 /**
  *	dev_hold - get reference to device
  *	@dev: network device
  *
  * Hold reference to device to keep it from being freed.
  */
 static inline void dev_hold(struct net_device *dev)
 {
 	irqsafe_cpu_inc(*dev->pcpu_refcnt);
 }
 /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  * and _off may be called from IRQ context, but it is caller
  * who is responsible for serialization of these calls.
  *
  * The name carrier is inappropriate, these functions should really be
  * called netif_lowerlayer_*() because they represent the state of any
  * kind of lower layer not just hardware media.
  */
 extern void linkwatch_fire_event(struct net_device *dev);
 extern void linkwatch_forget_dev(struct net_device *dev);
 /**
  *	netif_carrier_ok - test if carrier present
  *	@dev: network device
  *
  * Check if carrier is present on device
  */
 static inline int netif_carrier_ok(const struct net_device *dev)
 {
 	return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
 }
 extern unsigned long dev_trans_start(struct net_device *dev);
 extern void __netdev_watchdog_up(struct net_device *dev);
 extern void netif_carrier_on(struct net_device *dev);
 extern void netif_carrier_off(struct net_device *dev);
 extern void netif_notify_peers(struct net_device *dev);
 /**
  *	netif_dormant_on - mark device as dormant.
  *	@dev: network device
  *
  * Mark device as dormant (as per RFC2863).
  *
  * The dormant state indicates that the relevant interface is not
  * actually in a condition to pass packets (i.e., it is not 'up') but is
  * in a "pending" state, waiting for some external event.  For "on-
  * demand" interfaces, this new state identifies the situation where the
  * interface is waiting for events to place it in the up state.
  *
  */
 static inline void netif_dormant_on(struct net_device *dev)
 {
 	if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
 		linkwatch_fire_event(dev);
 }
 /**
  *	netif_dormant_off - set device as not dormant.
  *	@dev: network device
  *
  * Device is not in dormant state.
  */
 static inline void netif_dormant_off(struct net_device *dev)
 {
 	if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
 		linkwatch_fire_event(dev);
 }
 /**
  *	netif_dormant - test if carrier present
  *	@dev: network device
  *
  * Check if carrier is present on device
  */
 static inline int netif_dormant(const struct net_device *dev)
 {
 	return test_bit(__LINK_STATE_DORMANT, &dev->state);
 }
 /**
  *	netif_oper_up - test if device is operational
  *	@dev: network device
  *
  * Check if carrier is operational
  */
 static inline int netif_oper_up(const struct net_device *dev)
 {
 	return (dev->operstate == IF_OPER_UP ||
 		dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
 }
 /**
  *	netif_device_present - is device available or removed
  *	@dev: network device
  *
  * Check if device has not been removed from system.
  */
 static inline int netif_device_present(struct net_device *dev)
 {
 	return test_bit(__LINK_STATE_PRESENT, &dev->state);
 }
 extern void netif_device_detach(struct net_device *dev);
 extern void netif_device_attach(struct net_device *dev);
 /*
  * Network interface message level settings
  */
 #define HAVE_NETIF_MSG 1
 enum {
 	NETIF_MSG_DRV		= 0x0001,
 	NETIF_MSG_PROBE		= 0x0002,
 	NETIF_MSG_LINK		= 0x0004,
 	NETIF_MSG_TIMER		= 0x0008,
 	NETIF_MSG_IFDOWN	= 0x0010,
 	NETIF_MSG_IFUP		= 0x0020,
 	NETIF_MSG_RX_ERR	= 0x0040,
 	NETIF_MSG_TX_ERR	= 0x0080,
 	NETIF_MSG_TX_QUEUED	= 0x0100,
 	NETIF_MSG_INTR		= 0x0200,
 	NETIF_MSG_TX_DONE	= 0x0400,
 	NETIF_MSG_RX_STATUS	= 0x0800,
 	NETIF_MSG_PKTDATA	= 0x1000,
 	NETIF_MSG_HW		= 0x2000,
 	NETIF_MSG_WOL		= 0x4000,
 };
 #define netif_msg_drv(p)	((p)->msg_enable & NETIF_MSG_DRV)
 #define netif_msg_probe(p)	((p)->msg_enable & NETIF_MSG_PROBE)
 #define netif_msg_link(p)	((p)->msg_enable & NETIF_MSG_LINK)
 #define netif_msg_timer(p)	((p)->msg_enable & NETIF_MSG_TIMER)
 #define netif_msg_ifdown(p)	((p)->msg_enable & NETIF_MSG_IFDOWN)
 #define netif_msg_ifup(p)	((p)->msg_enable & NETIF_MSG_IFUP)
 #define netif_msg_rx_err(p)	((p)->msg_enable & NETIF_MSG_RX_ERR)
 #define netif_msg_tx_err(p)	((p)->msg_enable & NETIF_MSG_TX_ERR)
 #define netif_msg_tx_queued(p)	((p)->msg_enable & NETIF_MSG_TX_QUEUED)
 #define netif_msg_intr(p)	((p)->msg_enable & NETIF_MSG_INTR)
 #define netif_msg_tx_done(p)	((p)->msg_enable & NETIF_MSG_TX_DONE)
 #define netif_msg_rx_status(p)	((p)->msg_enable & NETIF_MSG_RX_STATUS)
 #define netif_msg_pktdata(p)	((p)->msg_enable & NETIF_MSG_PKTDATA)
 #define netif_msg_hw(p)		((p)->msg_enable & NETIF_MSG_HW)
 #define netif_msg_wol(p)	((p)->msg_enable & NETIF_MSG_WOL)
 static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
 {
 	/* use default */
 	if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
 		return default_msg_enable_bits;
 	if (debug_value == 0)	/* no output */
 		return 0;
 	/* set low N bits */
 	return (1 << debug_value) - 1;
 }
 static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
 {
 	spin_lock(&txq->_xmit_lock);
 	txq->xmit_lock_owner = cpu;
 }
 static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
 {
 	spin_lock_bh(&txq->_xmit_lock);
 	txq->xmit_lock_owner = smp_processor_id();
 }
 static inline int __netif_tx_trylock(struct netdev_queue *txq)
 {
 	int ok = spin_trylock(&txq->_xmit_lock);
 	if (likely(ok))
 		txq->xmit_lock_owner = smp_processor_id();
 	return ok;
 }
 static inline void __netif_tx_unlock(struct netdev_queue *txq)
 {
 	txq->xmit_lock_owner = -1;
 	spin_unlock(&txq->_xmit_lock);
 }
 static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
 {
 	txq->xmit_lock_owner = -1;
 	spin_unlock_bh(&txq->_xmit_lock);
 }
 static inline void txq_trans_update(struct netdev_queue *txq)
 {
 	if (txq->xmit_lock_owner != -1)
 		txq->trans_start = jiffies;
 }
 /**
  *	netif_tx_lock - grab network device transmit lock
  *	@dev: network device
  *
  * Get network device transmit lock
  */
 static inline void netif_tx_lock(struct net_device *dev)
 {
 	unsigned int i;
 	int cpu;
 	spin_lock(&dev->tx_global_lock);
 	cpu = smp_processor_id();
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		/* We are the only thread of execution doing a
 		 * freeze, but we have to grab the _xmit_lock in
 		 * order to synchronize with threads which are in
 		 * the ->hard_start_xmit() handler and already
 		 * checked the frozen bit.
 		 */
 		__netif_tx_lock(txq, cpu);
 		set_bit(__QUEUE_STATE_FROZEN, &txq->state);
 		__netif_tx_unlock(txq);
 	}
 }
 static inline void netif_tx_lock_bh(struct net_device *dev)
 {
 	local_bh_disable();
 	netif_tx_lock(dev);
 }
 static inline void netif_tx_unlock(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		/* No need to grab the _xmit_lock here.  If the
 		 * queue is not stopped for another reason, we
 		 * force a schedule.
 		 */
 		clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
 		netif_schedule_queue(txq);
 	}
 	spin_unlock(&dev->tx_global_lock);
 }
 static inline void netif_tx_unlock_bh(struct net_device *dev)
 {
 	netif_tx_unlock(dev);
 	local_bh_enable();
 }
 #define HARD_TX_LOCK(dev, txq, cpu) {			\
 	if ((dev->features & NETIF_F_LLTX) == 0) {	\
 		__netif_tx_lock(txq, cpu);		\
 	}						\
 }
 #define HARD_TX_UNLOCK(dev, txq) {			\
 	if ((dev->features & NETIF_F_LLTX) == 0) {	\
 		__netif_tx_unlock(txq);			\
 	}						\
 }
 static inline void netif_tx_disable(struct net_device *dev)
 {
 	unsigned int i;
 	int cpu;
 	local_bh_disable();
 	cpu = smp_processor_id();
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		__netif_tx_lock(txq, cpu);
 		netif_tx_stop_queue(txq);
 		__netif_tx_unlock(txq);
 	}
 	local_bh_enable();
 }
 static inline void netif_addr_lock(struct net_device *dev)
 {
 	spin_lock(&dev->addr_list_lock);
 }
 static inline void netif_addr_lock_bh(struct net_device *dev)
 {
 	spin_lock_bh(&dev->addr_list_lock);
 }
 static inline void netif_addr_unlock(struct net_device *dev)
 {
 	spin_unlock(&dev->addr_list_lock);
 }
 static inline void netif_addr_unlock_bh(struct net_device *dev)
 {
 	spin_unlock_bh(&dev->addr_list_lock);
 }
 /*
  * dev_addrs walker. Should be used only for read access. Call with
  * rcu_read_lock held.
  */
 #define for_each_dev_addr(dev, ha) \
 		list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
 /* These functions live elsewhere (drivers/net/net_init.c, but related) */
 extern void		ether_setup(struct net_device *dev);
 /* Support for loadable net-drivers */
 extern struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
 				       void (*setup)(struct net_device *),
 				       unsigned int txqs, unsigned int rxqs);
 #define alloc_netdev(sizeof_priv, name, setup) \
 	alloc_netdev_mqs(sizeof_priv, name, setup, 1, 1)
 #define alloc_netdev_mq(sizeof_priv, name, setup, count) \
 	alloc_netdev_mqs(sizeof_priv, name, setup, count, count)
 extern int		register_netdev(struct net_device *dev);
 extern void		unregister_netdev(struct net_device *dev);
 /* General hardware address lists handling functions */
 extern int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
 				  struct netdev_hw_addr_list *from_list,
 				  int addr_len, unsigned char addr_type);
 extern void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
 				   struct netdev_hw_addr_list *from_list,
 				   int addr_len, unsigned char addr_type);
 extern int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
 			  struct netdev_hw_addr_list *from_list,
 			  int addr_len);
 extern void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
 			     struct netdev_hw_addr_list *from_list,
 			     int addr_len);
 extern void __hw_addr_flush(struct netdev_hw_addr_list *list);
 extern void __hw_addr_init(struct netdev_hw_addr_list *list);
 /* Functions used for device addresses handling */
 extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
 			unsigned char addr_type);
 extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
 			unsigned char addr_type);
 extern int dev_addr_add_multiple(struct net_device *to_dev,
 				 struct net_device *from_dev,
 				 unsigned char addr_type);
 extern int dev_addr_del_multiple(struct net_device *to_dev,
 				 struct net_device *from_dev,
 				 unsigned char addr_type);
 extern void dev_addr_flush(struct net_device *dev);
 extern int dev_addr_init(struct net_device *dev);
 /* Functions used for unicast addresses handling */
 extern int dev_uc_add(struct net_device *dev, unsigned char *addr);
 extern int dev_uc_del(struct net_device *dev, unsigned char *addr);
 extern int dev_uc_sync(struct net_device *to, struct net_device *from);
 extern void dev_uc_unsync(struct net_device *to, struct net_device *from);
 extern void dev_uc_flush(struct net_device *dev);
 extern void dev_uc_init(struct net_device *dev);
 /* Functions used for multicast addresses handling */
 extern int dev_mc_add(struct net_device *dev, unsigned char *addr);
 extern int dev_mc_add_global(struct net_device *dev, unsigned char *addr);
 extern int dev_mc_del(struct net_device *dev, unsigned char *addr);
 extern int dev_mc_del_global(struct net_device *dev, unsigned char *addr);
 extern int dev_mc_sync(struct net_device *to, struct net_device *from);
 extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
 extern void dev_mc_flush(struct net_device *dev);
 extern void dev_mc_init(struct net_device *dev);
 /* Functions used for secondary unicast and multicast support */
 extern void		dev_set_rx_mode(struct net_device *dev);
 extern void		__dev_set_rx_mode(struct net_device *dev);
 extern int		dev_set_promiscuity(struct net_device *dev, int inc);
 extern int		dev_set_allmulti(struct net_device *dev, int inc);
 extern void		netdev_state_change(struct net_device *dev);
 extern int		netdev_bonding_change(struct net_device *dev,
 					      unsigned long event);
 extern void		netdev_features_change(struct net_device *dev);
 /* Load a device via the kmod */
 extern void		dev_load(struct net *net, const char *name);
 extern void		dev_mcast_init(void);
 extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
 					       struct rtnl_link_stats64 *storage);
 extern int		netdev_max_backlog;
 extern int		netdev_tstamp_prequeue;
 extern int		weight_p;
 extern int		bpf_jit_enable;
 extern int		netdev_set_master(struct net_device *dev, struct net_device *master);
 extern int netdev_set_bond_master(struct net_device *dev,
 				  struct net_device *master);
 extern int skb_checksum_help(struct sk_buff *skb);
 extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features);
 #ifdef CONFIG_BUG
 extern void netdev_rx_csum_fault(struct net_device *dev);
 #else
 static inline void netdev_rx_csum_fault(struct net_device *dev)
 {
 }
 #endif
 /* rx skb timestamps */
 extern void		net_enable_timestamp(void);
 extern void		net_disable_timestamp(void);
 #ifdef CONFIG_PROC_FS
 extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
 extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
 extern void dev_seq_stop(struct seq_file *seq, void *v);
 #endif
 extern int netdev_class_create_file(struct class_attribute *class_attr);
 extern void netdev_class_remove_file(struct class_attribute *class_attr);
 extern struct kobj_ns_type_operations net_ns_type_operations;
 extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);
 extern void linkwatch_run_queue(void);
 static inline u32 netdev_get_wanted_features(struct net_device *dev)
 {
 	return (dev->features & ~dev->hw_features) | dev->wanted_features;
 }
 u32 netdev_increment_features(u32 all, u32 one, u32 mask);
 u32 netdev_fix_features(struct net_device *dev, u32 features);
 int __netdev_update_features(struct net_device *dev);
 void netdev_update_features(struct net_device *dev);
 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
 					struct net_device *dev);
 u32 netif_skb_features(struct sk_buff *skb);
 static inline int net_gso_ok(u32 features, int gso_type)
 {
 	int feature = gso_type << NETIF_F_GSO_SHIFT;
 	return (features & feature) == feature;
 }
 static inline int skb_gso_ok(struct sk_buff *skb, u32 features)
 {
 	return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
 	       (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
 }
 static inline int netif_needs_gso(struct sk_buff *skb, int features)
 {
 	return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
 		unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
 }
 static inline void netif_set_gso_max_size(struct net_device *dev,
 					  unsigned int size)
 {
 	dev->gso_max_size = size;
 }
 static inline int netif_is_bond_slave(struct net_device *dev)
 {
 	return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
 }
 extern struct pernet_operations __net_initdata loopback_net_ops;
 int dev_ethtool_get_settings(struct net_device *dev,
 			     struct ethtool_cmd *cmd);
 static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
 {
 	if (dev->features & NETIF_F_RXCSUM)
 		return 1;
 	if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
 		return 0;
 	return dev->ethtool_ops->get_rx_csum(dev);
 }
 static inline u32 dev_ethtool_get_flags(struct net_device *dev)
 {
 	if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
 		return 0;
 	return dev->ethtool_ops->get_flags(dev);
 }
 /* Logging, debugging and troubleshooting/diagnostic helpers. */
 /* netdev_printk helpers, similar to dev_printk */
 static inline const char *netdev_name(const struct net_device *dev)
 {
 	if (dev->reg_state != NETREG_REGISTERED)
 		return "(unregistered net_device)";
 	return dev->name;
 }
 extern int netdev_printk(const char *level, const struct net_device *dev,
 			 const char *format, ...)
 	__attribute__ ((format (printf, 3, 4)));
 extern int netdev_emerg(const struct net_device *dev, const char *format, ...)
 	__attribute__ ((format (printf, 2, 3)));
 extern int netdev_alert(const struct net_device *dev, const char *format, ...)
 	__attribute__ ((format (printf, 2, 3)));
 extern int netdev_crit(const struct net_device *dev, const char *format, ...)
 	__attribute__ ((format (printf, 2, 3)));
 extern int netdev_err(const struct net_device *dev, const char *format, ...)
 	__attribute__ ((format (printf, 2, 3)));
 extern int netdev_warn(const struct net_device *dev, const char *format, ...)
 	__attribute__ ((format (printf, 2, 3)));
 extern int netdev_notice(const struct net_device *dev, const char *format, ...)
 	__attribute__ ((format (printf, 2, 3)));
 extern int netdev_info(const struct net_device *dev, const char *format, ...)
 	__attribute__ ((format (printf, 2, 3)));
 #define MODULE_ALIAS_NETDEV(device) \
 	MODULE_ALIAS("netdev-" device)
 #if defined(DEBUG)
 #define netdev_dbg(__dev, format, args...)			\
 	netdev_printk(KERN_DEBUG, __dev, format, ##args)
 #elif defined(CONFIG_DYNAMIC_DEBUG)
 #define netdev_dbg(__dev, format, args...)			\
 do {								\
 	dynamic_dev_dbg((__dev)->dev.parent, "%s: " format,	\
 			netdev_name(__dev), ##args);		\
 } while (0)
 #else
 #define netdev_dbg(__dev, format, args...)			\
 ({								\
 	if (0)							\
 		netdev_printk(KERN_DEBUG, __dev, format, ##args); \
 	0;							\
 })
 #endif
 #if defined(VERBOSE_DEBUG)
 #define netdev_vdbg	netdev_dbg
 #else
 #define netdev_vdbg(dev, format, args...)			\
 ({								\
 	if (0)							\
 		netdev_printk(KERN_DEBUG, dev, format, ##args);	\
 	0;							\
 })
 #endif
 /*
  * netdev_WARN() acts like dev_printk(), but with the key difference
  * of using a WARN/WARN_ON to get the message out, including the
  * file/line information and a backtrace.
  */
 #define netdev_WARN(dev, format, args...)			\
 	WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
 /* netif printk helpers, similar to netdev_printk */
 #define netif_printk(priv, type, level, dev, fmt, args...)	\
 do {					  			\
 	if (netif_msg_##type(priv))				\
 		netdev_printk(level, (dev), fmt, ##args);	\
 } while (0)
 #define netif_level(level, priv, type, dev, fmt, args...)	\
 do {								\
 	if (netif_msg_##type(priv))				\
 		netdev_##level(dev, fmt, ##args);		\
 } while (0)
 #define netif_emerg(priv, type, dev, fmt, args...)		\
 	netif_level(emerg, priv, type, dev, fmt, ##args)
 #define netif_alert(priv, type, dev, fmt, args...)		\
 	netif_level(alert, priv, type, dev, fmt, ##args)
 #define netif_crit(priv, type, dev, fmt, args...)		\
 	netif_level(crit, priv, type, dev, fmt, ##args)
 #define netif_err(priv, type, dev, fmt, args...)		\
 	netif_level(err, priv, type, dev, fmt, ##args)
 #define netif_warn(priv, type, dev, fmt, args...)		\
 	netif_level(warn, priv, type, dev, fmt, ##args)
 #define netif_notice(priv, type, dev, fmt, args...)		\
 	netif_level(notice, priv, type, dev, fmt, ##args)
 #define netif_info(priv, type, dev, fmt, args...)		\
 	netif_level(info, priv, type, dev, fmt, ##args)
 #if defined(DEBUG)
 #define netif_dbg(priv, type, dev, format, args...)		\
 	netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
 #elif defined(CONFIG_DYNAMIC_DEBUG)
 #define netif_dbg(priv, type, netdev, format, args...)		\
 do {								\
 	if (netif_msg_##type(priv))				\
 		dynamic_dev_dbg((netdev)->dev.parent,		\
 				"%s: " format,			\
 				netdev_name(netdev), ##args);	\
 } while (0)
 #else
 #define netif_dbg(priv, type, dev, format, args...)			\
 ({									\
 	if (0)								\
 		netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
 	0;								\
 })
 #endif
 #if defined(VERBOSE_DEBUG)
 #define netif_vdbg	netif_dbg
 #else
 #define netif_vdbg(priv, type, dev, format, args...)		\
 ({								\
 	if (0)							\
 		netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
 	0;							\
 })
 #endif
 #endif /* __KERNEL__ */
 #endif	/* _LINUX_NETDEVICE_H */

net/core/ethtool.c

Diff comments View file @ eed2a12

1	/*	1	/*
2	* net/core/ethtool.c - Ethtool ioctl handler	2	* net/core/ethtool.c - Ethtool ioctl handler
3	* Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>	3	* Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>
4	*	4	*
5	* This file is where we call all the ethtool_ops commands to get	5	* This file is where we call all the ethtool_ops commands to get
6	* the information ethtool needs.	6	* the information ethtool needs.
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*/	12	*/
13		13
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/types.h>	15	#include <linux/types.h>
16	#include <linux/capability.h>	16	#include <linux/capability.h>
17	#include <linux/errno.h>	17	#include <linux/errno.h>
18	#include <linux/ethtool.h>	18	#include <linux/ethtool.h>
19	#include <linux/netdevice.h>	19	#include <linux/netdevice.h>
20	#include <linux/bitops.h>	20	#include <linux/bitops.h>
21	#include <linux/uaccess.h>	21	#include <linux/uaccess.h>
22	#include <linux/vmalloc.h>	22	#include <linux/vmalloc.h>
23	#include <linux/slab.h>	23	#include <linux/slab.h>
24	#include <linux/rtnetlink.h>	24	#include <linux/rtnetlink.h>
25	#include <linux/sched.h>	25	#include <linux/sched.h>
26		26
27	/*	27	/*
28	* Some useful ethtool_ops methods that're device independent.	28	* Some useful ethtool_ops methods that're device independent.
29	* If we find that all drivers want to do the same thing here,	29	* If we find that all drivers want to do the same thing here,
30	* we can turn these into dev_() function calls.	30	* we can turn these into dev_() function calls.
31	*/	31	*/
32		32
33	u32 ethtool_op_get_link(struct net_device *dev)	33	u32 ethtool_op_get_link(struct net_device *dev)
34	{	34	{
35	return netif_carrier_ok(dev) ? 1 : 0;	35	return netif_carrier_ok(dev) ? 1 : 0;
36	}	36	}
37	EXPORT_SYMBOL(ethtool_op_get_link);	37	EXPORT_SYMBOL(ethtool_op_get_link);
38		38
39	u32 ethtool_op_get_tx_csum(struct net_device *dev)	39	u32 ethtool_op_get_tx_csum(struct net_device *dev)
40	{	40	{
41	return (dev->features & NETIF_F_ALL_CSUM) != 0;	41	return (dev->features & NETIF_F_ALL_CSUM) != 0;
42	}	42	}
43	EXPORT_SYMBOL(ethtool_op_get_tx_csum);	43	EXPORT_SYMBOL(ethtool_op_get_tx_csum);
44		44
45	int ethtool_op_set_tx_csum(struct net_device *dev, u32 data)	45	int ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
46	{	46	{
47	if (data)	47	if (data)
48	dev->features \|= NETIF_F_IP_CSUM;	48	dev->features \|= NETIF_F_IP_CSUM;
49	else	49	else
50	dev->features &= ~NETIF_F_IP_CSUM;	50	dev->features &= ~NETIF_F_IP_CSUM;
51		51
52	return 0;	52	return 0;
53	}	53	}
54	EXPORT_SYMBOL(ethtool_op_set_tx_csum);	54	EXPORT_SYMBOL(ethtool_op_set_tx_csum);
55		55
56	int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)	56	int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)
57	{	57	{
58	if (data)	58	if (data)
59	dev->features \|= NETIF_F_HW_CSUM;	59	dev->features \|= NETIF_F_HW_CSUM;
60	else	60	else
61	dev->features &= ~NETIF_F_HW_CSUM;	61	dev->features &= ~NETIF_F_HW_CSUM;
62		62
63	return 0;	63	return 0;
64	}	64	}
65	EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);	65	EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
66		66
67	int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)	67	int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)
68	{	68	{
69	if (data)	69	if (data)
70	dev->features \|= NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM;	70	dev->features \|= NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM;
71	else	71	else
72	dev->features &= ~(NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM);	72	dev->features &= ~(NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM);
73		73
74	return 0;	74	return 0;
75	}	75	}
76	EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);	76	EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
77		77
78	u32 ethtool_op_get_sg(struct net_device *dev)	78	u32 ethtool_op_get_sg(struct net_device *dev)
79	{	79	{
80	return (dev->features & NETIF_F_SG) != 0;	80	return (dev->features & NETIF_F_SG) != 0;
81	}	81	}
82	EXPORT_SYMBOL(ethtool_op_get_sg);	82	EXPORT_SYMBOL(ethtool_op_get_sg);
83		83
84	int ethtool_op_set_sg(struct net_device *dev, u32 data)	84	int ethtool_op_set_sg(struct net_device *dev, u32 data)
85	{	85	{
86	if (data)	86	if (data)
87	dev->features \|= NETIF_F_SG;	87	dev->features \|= NETIF_F_SG;
88	else	88	else
89	dev->features &= ~NETIF_F_SG;	89	dev->features &= ~NETIF_F_SG;
90		90
91	return 0;	91	return 0;
92	}	92	}
93	EXPORT_SYMBOL(ethtool_op_set_sg);	93	EXPORT_SYMBOL(ethtool_op_set_sg);
94		94
95	u32 ethtool_op_get_tso(struct net_device *dev)	95	u32 ethtool_op_get_tso(struct net_device *dev)
96	{	96	{
97	return (dev->features & NETIF_F_TSO) != 0;	97	return (dev->features & NETIF_F_TSO) != 0;
98	}	98	}
99	EXPORT_SYMBOL(ethtool_op_get_tso);	99	EXPORT_SYMBOL(ethtool_op_get_tso);
100		100
101	int ethtool_op_set_tso(struct net_device *dev, u32 data)	101	int ethtool_op_set_tso(struct net_device *dev, u32 data)
102	{	102	{
103	if (data)	103	if (data)
104	dev->features \|= NETIF_F_TSO;	104	dev->features \|= NETIF_F_TSO;
105	else	105	else
106	dev->features &= ~NETIF_F_TSO;	106	dev->features &= ~NETIF_F_TSO;
107		107
108	return 0;	108	return 0;
109	}	109	}
110	EXPORT_SYMBOL(ethtool_op_set_tso);	110	EXPORT_SYMBOL(ethtool_op_set_tso);
111		111
112	u32 ethtool_op_get_ufo(struct net_device *dev)	112	u32 ethtool_op_get_ufo(struct net_device *dev)
113	{	113	{
114	return (dev->features & NETIF_F_UFO) != 0;	114	return (dev->features & NETIF_F_UFO) != 0;
115	}	115	}
116	EXPORT_SYMBOL(ethtool_op_get_ufo);	116	EXPORT_SYMBOL(ethtool_op_get_ufo);
117		117
118	int ethtool_op_set_ufo(struct net_device *dev, u32 data)	118	int ethtool_op_set_ufo(struct net_device *dev, u32 data)
119	{	119	{
120	if (data)	120	if (data)
121	dev->features \|= NETIF_F_UFO;	121	dev->features \|= NETIF_F_UFO;
122	else	122	else
123	dev->features &= ~NETIF_F_UFO;	123	dev->features &= ~NETIF_F_UFO;
124	return 0;	124	return 0;
125	}	125	}
126	EXPORT_SYMBOL(ethtool_op_set_ufo);	126	EXPORT_SYMBOL(ethtool_op_set_ufo);
127		127
128	/* the following list of flags are the same as their associated	128	/* the following list of flags are the same as their associated
129	* NETIF_F_xxx values in include/linux/netdevice.h	129	* NETIF_F_xxx values in include/linux/netdevice.h
130	*/	130	*/
131	static const u32 flags_dup_features =	131	static const u32 flags_dup_features =
132	(ETH_FLAG_LRO \| ETH_FLAG_RXVLAN \| ETH_FLAG_TXVLAN \| ETH_FLAG_NTUPLE \|	132	(ETH_FLAG_LRO \| ETH_FLAG_RXVLAN \| ETH_FLAG_TXVLAN \| ETH_FLAG_NTUPLE \|
133	ETH_FLAG_RXHASH);	133	ETH_FLAG_RXHASH);
134		134
135	u32 ethtool_op_get_flags(struct net_device *dev)	135	u32 ethtool_op_get_flags(struct net_device *dev)
136	{	136	{
137	/* in the future, this function will probably contain additional	137	/* in the future, this function will probably contain additional
138	* handling for flags which are not so easily handled	138	* handling for flags which are not so easily handled
139	* by a simple masking operation	139	* by a simple masking operation
140	*/	140	*/
141		141
142	return dev->features & flags_dup_features;	142	return dev->features & flags_dup_features;
143	}	143	}
144	EXPORT_SYMBOL(ethtool_op_get_flags);	144	EXPORT_SYMBOL(ethtool_op_get_flags);
145		145
146	/* Check if device can enable (or disable) particular feature coded in "data"	146	/* Check if device can enable (or disable) particular feature coded in "data"
147	* argument. Flags "supported" describe features that can be toggled by device.	147	* argument. Flags "supported" describe features that can be toggled by device.
148	* If feature can not be toggled, it state (enabled or disabled) must match	148	* If feature can not be toggled, it state (enabled or disabled) must match
149	* hardcoded device features state, otherwise flags are marked as invalid.	149	* hardcoded device features state, otherwise flags are marked as invalid.
150	*/	150	*/
151	bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported)	151	bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported)
152	{	152	{
153	u32 features = dev->features & flags_dup_features;	153	u32 features = dev->features & flags_dup_features;
154	/* "data" can contain only flags_dup_features bits,	154	/* "data" can contain only flags_dup_features bits,
155	* see __ethtool_set_flags */	155	* see __ethtool_set_flags */
156		156
157	return (features & ~supported) != (data & ~supported);	157	return (features & ~supported) != (data & ~supported);
158	}	158	}
159	EXPORT_SYMBOL(ethtool_invalid_flags);	159	EXPORT_SYMBOL(ethtool_invalid_flags);
160		160
161	int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported)	161	int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported)
162	{	162	{
163	if (ethtool_invalid_flags(dev, data, supported))	163	if (ethtool_invalid_flags(dev, data, supported))
164	return -EINVAL;	164	return -EINVAL;
165		165
166	dev->features = ((dev->features & ~flags_dup_features) \|	166	dev->features = ((dev->features & ~flags_dup_features) \|
167	(data & flags_dup_features));	167	(data & flags_dup_features));
168	return 0;	168	return 0;
169	}	169	}
170	EXPORT_SYMBOL(ethtool_op_set_flags);	170	EXPORT_SYMBOL(ethtool_op_set_flags);
171		171
172	void ethtool_ntuple_flush(struct net_device *dev)	172	void ethtool_ntuple_flush(struct net_device *dev)
173	{	173	{
174	struct ethtool_rx_ntuple_flow_spec_container fsc, f;	174	struct ethtool_rx_ntuple_flow_spec_container fsc, f;
175		175
176	list_for_each_entry_safe(fsc, f, &dev->ethtool_ntuple_list.list, list) {	176	list_for_each_entry_safe(fsc, f, &dev->ethtool_ntuple_list.list, list) {
177	list_del(&fsc->list);	177	list_del(&fsc->list);
178	kfree(fsc);	178	kfree(fsc);
179	}	179	}
180	dev->ethtool_ntuple_list.count = 0;	180	dev->ethtool_ntuple_list.count = 0;
181	}	181	}
182	EXPORT_SYMBOL(ethtool_ntuple_flush);	182	EXPORT_SYMBOL(ethtool_ntuple_flush);
183		183
184	/* Handlers for each ethtool command */	184	/* Handlers for each ethtool command */
185		185
186	#define ETHTOOL_DEV_FEATURE_WORDS 1	186	#define ETHTOOL_DEV_FEATURE_WORDS 1
187		187
188	static void ethtool_get_features_compat(struct net_device *dev,	188	static void ethtool_get_features_compat(struct net_device *dev,
189	struct ethtool_get_features_block *features)	189	struct ethtool_get_features_block *features)
190	{	190	{
191	if (!dev->ethtool_ops)	191	if (!dev->ethtool_ops)
192	return;	192	return;
193		193
194	/* getting RX checksum */	194	/* getting RX checksum */
195	if (dev->ethtool_ops->get_rx_csum)	195	if (dev->ethtool_ops->get_rx_csum)
196	if (dev->ethtool_ops->get_rx_csum(dev))	196	if (dev->ethtool_ops->get_rx_csum(dev))
197	features[0].active \|= NETIF_F_RXCSUM;	197	features[0].active \|= NETIF_F_RXCSUM;
198		198
199	/* mark legacy-changeable features */	199	/* mark legacy-changeable features */
200	if (dev->ethtool_ops->set_sg)	200	if (dev->ethtool_ops->set_sg)
201	features[0].available \|= NETIF_F_SG;	201	features[0].available \|= NETIF_F_SG;
202	if (dev->ethtool_ops->set_tx_csum)	202	if (dev->ethtool_ops->set_tx_csum)
203	features[0].available \|= NETIF_F_ALL_CSUM;	203	features[0].available \|= NETIF_F_ALL_CSUM;
204	if (dev->ethtool_ops->set_tso)	204	if (dev->ethtool_ops->set_tso)
205	features[0].available \|= NETIF_F_ALL_TSO;	205	features[0].available \|= NETIF_F_ALL_TSO;
206	if (dev->ethtool_ops->set_rx_csum)	206	if (dev->ethtool_ops->set_rx_csum)
207	features[0].available \|= NETIF_F_RXCSUM;	207	features[0].available \|= NETIF_F_RXCSUM;
208	if (dev->ethtool_ops->set_flags)	208	if (dev->ethtool_ops->set_flags)
209	features[0].available \|= flags_dup_features;	209	features[0].available \|= flags_dup_features;
210	}	210	}
211		211
212	static int ethtool_set_feature_compat(struct net_device *dev,	212	static int ethtool_set_feature_compat(struct net_device *dev,
213	int (legacy_set)(struct net_device , u32),	213	int (legacy_set)(struct net_device , u32),
214	struct ethtool_set_features_block *features, u32 mask)	214	struct ethtool_set_features_block *features, u32 mask)
215	{	215	{
216	u32 do_set;	216	u32 do_set;
217		217
218	if (!legacy_set)	218	if (!legacy_set)
219	return 0;	219	return 0;
220		220
221	if (!(features[0].valid & mask))	221	if (!(features[0].valid & mask))
222	return 0;	222	return 0;
223		223
224	features[0].valid &= ~mask;	224	features[0].valid &= ~mask;
225		225
226	do_set = !!(features[0].requested & mask);	226	do_set = !!(features[0].requested & mask);
227		227
228	if (legacy_set(dev, do_set) < 0)	228	if (legacy_set(dev, do_set) < 0)
229	netdev_info(dev,	229	netdev_info(dev,
230	"Legacy feature change (%s) failed for 0x%08x\n",	230	"Legacy feature change (%s) failed for 0x%08x\n",
231	do_set ? "set" : "clear", mask);	231	do_set ? "set" : "clear", mask);
232		232
233	return 1;	233	return 1;
234	}	234	}
235		235
236	static int ethtool_set_features_compat(struct net_device *dev,	236	static int ethtool_set_features_compat(struct net_device *dev,
237	struct ethtool_set_features_block *features)	237	struct ethtool_set_features_block *features)
238	{	238	{
239	int compat;	239	int compat;
240		240
241	if (!dev->ethtool_ops)	241	if (!dev->ethtool_ops)
242	return 0;	242	return 0;
243		243
244	compat = ethtool_set_feature_compat(dev, dev->ethtool_ops->set_sg,	244	compat = ethtool_set_feature_compat(dev, dev->ethtool_ops->set_sg,
245	features, NETIF_F_SG);	245	features, NETIF_F_SG);
246	compat \|= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tx_csum,	246	compat \|= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tx_csum,
247	features, NETIF_F_ALL_CSUM);	247	features, NETIF_F_ALL_CSUM);
248	compat \|= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tso,	248	compat \|= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tso,
249	features, NETIF_F_ALL_TSO);	249	features, NETIF_F_ALL_TSO);
250	compat \|= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_rx_csum,	250	compat \|= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_rx_csum,
251	features, NETIF_F_RXCSUM);	251	features, NETIF_F_RXCSUM);
252	compat \|= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_flags,	252	compat \|= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_flags,
253	features, flags_dup_features);	253	features, flags_dup_features);
254		254
255	return compat;	255	return compat;
256	}	256	}
257		257
258	static int ethtool_get_features(struct net_device dev, void __user useraddr)	258	static int ethtool_get_features(struct net_device dev, void __user useraddr)
259	{	259	{
260	struct ethtool_gfeatures cmd = {	260	struct ethtool_gfeatures cmd = {
261	.cmd = ETHTOOL_GFEATURES,	261	.cmd = ETHTOOL_GFEATURES,
262	.size = ETHTOOL_DEV_FEATURE_WORDS,	262	.size = ETHTOOL_DEV_FEATURE_WORDS,
263	};	263	};
264	struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS] = {	264	struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS] = {
265	{	265	{
266	.available = dev->hw_features,	266	.available = dev->hw_features,
267	.requested = dev->wanted_features,	267	.requested = dev->wanted_features,
268	.active = dev->features,	268	.active = dev->features,
269	.never_changed = NETIF_F_NEVER_CHANGE,	269	.never_changed = NETIF_F_NEVER_CHANGE,
270	},	270	},
271	};	271	};
272	u32 __user *sizeaddr;	272	u32 __user *sizeaddr;
273	u32 copy_size;	273	u32 copy_size;
274		274
275	ethtool_get_features_compat(dev, features);	275	ethtool_get_features_compat(dev, features);
276		276
277	sizeaddr = useraddr + offsetof(struct ethtool_gfeatures, size);	277	sizeaddr = useraddr + offsetof(struct ethtool_gfeatures, size);
278	if (get_user(copy_size, sizeaddr))	278	if (get_user(copy_size, sizeaddr))
279	return -EFAULT;	279	return -EFAULT;
280		280
281	if (copy_size > ETHTOOL_DEV_FEATURE_WORDS)	281	if (copy_size > ETHTOOL_DEV_FEATURE_WORDS)
282	copy_size = ETHTOOL_DEV_FEATURE_WORDS;	282	copy_size = ETHTOOL_DEV_FEATURE_WORDS;
283		283
284	if (copy_to_user(useraddr, &cmd, sizeof(cmd)))	284	if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
285	return -EFAULT;	285	return -EFAULT;
286	useraddr += sizeof(cmd);	286	useraddr += sizeof(cmd);
287	if (copy_to_user(useraddr, features, copy_size * sizeof(*features)))	287	if (copy_to_user(useraddr, features, copy_size * sizeof(*features)))
288	return -EFAULT;	288	return -EFAULT;
289		289
290	return 0;	290	return 0;
291	}	291	}
292		292
293	static int ethtool_set_features(struct net_device dev, void __user useraddr)	293	static int ethtool_set_features(struct net_device dev, void __user useraddr)
294	{	294	{
295	struct ethtool_sfeatures cmd;	295	struct ethtool_sfeatures cmd;
296	struct ethtool_set_features_block features[ETHTOOL_DEV_FEATURE_WORDS];	296	struct ethtool_set_features_block features[ETHTOOL_DEV_FEATURE_WORDS];
297	int ret = 0;	297	int ret = 0;
298		298
299	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))	299	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
300	return -EFAULT;	300	return -EFAULT;
301	useraddr += sizeof(cmd);	301	useraddr += sizeof(cmd);
302		302
303	if (cmd.size != ETHTOOL_DEV_FEATURE_WORDS)	303	if (cmd.size != ETHTOOL_DEV_FEATURE_WORDS)
304	return -EINVAL;	304	return -EINVAL;
305		305
306	if (copy_from_user(features, useraddr, sizeof(features)))	306	if (copy_from_user(features, useraddr, sizeof(features)))
307	return -EFAULT;	307	return -EFAULT;
308		308
309	if (features[0].valid & ~NETIF_F_ETHTOOL_BITS)	309	if (features[0].valid & ~NETIF_F_ETHTOOL_BITS)
310	return -EINVAL;	310	return -EINVAL;
311		311
312	if (ethtool_set_features_compat(dev, features))	312	if (ethtool_set_features_compat(dev, features))
313	ret \|= ETHTOOL_F_COMPAT;	313	ret \|= ETHTOOL_F_COMPAT;
314		314
315	if (features[0].valid & ~dev->hw_features) {	315	if (features[0].valid & ~dev->hw_features) {
316	features[0].valid &= dev->hw_features;	316	features[0].valid &= dev->hw_features;
317	ret \|= ETHTOOL_F_UNSUPPORTED;	317	ret \|= ETHTOOL_F_UNSUPPORTED;
318	}	318	}
319		319
320	dev->wanted_features &= ~features[0].valid;	320	dev->wanted_features &= ~features[0].valid;
321	dev->wanted_features \|= features[0].valid & features[0].requested;	321	dev->wanted_features \|= features[0].valid & features[0].requested;
322	__netdev_update_features(dev);	322	__netdev_update_features(dev);
323		323
324	if ((dev->wanted_features ^ dev->features) & features[0].valid)	324	if ((dev->wanted_features ^ dev->features) & features[0].valid)
325	ret \|= ETHTOOL_F_WISH;	325	ret \|= ETHTOOL_F_WISH;
326		326
327	return ret;	327	return ret;
328	}	328	}
329		329
330	static const char netdev_features_strings[ETHTOOL_DEV_FEATURE_WORDS * 32][ETH_GSTRING_LEN] = {	330	static const char netdev_features_strings[ETHTOOL_DEV_FEATURE_WORDS * 32][ETH_GSTRING_LEN] = {
331	/* NETIF_F_SG */ "tx-scatter-gather",	331	/* NETIF_F_SG */ "tx-scatter-gather",
332	/* NETIF_F_IP_CSUM */ "tx-checksum-ipv4",	332	/* NETIF_F_IP_CSUM */ "tx-checksum-ipv4",
333	/* NETIF_F_NO_CSUM */ "tx-checksum-unneeded",	333	/* NETIF_F_NO_CSUM */ "tx-checksum-unneeded",
334	/* NETIF_F_HW_CSUM */ "tx-checksum-ip-generic",	334	/* NETIF_F_HW_CSUM */ "tx-checksum-ip-generic",
335	/* NETIF_F_IPV6_CSUM */ "tx_checksum-ipv6",	335	/* NETIF_F_IPV6_CSUM */ "tx_checksum-ipv6",
336	/* NETIF_F_HIGHDMA */ "highdma",	336	/* NETIF_F_HIGHDMA */ "highdma",
337	/* NETIF_F_FRAGLIST */ "tx-scatter-gather-fraglist",	337	/* NETIF_F_FRAGLIST */ "tx-scatter-gather-fraglist",
338	/* NETIF_F_HW_VLAN_TX */ "tx-vlan-hw-insert",	338	/* NETIF_F_HW_VLAN_TX */ "tx-vlan-hw-insert",
339		339
340	/* NETIF_F_HW_VLAN_RX */ "rx-vlan-hw-parse",	340	/* NETIF_F_HW_VLAN_RX */ "rx-vlan-hw-parse",
341	/* NETIF_F_HW_VLAN_FILTER */ "rx-vlan-filter",	341	/* NETIF_F_HW_VLAN_FILTER */ "rx-vlan-filter",
342	/* NETIF_F_VLAN_CHALLENGED */ "vlan-challenged",	342	/* NETIF_F_VLAN_CHALLENGED */ "vlan-challenged",
343	/* NETIF_F_GSO */ "tx-generic-segmentation",	343	/* NETIF_F_GSO */ "tx-generic-segmentation",
344	/* NETIF_F_LLTX */ "tx-lockless",	344	/* NETIF_F_LLTX */ "tx-lockless",
345	/* NETIF_F_NETNS_LOCAL */ "netns-local",	345	/* NETIF_F_NETNS_LOCAL */ "netns-local",
346	/* NETIF_F_GRO */ "rx-gro",	346	/* NETIF_F_GRO */ "rx-gro",
347	/* NETIF_F_LRO */ "rx-lro",	347	/* NETIF_F_LRO */ "rx-lro",
348		348
349	/* NETIF_F_TSO */ "tx-tcp-segmentation",	349	/* NETIF_F_TSO */ "tx-tcp-segmentation",
350	/* NETIF_F_UFO */ "tx-udp-fragmentation",	350	/* NETIF_F_UFO */ "tx-udp-fragmentation",
351	/* NETIF_F_GSO_ROBUST */ "tx-gso-robust",	351	/* NETIF_F_GSO_ROBUST */ "tx-gso-robust",
352	/* NETIF_F_TSO_ECN */ "tx-tcp-ecn-segmentation",	352	/* NETIF_F_TSO_ECN */ "tx-tcp-ecn-segmentation",
353	/* NETIF_F_TSO6 */ "tx-tcp6-segmentation",	353	/* NETIF_F_TSO6 */ "tx-tcp6-segmentation",
354	/* NETIF_F_FSO */ "tx-fcoe-segmentation",	354	/* NETIF_F_FSO */ "tx-fcoe-segmentation",
355	"",	355	"",
356	"",	356	"",
357		357
358	/* NETIF_F_FCOE_CRC */ "tx-checksum-fcoe-crc",	358	/* NETIF_F_FCOE_CRC */ "tx-checksum-fcoe-crc",
359	/* NETIF_F_SCTP_CSUM */ "tx-checksum-sctp",	359	/* NETIF_F_SCTP_CSUM */ "tx-checksum-sctp",
360	/* NETIF_F_FCOE_MTU */ "fcoe-mtu",	360	/* NETIF_F_FCOE_MTU */ "fcoe-mtu",
361	/* NETIF_F_NTUPLE */ "rx-ntuple-filter",	361	/* NETIF_F_NTUPLE */ "rx-ntuple-filter",
362	/* NETIF_F_RXHASH */ "rx-hashing",	362	/* NETIF_F_RXHASH */ "rx-hashing",
363	/* NETIF_F_RXCSUM */ "rx-checksum",	363	/* NETIF_F_RXCSUM */ "rx-checksum",
364	/* NETIF_F_NOCACHE_COPY */ "tx-nocache-copy"	364	/* NETIF_F_NOCACHE_COPY */ "tx-nocache-copy"
365	"",	365	/* NETIF_F_LOOPBACK */ "loopback",
366	};	366	};
367		367
368	static int __ethtool_get_sset_count(struct net_device *dev, int sset)	368	static int __ethtool_get_sset_count(struct net_device *dev, int sset)
369	{	369	{
370	const struct ethtool_ops *ops = dev->ethtool_ops;	370	const struct ethtool_ops *ops = dev->ethtool_ops;
371		371
372	if (sset == ETH_SS_FEATURES)	372	if (sset == ETH_SS_FEATURES)
373	return ARRAY_SIZE(netdev_features_strings);	373	return ARRAY_SIZE(netdev_features_strings);
374		374
375	if (ops && ops->get_sset_count && ops->get_strings)	375	if (ops && ops->get_sset_count && ops->get_strings)
376	return ops->get_sset_count(dev, sset);	376	return ops->get_sset_count(dev, sset);
377	else	377	else
378	return -EOPNOTSUPP;	378	return -EOPNOTSUPP;
379	}	379	}
380		380
381	static void __ethtool_get_strings(struct net_device *dev,	381	static void __ethtool_get_strings(struct net_device *dev,
382	u32 stringset, u8 *data)	382	u32 stringset, u8 *data)
383	{	383	{
384	const struct ethtool_ops *ops = dev->ethtool_ops;	384	const struct ethtool_ops *ops = dev->ethtool_ops;
385		385
386	if (stringset == ETH_SS_FEATURES)	386	if (stringset == ETH_SS_FEATURES)
387	memcpy(data, netdev_features_strings,	387	memcpy(data, netdev_features_strings,
388	sizeof(netdev_features_strings));	388	sizeof(netdev_features_strings));
389	else	389	else
390	/* ops->get_strings is valid because checked earlier */	390	/* ops->get_strings is valid because checked earlier */
391	ops->get_strings(dev, stringset, data);	391	ops->get_strings(dev, stringset, data);
392	}	392	}
393		393
394	static u32 ethtool_get_feature_mask(u32 eth_cmd)	394	static u32 ethtool_get_feature_mask(u32 eth_cmd)
395	{	395	{
396	/* feature masks of legacy discrete ethtool ops */	396	/* feature masks of legacy discrete ethtool ops */
397		397
398	switch (eth_cmd) {	398	switch (eth_cmd) {
399	case ETHTOOL_GTXCSUM:	399	case ETHTOOL_GTXCSUM:
400	case ETHTOOL_STXCSUM:	400	case ETHTOOL_STXCSUM:
401	return NETIF_F_ALL_CSUM \| NETIF_F_SCTP_CSUM;	401	return NETIF_F_ALL_CSUM \| NETIF_F_SCTP_CSUM;
402	case ETHTOOL_GRXCSUM:	402	case ETHTOOL_GRXCSUM:
403	case ETHTOOL_SRXCSUM:	403	case ETHTOOL_SRXCSUM:
404	return NETIF_F_RXCSUM;	404	return NETIF_F_RXCSUM;
405	case ETHTOOL_GSG:	405	case ETHTOOL_GSG:
406	case ETHTOOL_SSG:	406	case ETHTOOL_SSG:
407	return NETIF_F_SG;	407	return NETIF_F_SG;
408	case ETHTOOL_GTSO:	408	case ETHTOOL_GTSO:
409	case ETHTOOL_STSO:	409	case ETHTOOL_STSO:
410	return NETIF_F_ALL_TSO;	410	return NETIF_F_ALL_TSO;
411	case ETHTOOL_GUFO:	411	case ETHTOOL_GUFO:
412	case ETHTOOL_SUFO:	412	case ETHTOOL_SUFO:
413	return NETIF_F_UFO;	413	return NETIF_F_UFO;
414	case ETHTOOL_GGSO:	414	case ETHTOOL_GGSO:
415	case ETHTOOL_SGSO:	415	case ETHTOOL_SGSO:
416	return NETIF_F_GSO;	416	return NETIF_F_GSO;
417	case ETHTOOL_GGRO:	417	case ETHTOOL_GGRO:
418	case ETHTOOL_SGRO:	418	case ETHTOOL_SGRO:
419	return NETIF_F_GRO;	419	return NETIF_F_GRO;
420	default:	420	default:
421	BUG();	421	BUG();
422	}	422	}
423	}	423	}
424		424
425	static void __ethtool_get_one_feature_actor(struct net_device dev, u32 ethcmd)	425	static void __ethtool_get_one_feature_actor(struct net_device dev, u32 ethcmd)
426	{	426	{
427	const struct ethtool_ops *ops = dev->ethtool_ops;	427	const struct ethtool_ops *ops = dev->ethtool_ops;
428		428
429	if (!ops)	429	if (!ops)
430	return NULL;	430	return NULL;
431		431
432	switch (ethcmd) {	432	switch (ethcmd) {
433	case ETHTOOL_GTXCSUM:	433	case ETHTOOL_GTXCSUM:
434	return ops->get_tx_csum;	434	return ops->get_tx_csum;
435	case ETHTOOL_GRXCSUM:	435	case ETHTOOL_GRXCSUM:
436	return ops->get_rx_csum;	436	return ops->get_rx_csum;
437	case ETHTOOL_SSG:	437	case ETHTOOL_SSG:
438	return ops->get_sg;	438	return ops->get_sg;
439	case ETHTOOL_STSO:	439	case ETHTOOL_STSO:
440	return ops->get_tso;	440	return ops->get_tso;
441	case ETHTOOL_SUFO:	441	case ETHTOOL_SUFO:
442	return ops->get_ufo;	442	return ops->get_ufo;
443	default:	443	default:
444	return NULL;	444	return NULL;
445	}	445	}
446	}	446	}
447		447
448	static u32 __ethtool_get_rx_csum_oldbug(struct net_device *dev)	448	static u32 __ethtool_get_rx_csum_oldbug(struct net_device *dev)
449	{	449	{
450	return !!(dev->features & NETIF_F_ALL_CSUM);	450	return !!(dev->features & NETIF_F_ALL_CSUM);
451	}	451	}
452		452
453	static int ethtool_get_one_feature(struct net_device *dev,	453	static int ethtool_get_one_feature(struct net_device *dev,
454	char __user *useraddr, u32 ethcmd)	454	char __user *useraddr, u32 ethcmd)
455	{	455	{
456	u32 mask = ethtool_get_feature_mask(ethcmd);	456	u32 mask = ethtool_get_feature_mask(ethcmd);
457	struct ethtool_value edata = {	457	struct ethtool_value edata = {
458	.cmd = ethcmd,	458	.cmd = ethcmd,
459	.data = !!(dev->features & mask),	459	.data = !!(dev->features & mask),
460	};	460	};
461		461
462	/* compatibility with discrete get_ ops */	462	/* compatibility with discrete get_ ops */
463	if (!(dev->hw_features & mask)) {	463	if (!(dev->hw_features & mask)) {
464	u32 (actor)(struct net_device );	464	u32 (actor)(struct net_device );
465		465
466	actor = __ethtool_get_one_feature_actor(dev, ethcmd);	466	actor = __ethtool_get_one_feature_actor(dev, ethcmd);
467		467
468	/* bug compatibility with old get_rx_csum */	468	/* bug compatibility with old get_rx_csum */
469	if (ethcmd == ETHTOOL_GRXCSUM && !actor)	469	if (ethcmd == ETHTOOL_GRXCSUM && !actor)
470	actor = __ethtool_get_rx_csum_oldbug;	470	actor = __ethtool_get_rx_csum_oldbug;
471		471
472	if (actor)	472	if (actor)
473	edata.data = actor(dev);	473	edata.data = actor(dev);
474	}	474	}
475		475
476	if (copy_to_user(useraddr, &edata, sizeof(edata)))	476	if (copy_to_user(useraddr, &edata, sizeof(edata)))
477	return -EFAULT;	477	return -EFAULT;
478	return 0;	478	return 0;
479	}	479	}
480		480
481	static int __ethtool_set_tx_csum(struct net_device *dev, u32 data);	481	static int __ethtool_set_tx_csum(struct net_device *dev, u32 data);
482	static int __ethtool_set_rx_csum(struct net_device *dev, u32 data);	482	static int __ethtool_set_rx_csum(struct net_device *dev, u32 data);
483	static int __ethtool_set_sg(struct net_device *dev, u32 data);	483	static int __ethtool_set_sg(struct net_device *dev, u32 data);
484	static int __ethtool_set_tso(struct net_device *dev, u32 data);	484	static int __ethtool_set_tso(struct net_device *dev, u32 data);
485	static int __ethtool_set_ufo(struct net_device *dev, u32 data);	485	static int __ethtool_set_ufo(struct net_device *dev, u32 data);
486		486
487	static int ethtool_set_one_feature(struct net_device *dev,	487	static int ethtool_set_one_feature(struct net_device *dev,
488	void __user *useraddr, u32 ethcmd)	488	void __user *useraddr, u32 ethcmd)
489	{	489	{
490	struct ethtool_value edata;	490	struct ethtool_value edata;
491	u32 mask;	491	u32 mask;
492		492
493	if (copy_from_user(&edata, useraddr, sizeof(edata)))	493	if (copy_from_user(&edata, useraddr, sizeof(edata)))
494	return -EFAULT;	494	return -EFAULT;
495		495
496	mask = ethtool_get_feature_mask(ethcmd);	496	mask = ethtool_get_feature_mask(ethcmd);
497	mask &= dev->hw_features;	497	mask &= dev->hw_features;
498	if (mask) {	498	if (mask) {
499	if (edata.data)	499	if (edata.data)
500	dev->wanted_features \|= mask;	500	dev->wanted_features \|= mask;
501	else	501	else
502	dev->wanted_features &= ~mask;	502	dev->wanted_features &= ~mask;
503		503
504	__netdev_update_features(dev);	504	__netdev_update_features(dev);
505	return 0;	505	return 0;
506	}	506	}
507		507
508	/* Driver is not converted to ndo_fix_features or does not	508	/* Driver is not converted to ndo_fix_features or does not
509	* support changing this offload. In the latter case it won't	509	* support changing this offload. In the latter case it won't
510	* have corresponding ethtool_ops field set.	510	* have corresponding ethtool_ops field set.
511	*	511	*
512	* Following part is to be removed after all drivers advertise	512	* Following part is to be removed after all drivers advertise
513	* their changeable features in netdev->hw_features and stop	513	* their changeable features in netdev->hw_features and stop
514	* using discrete offload setting ops.	514	* using discrete offload setting ops.
515	*/	515	*/
516		516
517	switch (ethcmd) {	517	switch (ethcmd) {
518	case ETHTOOL_STXCSUM:	518	case ETHTOOL_STXCSUM:
519	return __ethtool_set_tx_csum(dev, edata.data);	519	return __ethtool_set_tx_csum(dev, edata.data);
520	case ETHTOOL_SRXCSUM:	520	case ETHTOOL_SRXCSUM:
521	return __ethtool_set_rx_csum(dev, edata.data);	521	return __ethtool_set_rx_csum(dev, edata.data);
522	case ETHTOOL_SSG:	522	case ETHTOOL_SSG:
523	return __ethtool_set_sg(dev, edata.data);	523	return __ethtool_set_sg(dev, edata.data);
524	case ETHTOOL_STSO:	524	case ETHTOOL_STSO:
525	return __ethtool_set_tso(dev, edata.data);	525	return __ethtool_set_tso(dev, edata.data);
526	case ETHTOOL_SUFO:	526	case ETHTOOL_SUFO:
527	return __ethtool_set_ufo(dev, edata.data);	527	return __ethtool_set_ufo(dev, edata.data);
528	default:	528	default:
529	return -EOPNOTSUPP;	529	return -EOPNOTSUPP;
530	}	530	}
531	}	531	}
532		532
533	int __ethtool_set_flags(struct net_device *dev, u32 data)	533	int __ethtool_set_flags(struct net_device *dev, u32 data)
534	{	534	{
535	u32 changed;	535	u32 changed;
536		536
537	if (data & ~flags_dup_features)	537	if (data & ~flags_dup_features)
538	return -EINVAL;	538	return -EINVAL;
539		539
540	/* legacy set_flags() op */	540	/* legacy set_flags() op */
541	if (dev->ethtool_ops->set_flags) {	541	if (dev->ethtool_ops->set_flags) {
542	if (unlikely(dev->hw_features & flags_dup_features))	542	if (unlikely(dev->hw_features & flags_dup_features))
543	netdev_warn(dev,	543	netdev_warn(dev,
544	"driver BUG: mixed hw_features and set_flags()\n");	544	"driver BUG: mixed hw_features and set_flags()\n");
545	return dev->ethtool_ops->set_flags(dev, data);	545	return dev->ethtool_ops->set_flags(dev, data);
546	}	546	}
547		547
548	/* allow changing only bits set in hw_features */	548	/* allow changing only bits set in hw_features */
549	changed = (data ^ dev->features) & flags_dup_features;	549	changed = (data ^ dev->features) & flags_dup_features;
550	if (changed & ~dev->hw_features)	550	if (changed & ~dev->hw_features)
551	return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP;	551	return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP;
552		552
553	dev->wanted_features =	553	dev->wanted_features =
554	(dev->wanted_features & ~changed) \| (data & dev->hw_features);	554	(dev->wanted_features & ~changed) \| (data & dev->hw_features);
555		555
556	__netdev_update_features(dev);	556	__netdev_update_features(dev);
557		557
558	return 0;	558	return 0;
559	}	559	}
560		560
561	static int ethtool_get_settings(struct net_device dev, void __user useraddr)	561	static int ethtool_get_settings(struct net_device dev, void __user useraddr)
562	{	562	{
563	struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };	563	struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
564	int err;	564	int err;
565		565
566	if (!dev->ethtool_ops->get_settings)	566	if (!dev->ethtool_ops->get_settings)
567	return -EOPNOTSUPP;	567	return -EOPNOTSUPP;
568		568
569	err = dev->ethtool_ops->get_settings(dev, &cmd);	569	err = dev->ethtool_ops->get_settings(dev, &cmd);
570	if (err < 0)	570	if (err < 0)
571	return err;	571	return err;
572		572
573	if (copy_to_user(useraddr, &cmd, sizeof(cmd)))	573	if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
574	return -EFAULT;	574	return -EFAULT;
575	return 0;	575	return 0;
576	}	576	}
577		577
578	static int ethtool_set_settings(struct net_device dev, void __user useraddr)	578	static int ethtool_set_settings(struct net_device dev, void __user useraddr)
579	{	579	{
580	struct ethtool_cmd cmd;	580	struct ethtool_cmd cmd;
581		581
582	if (!dev->ethtool_ops->set_settings)	582	if (!dev->ethtool_ops->set_settings)
583	return -EOPNOTSUPP;	583	return -EOPNOTSUPP;
584		584
585	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))	585	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
586	return -EFAULT;	586	return -EFAULT;
587		587
588	return dev->ethtool_ops->set_settings(dev, &cmd);	588	return dev->ethtool_ops->set_settings(dev, &cmd);
589	}	589	}
590		590
591	static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,	591	static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
592	void __user *useraddr)	592	void __user *useraddr)
593	{	593	{
594	struct ethtool_drvinfo info;	594	struct ethtool_drvinfo info;
595	const struct ethtool_ops *ops = dev->ethtool_ops;	595	const struct ethtool_ops *ops = dev->ethtool_ops;
596		596
597	memset(&info, 0, sizeof(info));	597	memset(&info, 0, sizeof(info));
598	info.cmd = ETHTOOL_GDRVINFO;	598	info.cmd = ETHTOOL_GDRVINFO;
599	if (ops && ops->get_drvinfo) {	599	if (ops && ops->get_drvinfo) {
600	ops->get_drvinfo(dev, &info);	600	ops->get_drvinfo(dev, &info);
601	} else if (dev->dev.parent && dev->dev.parent->driver) {	601	} else if (dev->dev.parent && dev->dev.parent->driver) {
602	strlcpy(info.bus_info, dev_name(dev->dev.parent),	602	strlcpy(info.bus_info, dev_name(dev->dev.parent),
603	sizeof(info.bus_info));	603	sizeof(info.bus_info));
604	strlcpy(info.driver, dev->dev.parent->driver->name,	604	strlcpy(info.driver, dev->dev.parent->driver->name,
605	sizeof(info.driver));	605	sizeof(info.driver));
606	} else {	606	} else {
607	return -EOPNOTSUPP;	607	return -EOPNOTSUPP;
608	}	608	}
609		609
610	/*	610	/*
611	* this method of obtaining string set info is deprecated;	611	* this method of obtaining string set info is deprecated;
612	* Use ETHTOOL_GSSET_INFO instead.	612	* Use ETHTOOL_GSSET_INFO instead.
613	*/	613	*/
614	if (ops && ops->get_sset_count) {	614	if (ops && ops->get_sset_count) {
615	int rc;	615	int rc;
616		616
617	rc = ops->get_sset_count(dev, ETH_SS_TEST);	617	rc = ops->get_sset_count(dev, ETH_SS_TEST);
618	if (rc >= 0)	618	if (rc >= 0)
619	info.testinfo_len = rc;	619	info.testinfo_len = rc;
620	rc = ops->get_sset_count(dev, ETH_SS_STATS);	620	rc = ops->get_sset_count(dev, ETH_SS_STATS);
621	if (rc >= 0)	621	if (rc >= 0)
622	info.n_stats = rc;	622	info.n_stats = rc;
623	rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);	623	rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
624	if (rc >= 0)	624	if (rc >= 0)
625	info.n_priv_flags = rc;	625	info.n_priv_flags = rc;
626	}	626	}
627	if (ops && ops->get_regs_len)	627	if (ops && ops->get_regs_len)
628	info.regdump_len = ops->get_regs_len(dev);	628	info.regdump_len = ops->get_regs_len(dev);
629	if (ops && ops->get_eeprom_len)	629	if (ops && ops->get_eeprom_len)
630	info.eedump_len = ops->get_eeprom_len(dev);	630	info.eedump_len = ops->get_eeprom_len(dev);
631		631
632	if (copy_to_user(useraddr, &info, sizeof(info)))	632	if (copy_to_user(useraddr, &info, sizeof(info)))
633	return -EFAULT;	633	return -EFAULT;
634	return 0;	634	return 0;
635	}	635	}
636		636
637	static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,	637	static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
638	void __user *useraddr)	638	void __user *useraddr)
639	{	639	{
640	struct ethtool_sset_info info;	640	struct ethtool_sset_info info;
641	u64 sset_mask;	641	u64 sset_mask;
642	int i, idx = 0, n_bits = 0, ret, rc;	642	int i, idx = 0, n_bits = 0, ret, rc;
643	u32 *info_buf = NULL;	643	u32 *info_buf = NULL;
644		644
645	if (copy_from_user(&info, useraddr, sizeof(info)))	645	if (copy_from_user(&info, useraddr, sizeof(info)))
646	return -EFAULT;	646	return -EFAULT;
647		647
648	/* store copy of mask, because we zero struct later on */	648	/* store copy of mask, because we zero struct later on */
649	sset_mask = info.sset_mask;	649	sset_mask = info.sset_mask;
650	if (!sset_mask)	650	if (!sset_mask)
651	return 0;	651	return 0;
652		652
653	/* calculate size of return buffer */	653	/* calculate size of return buffer */
654	n_bits = hweight64(sset_mask);	654	n_bits = hweight64(sset_mask);
655		655
656	memset(&info, 0, sizeof(info));	656	memset(&info, 0, sizeof(info));
657	info.cmd = ETHTOOL_GSSET_INFO;	657	info.cmd = ETHTOOL_GSSET_INFO;
658		658
659	info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);	659	info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
660	if (!info_buf)	660	if (!info_buf)
661	return -ENOMEM;	661	return -ENOMEM;
662		662
663	/*	663	/*
664	* fill return buffer based on input bitmask and successful	664	* fill return buffer based on input bitmask and successful
665	* get_sset_count return	665	* get_sset_count return
666	*/	666	*/
667	for (i = 0; i < 64; i++) {	667	for (i = 0; i < 64; i++) {
668	if (!(sset_mask & (1ULL << i)))	668	if (!(sset_mask & (1ULL << i)))
669	continue;	669	continue;
670		670
671	rc = __ethtool_get_sset_count(dev, i);	671	rc = __ethtool_get_sset_count(dev, i);
672	if (rc >= 0) {	672	if (rc >= 0) {
673	info.sset_mask \|= (1ULL << i);	673	info.sset_mask \|= (1ULL << i);
674	info_buf[idx++] = rc;	674	info_buf[idx++] = rc;
675	}	675	}
676	}	676	}
677		677
678	ret = -EFAULT;	678	ret = -EFAULT;
679	if (copy_to_user(useraddr, &info, sizeof(info)))	679	if (copy_to_user(useraddr, &info, sizeof(info)))
680	goto out;	680	goto out;
681		681
682	useraddr += offsetof(struct ethtool_sset_info, data);	682	useraddr += offsetof(struct ethtool_sset_info, data);
683	if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))	683	if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
684	goto out;	684	goto out;
685		685
686	ret = 0;	686	ret = 0;
687		687
688	out:	688	out:
689	kfree(info_buf);	689	kfree(info_buf);
690	return ret;	690	return ret;
691	}	691	}
692		692
693	static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,	693	static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
694	u32 cmd, void __user *useraddr)	694	u32 cmd, void __user *useraddr)
695	{	695	{
696	struct ethtool_rxnfc info;	696	struct ethtool_rxnfc info;
697	size_t info_size = sizeof(info);	697	size_t info_size = sizeof(info);
698		698
699	if (!dev->ethtool_ops->set_rxnfc)	699	if (!dev->ethtool_ops->set_rxnfc)
700	return -EOPNOTSUPP;	700	return -EOPNOTSUPP;
701		701
702	/* struct ethtool_rxnfc was originally defined for	702	/* struct ethtool_rxnfc was originally defined for
703	* ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data	703	* ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
704	* members. User-space might still be using that	704	* members. User-space might still be using that
705	* definition. */	705	* definition. */
706	if (cmd == ETHTOOL_SRXFH)	706	if (cmd == ETHTOOL_SRXFH)
707	info_size = (offsetof(struct ethtool_rxnfc, data) +	707	info_size = (offsetof(struct ethtool_rxnfc, data) +
708	sizeof(info.data));	708	sizeof(info.data));
709		709
710	if (copy_from_user(&info, useraddr, info_size))	710	if (copy_from_user(&info, useraddr, info_size))
711	return -EFAULT;	711	return -EFAULT;
712		712
713	return dev->ethtool_ops->set_rxnfc(dev, &info);	713	return dev->ethtool_ops->set_rxnfc(dev, &info);
714	}	714	}
715		715
716	static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,	716	static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
717	u32 cmd, void __user *useraddr)	717	u32 cmd, void __user *useraddr)
718	{	718	{
719	struct ethtool_rxnfc info;	719	struct ethtool_rxnfc info;
720	size_t info_size = sizeof(info);	720	size_t info_size = sizeof(info);
721	const struct ethtool_ops *ops = dev->ethtool_ops;	721	const struct ethtool_ops *ops = dev->ethtool_ops;
722	int ret;	722	int ret;
723	void *rule_buf = NULL;	723	void *rule_buf = NULL;
724		724
725	if (!ops->get_rxnfc)	725	if (!ops->get_rxnfc)
726	return -EOPNOTSUPP;	726	return -EOPNOTSUPP;
727		727
728	/* struct ethtool_rxnfc was originally defined for	728	/* struct ethtool_rxnfc was originally defined for
729	* ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data	729	* ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
730	* members. User-space might still be using that	730	* members. User-space might still be using that
731	* definition. */	731	* definition. */
732	if (cmd == ETHTOOL_GRXFH)	732	if (cmd == ETHTOOL_GRXFH)
733	info_size = (offsetof(struct ethtool_rxnfc, data) +	733	info_size = (offsetof(struct ethtool_rxnfc, data) +
734	sizeof(info.data));	734	sizeof(info.data));
735		735
736	if (copy_from_user(&info, useraddr, info_size))	736	if (copy_from_user(&info, useraddr, info_size))
737	return -EFAULT;	737	return -EFAULT;
738		738
739	if (info.cmd == ETHTOOL_GRXCLSRLALL) {	739	if (info.cmd == ETHTOOL_GRXCLSRLALL) {
740	if (info.rule_cnt > 0) {	740	if (info.rule_cnt > 0) {
741	if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))	741	if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
742	rule_buf = kzalloc(info.rule_cnt * sizeof(u32),	742	rule_buf = kzalloc(info.rule_cnt * sizeof(u32),
743	GFP_USER);	743	GFP_USER);
744	if (!rule_buf)	744	if (!rule_buf)
745	return -ENOMEM;	745	return -ENOMEM;
746	}	746	}
747	}	747	}
748		748
749	ret = ops->get_rxnfc(dev, &info, rule_buf);	749	ret = ops->get_rxnfc(dev, &info, rule_buf);
750	if (ret < 0)	750	if (ret < 0)
751	goto err_out;	751	goto err_out;
752		752
753	ret = -EFAULT;	753	ret = -EFAULT;
754	if (copy_to_user(useraddr, &info, info_size))	754	if (copy_to_user(useraddr, &info, info_size))
755	goto err_out;	755	goto err_out;
756		756
757	if (rule_buf) {	757	if (rule_buf) {
758	useraddr += offsetof(struct ethtool_rxnfc, rule_locs);	758	useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
759	if (copy_to_user(useraddr, rule_buf,	759	if (copy_to_user(useraddr, rule_buf,
760	info.rule_cnt * sizeof(u32)))	760	info.rule_cnt * sizeof(u32)))
761	goto err_out;	761	goto err_out;
762	}	762	}
763	ret = 0;	763	ret = 0;
764		764
765	err_out:	765	err_out:
766	kfree(rule_buf);	766	kfree(rule_buf);
767		767
768	return ret;	768	return ret;
769	}	769	}
770		770
771	static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,	771	static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,
772	void __user *useraddr)	772	void __user *useraddr)
773	{	773	{
774	struct ethtool_rxfh_indir *indir;	774	struct ethtool_rxfh_indir *indir;
775	u32 table_size;	775	u32 table_size;
776	size_t full_size;	776	size_t full_size;
777	int ret;	777	int ret;
778		778
779	if (!dev->ethtool_ops->get_rxfh_indir)	779	if (!dev->ethtool_ops->get_rxfh_indir)
780	return -EOPNOTSUPP;	780	return -EOPNOTSUPP;
781		781
782	if (copy_from_user(&table_size,	782	if (copy_from_user(&table_size,
783	useraddr + offsetof(struct ethtool_rxfh_indir, size),	783	useraddr + offsetof(struct ethtool_rxfh_indir, size),
784	sizeof(table_size)))	784	sizeof(table_size)))
785	return -EFAULT;	785	return -EFAULT;
786		786
787	if (table_size >	787	if (table_size >
788	(KMALLOC_MAX_SIZE - sizeof(indir)) / sizeof(indir->ring_index))	788	(KMALLOC_MAX_SIZE - sizeof(indir)) / sizeof(indir->ring_index))
789	return -ENOMEM;	789	return -ENOMEM;
790	full_size = sizeof(indir) + sizeof(indir->ring_index) * table_size;	790	full_size = sizeof(indir) + sizeof(indir->ring_index) * table_size;
791	indir = kzalloc(full_size, GFP_USER);	791	indir = kzalloc(full_size, GFP_USER);
792	if (!indir)	792	if (!indir)
793	return -ENOMEM;	793	return -ENOMEM;
794		794
795	indir->cmd = ETHTOOL_GRXFHINDIR;	795	indir->cmd = ETHTOOL_GRXFHINDIR;
796	indir->size = table_size;	796	indir->size = table_size;
797	ret = dev->ethtool_ops->get_rxfh_indir(dev, indir);	797	ret = dev->ethtool_ops->get_rxfh_indir(dev, indir);
798	if (ret)	798	if (ret)
799	goto out;	799	goto out;
800		800
801	if (copy_to_user(useraddr, indir, full_size))	801	if (copy_to_user(useraddr, indir, full_size))
802	ret = -EFAULT;	802	ret = -EFAULT;
803		803
804	out:	804	out:
805	kfree(indir);	805	kfree(indir);
806	return ret;	806	return ret;
807	}	807	}
808		808
809	static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,	809	static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,
810	void __user *useraddr)	810	void __user *useraddr)
811	{	811	{
812	struct ethtool_rxfh_indir *indir;	812	struct ethtool_rxfh_indir *indir;
813	u32 table_size;	813	u32 table_size;
814	size_t full_size;	814	size_t full_size;
815	int ret;	815	int ret;
816		816
817	if (!dev->ethtool_ops->set_rxfh_indir)	817	if (!dev->ethtool_ops->set_rxfh_indir)
818	return -EOPNOTSUPP;	818	return -EOPNOTSUPP;
819		819
820	if (copy_from_user(&table_size,	820	if (copy_from_user(&table_size,
821	useraddr + offsetof(struct ethtool_rxfh_indir, size),	821	useraddr + offsetof(struct ethtool_rxfh_indir, size),
822	sizeof(table_size)))	822	sizeof(table_size)))
823	return -EFAULT;	823	return -EFAULT;
824		824
825	if (table_size >	825	if (table_size >
826	(KMALLOC_MAX_SIZE - sizeof(indir)) / sizeof(indir->ring_index))	826	(KMALLOC_MAX_SIZE - sizeof(indir)) / sizeof(indir->ring_index))
827	return -ENOMEM;	827	return -ENOMEM;
828	full_size = sizeof(indir) + sizeof(indir->ring_index) * table_size;	828	full_size = sizeof(indir) + sizeof(indir->ring_index) * table_size;
829	indir = kmalloc(full_size, GFP_USER);	829	indir = kmalloc(full_size, GFP_USER);
830	if (!indir)	830	if (!indir)
831	return -ENOMEM;	831	return -ENOMEM;
832		832
833	if (copy_from_user(indir, useraddr, full_size)) {	833	if (copy_from_user(indir, useraddr, full_size)) {
834	ret = -EFAULT;	834	ret = -EFAULT;
835	goto out;	835	goto out;
836	}	836	}
837		837
838	ret = dev->ethtool_ops->set_rxfh_indir(dev, indir);	838	ret = dev->ethtool_ops->set_rxfh_indir(dev, indir);
839		839
840	out:	840	out:
841	kfree(indir);	841	kfree(indir);
842	return ret;	842	return ret;
843	}	843	}
844		844
845	static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,	845	static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,
846	struct ethtool_rx_ntuple_flow_spec *spec,	846	struct ethtool_rx_ntuple_flow_spec *spec,
847	struct ethtool_rx_ntuple_flow_spec_container *fsc)	847	struct ethtool_rx_ntuple_flow_spec_container *fsc)
848	{	848	{
849		849
850	/* don't add filters forever */	850	/* don't add filters forever */
851	if (list->count >= ETHTOOL_MAX_NTUPLE_LIST_ENTRY) {	851	if (list->count >= ETHTOOL_MAX_NTUPLE_LIST_ENTRY) {
852	/* free the container */	852	/* free the container */
853	kfree(fsc);	853	kfree(fsc);
854	return;	854	return;
855	}	855	}
856		856
857	/* Copy the whole filter over */	857	/* Copy the whole filter over */
858	fsc->fs.flow_type = spec->flow_type;	858	fsc->fs.flow_type = spec->flow_type;
859	memcpy(&fsc->fs.h_u, &spec->h_u, sizeof(spec->h_u));	859	memcpy(&fsc->fs.h_u, &spec->h_u, sizeof(spec->h_u));
860	memcpy(&fsc->fs.m_u, &spec->m_u, sizeof(spec->m_u));	860	memcpy(&fsc->fs.m_u, &spec->m_u, sizeof(spec->m_u));
861		861
862	fsc->fs.vlan_tag = spec->vlan_tag;	862	fsc->fs.vlan_tag = spec->vlan_tag;
863	fsc->fs.vlan_tag_mask = spec->vlan_tag_mask;	863	fsc->fs.vlan_tag_mask = spec->vlan_tag_mask;
864	fsc->fs.data = spec->data;	864	fsc->fs.data = spec->data;
865	fsc->fs.data_mask = spec->data_mask;	865	fsc->fs.data_mask = spec->data_mask;
866	fsc->fs.action = spec->action;	866	fsc->fs.action = spec->action;
867		867
868	/* add to the list */	868	/* add to the list */
869	list_add_tail_rcu(&fsc->list, &list->list);	869	list_add_tail_rcu(&fsc->list, &list->list);
870	list->count++;	870	list->count++;
871	}	871	}
872		872
873	/*	873	/*
874	* ethtool does not (or did not) set masks for flow parameters that are	874	* ethtool does not (or did not) set masks for flow parameters that are
875	* not specified, so if both value and mask are 0 then this must be	875	* not specified, so if both value and mask are 0 then this must be
876	* treated as equivalent to a mask with all bits set. Implement that	876	* treated as equivalent to a mask with all bits set. Implement that
877	* here rather than in drivers.	877	* here rather than in drivers.
878	*/	878	*/
879	static void rx_ntuple_fix_masks(struct ethtool_rx_ntuple_flow_spec *fs)	879	static void rx_ntuple_fix_masks(struct ethtool_rx_ntuple_flow_spec *fs)
880	{	880	{
881	struct ethtool_tcpip4_spec *entry = &fs->h_u.tcp_ip4_spec;	881	struct ethtool_tcpip4_spec *entry = &fs->h_u.tcp_ip4_spec;
882	struct ethtool_tcpip4_spec *mask = &fs->m_u.tcp_ip4_spec;	882	struct ethtool_tcpip4_spec *mask = &fs->m_u.tcp_ip4_spec;
883		883
884	if (fs->flow_type != TCP_V4_FLOW &&	884	if (fs->flow_type != TCP_V4_FLOW &&
885	fs->flow_type != UDP_V4_FLOW &&	885	fs->flow_type != UDP_V4_FLOW &&
886	fs->flow_type != SCTP_V4_FLOW)	886	fs->flow_type != SCTP_V4_FLOW)
887	return;	887	return;
888		888
889	if (!(entry->ip4src \| mask->ip4src))	889	if (!(entry->ip4src \| mask->ip4src))
890	mask->ip4src = htonl(0xffffffff);	890	mask->ip4src = htonl(0xffffffff);
891	if (!(entry->ip4dst \| mask->ip4dst))	891	if (!(entry->ip4dst \| mask->ip4dst))
892	mask->ip4dst = htonl(0xffffffff);	892	mask->ip4dst = htonl(0xffffffff);
893	if (!(entry->psrc \| mask->psrc))	893	if (!(entry->psrc \| mask->psrc))
894	mask->psrc = htons(0xffff);	894	mask->psrc = htons(0xffff);
895	if (!(entry->pdst \| mask->pdst))	895	if (!(entry->pdst \| mask->pdst))
896	mask->pdst = htons(0xffff);	896	mask->pdst = htons(0xffff);
897	if (!(entry->tos \| mask->tos))	897	if (!(entry->tos \| mask->tos))
898	mask->tos = 0xff;	898	mask->tos = 0xff;
899	if (!(fs->vlan_tag \| fs->vlan_tag_mask))	899	if (!(fs->vlan_tag \| fs->vlan_tag_mask))
900	fs->vlan_tag_mask = 0xffff;	900	fs->vlan_tag_mask = 0xffff;
901	if (!(fs->data \| fs->data_mask))	901	if (!(fs->data \| fs->data_mask))
902	fs->data_mask = 0xffffffffffffffffULL;	902	fs->data_mask = 0xffffffffffffffffULL;
903	}	903	}
904		904
905	static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,	905	static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
906	void __user *useraddr)	906	void __user *useraddr)
907	{	907	{
908	struct ethtool_rx_ntuple cmd;	908	struct ethtool_rx_ntuple cmd;
909	const struct ethtool_ops *ops = dev->ethtool_ops;	909	const struct ethtool_ops *ops = dev->ethtool_ops;
910	struct ethtool_rx_ntuple_flow_spec_container *fsc = NULL;	910	struct ethtool_rx_ntuple_flow_spec_container *fsc = NULL;
911	int ret;	911	int ret;
912		912
913	if (!ops->set_rx_ntuple)	913	if (!ops->set_rx_ntuple)
914	return -EOPNOTSUPP;	914	return -EOPNOTSUPP;
915		915
916	if (!(dev->features & NETIF_F_NTUPLE))	916	if (!(dev->features & NETIF_F_NTUPLE))
917	return -EINVAL;	917	return -EINVAL;
918		918
919	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))	919	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
920	return -EFAULT;	920	return -EFAULT;
921		921
922	rx_ntuple_fix_masks(&cmd.fs);	922	rx_ntuple_fix_masks(&cmd.fs);
923		923
924	/*	924	/*
925	* Cache filter in dev struct for GET operation only if	925	* Cache filter in dev struct for GET operation only if
926	* the underlying driver doesn't have its own GET operation, and	926	* the underlying driver doesn't have its own GET operation, and
927	* only if the filter was added successfully. First make sure we	927	* only if the filter was added successfully. First make sure we
928	* can allocate the filter, then continue if successful.	928	* can allocate the filter, then continue if successful.
929	*/	929	*/
930	if (!ops->get_rx_ntuple) {	930	if (!ops->get_rx_ntuple) {
931	fsc = kmalloc(sizeof(*fsc), GFP_ATOMIC);	931	fsc = kmalloc(sizeof(*fsc), GFP_ATOMIC);
932	if (!fsc)	932	if (!fsc)
933	return -ENOMEM;	933	return -ENOMEM;
934	}	934	}
935		935
936	ret = ops->set_rx_ntuple(dev, &cmd);	936	ret = ops->set_rx_ntuple(dev, &cmd);
937	if (ret) {	937	if (ret) {
938	kfree(fsc);	938	kfree(fsc);
939	return ret;	939	return ret;
940	}	940	}
941		941
942	if (!ops->get_rx_ntuple)	942	if (!ops->get_rx_ntuple)
943	__rx_ntuple_filter_add(&dev->ethtool_ntuple_list, &cmd.fs, fsc);	943	__rx_ntuple_filter_add(&dev->ethtool_ntuple_list, &cmd.fs, fsc);
944		944
945	return ret;	945	return ret;
946	}	946	}
947		947
948	static int ethtool_get_rx_ntuple(struct net_device dev, void __user useraddr)	948	static int ethtool_get_rx_ntuple(struct net_device dev, void __user useraddr)
949	{	949	{
950	struct ethtool_gstrings gstrings;	950	struct ethtool_gstrings gstrings;
951	const struct ethtool_ops *ops = dev->ethtool_ops;	951	const struct ethtool_ops *ops = dev->ethtool_ops;
952	struct ethtool_rx_ntuple_flow_spec_container *fsc;	952	struct ethtool_rx_ntuple_flow_spec_container *fsc;
953	u8 *data;	953	u8 *data;
954	char *p;	954	char *p;
955	int ret, i, num_strings = 0;	955	int ret, i, num_strings = 0;
956		956
957	if (!ops->get_sset_count)	957	if (!ops->get_sset_count)
958	return -EOPNOTSUPP;	958	return -EOPNOTSUPP;
959		959
960	if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))	960	if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
961	return -EFAULT;	961	return -EFAULT;
962		962
963	ret = ops->get_sset_count(dev, gstrings.string_set);	963	ret = ops->get_sset_count(dev, gstrings.string_set);
964	if (ret < 0)	964	if (ret < 0)
965	return ret;	965	return ret;
966		966
967	gstrings.len = ret;	967	gstrings.len = ret;
968		968
969	data = kzalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);	969	data = kzalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
970	if (!data)	970	if (!data)
971	return -ENOMEM;	971	return -ENOMEM;
972		972
973	if (ops->get_rx_ntuple) {	973	if (ops->get_rx_ntuple) {
974	/* driver-specific filter grab */	974	/* driver-specific filter grab */
975	ret = ops->get_rx_ntuple(dev, gstrings.string_set, data);	975	ret = ops->get_rx_ntuple(dev, gstrings.string_set, data);
976	goto copy;	976	goto copy;
977	}	977	}
978		978
979	/* default ethtool filter grab */	979	/* default ethtool filter grab */
980	i = 0;	980	i = 0;
981	p = (char *)data;	981	p = (char *)data;
982	list_for_each_entry(fsc, &dev->ethtool_ntuple_list.list, list) {	982	list_for_each_entry(fsc, &dev->ethtool_ntuple_list.list, list) {
983	sprintf(p, "Filter %d:\n", i);	983	sprintf(p, "Filter %d:\n", i);
984	p += ETH_GSTRING_LEN;	984	p += ETH_GSTRING_LEN;
985	num_strings++;	985	num_strings++;
986		986
987	switch (fsc->fs.flow_type) {	987	switch (fsc->fs.flow_type) {
988	case TCP_V4_FLOW:	988	case TCP_V4_FLOW:
989	sprintf(p, "\tFlow Type: TCP\n");	989	sprintf(p, "\tFlow Type: TCP\n");
990	p += ETH_GSTRING_LEN;	990	p += ETH_GSTRING_LEN;
991	num_strings++;	991	num_strings++;
992	break;	992	break;
993	case UDP_V4_FLOW:	993	case UDP_V4_FLOW:
994	sprintf(p, "\tFlow Type: UDP\n");	994	sprintf(p, "\tFlow Type: UDP\n");
995	p += ETH_GSTRING_LEN;	995	p += ETH_GSTRING_LEN;
996	num_strings++;	996	num_strings++;
997	break;	997	break;
998	case SCTP_V4_FLOW:	998	case SCTP_V4_FLOW:
999	sprintf(p, "\tFlow Type: SCTP\n");	999	sprintf(p, "\tFlow Type: SCTP\n");
1000	p += ETH_GSTRING_LEN;	1000	p += ETH_GSTRING_LEN;
1001	num_strings++;	1001	num_strings++;
1002	break;	1002	break;
1003	case AH_ESP_V4_FLOW:	1003	case AH_ESP_V4_FLOW:
1004	sprintf(p, "\tFlow Type: AH ESP\n");	1004	sprintf(p, "\tFlow Type: AH ESP\n");
1005	p += ETH_GSTRING_LEN;	1005	p += ETH_GSTRING_LEN;
1006	num_strings++;	1006	num_strings++;
1007	break;	1007	break;
1008	case ESP_V4_FLOW:	1008	case ESP_V4_FLOW:
1009	sprintf(p, "\tFlow Type: ESP\n");	1009	sprintf(p, "\tFlow Type: ESP\n");
1010	p += ETH_GSTRING_LEN;	1010	p += ETH_GSTRING_LEN;
1011	num_strings++;	1011	num_strings++;
1012	break;	1012	break;
1013	case IP_USER_FLOW:	1013	case IP_USER_FLOW:
1014	sprintf(p, "\tFlow Type: Raw IP\n");	1014	sprintf(p, "\tFlow Type: Raw IP\n");
1015	p += ETH_GSTRING_LEN;	1015	p += ETH_GSTRING_LEN;
1016	num_strings++;	1016	num_strings++;
1017	break;	1017	break;
1018	case IPV4_FLOW:	1018	case IPV4_FLOW:
1019	sprintf(p, "\tFlow Type: IPv4\n");	1019	sprintf(p, "\tFlow Type: IPv4\n");
1020	p += ETH_GSTRING_LEN;	1020	p += ETH_GSTRING_LEN;
1021	num_strings++;	1021	num_strings++;
1022	break;	1022	break;
1023	default:	1023	default:
1024	sprintf(p, "\tFlow Type: Unknown\n");	1024	sprintf(p, "\tFlow Type: Unknown\n");
1025	p += ETH_GSTRING_LEN;	1025	p += ETH_GSTRING_LEN;
1026	num_strings++;	1026	num_strings++;
1027	goto unknown_filter;	1027	goto unknown_filter;
1028	}	1028	}
1029		1029
1030	/* now the rest of the filters */	1030	/* now the rest of the filters */
1031	switch (fsc->fs.flow_type) {	1031	switch (fsc->fs.flow_type) {
1032	case TCP_V4_FLOW:	1032	case TCP_V4_FLOW:
1033	case UDP_V4_FLOW:	1033	case UDP_V4_FLOW:
1034	case SCTP_V4_FLOW:	1034	case SCTP_V4_FLOW:
1035	sprintf(p, "\tSrc IP addr: 0x%x\n",	1035	sprintf(p, "\tSrc IP addr: 0x%x\n",
1036	fsc->fs.h_u.tcp_ip4_spec.ip4src);	1036	fsc->fs.h_u.tcp_ip4_spec.ip4src);
1037	p += ETH_GSTRING_LEN;	1037	p += ETH_GSTRING_LEN;
1038	num_strings++;	1038	num_strings++;
1039	sprintf(p, "\tSrc IP mask: 0x%x\n",	1039	sprintf(p, "\tSrc IP mask: 0x%x\n",
1040	fsc->fs.m_u.tcp_ip4_spec.ip4src);	1040	fsc->fs.m_u.tcp_ip4_spec.ip4src);
1041	p += ETH_GSTRING_LEN;	1041	p += ETH_GSTRING_LEN;
1042	num_strings++;	1042	num_strings++;
1043	sprintf(p, "\tDest IP addr: 0x%x\n",	1043	sprintf(p, "\tDest IP addr: 0x%x\n",
1044	fsc->fs.h_u.tcp_ip4_spec.ip4dst);	1044	fsc->fs.h_u.tcp_ip4_spec.ip4dst);
1045	p += ETH_GSTRING_LEN;	1045	p += ETH_GSTRING_LEN;
1046	num_strings++;	1046	num_strings++;
1047	sprintf(p, "\tDest IP mask: 0x%x\n",	1047	sprintf(p, "\tDest IP mask: 0x%x\n",
1048	fsc->fs.m_u.tcp_ip4_spec.ip4dst);	1048	fsc->fs.m_u.tcp_ip4_spec.ip4dst);
1049	p += ETH_GSTRING_LEN;	1049	p += ETH_GSTRING_LEN;
1050	num_strings++;	1050	num_strings++;
1051	sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",	1051	sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",
1052	fsc->fs.h_u.tcp_ip4_spec.psrc,	1052	fsc->fs.h_u.tcp_ip4_spec.psrc,
1053	fsc->fs.m_u.tcp_ip4_spec.psrc);	1053	fsc->fs.m_u.tcp_ip4_spec.psrc);
1054	p += ETH_GSTRING_LEN;	1054	p += ETH_GSTRING_LEN;
1055	num_strings++;	1055	num_strings++;
1056	sprintf(p, "\tDest Port: %d, mask: 0x%x\n",	1056	sprintf(p, "\tDest Port: %d, mask: 0x%x\n",
1057	fsc->fs.h_u.tcp_ip4_spec.pdst,	1057	fsc->fs.h_u.tcp_ip4_spec.pdst,
1058	fsc->fs.m_u.tcp_ip4_spec.pdst);	1058	fsc->fs.m_u.tcp_ip4_spec.pdst);
1059	p += ETH_GSTRING_LEN;	1059	p += ETH_GSTRING_LEN;
1060	num_strings++;	1060	num_strings++;
1061	sprintf(p, "\tTOS: %d, mask: 0x%x\n",	1061	sprintf(p, "\tTOS: %d, mask: 0x%x\n",
1062	fsc->fs.h_u.tcp_ip4_spec.tos,	1062	fsc->fs.h_u.tcp_ip4_spec.tos,
1063	fsc->fs.m_u.tcp_ip4_spec.tos);	1063	fsc->fs.m_u.tcp_ip4_spec.tos);
1064	p += ETH_GSTRING_LEN;	1064	p += ETH_GSTRING_LEN;
1065	num_strings++;	1065	num_strings++;
1066	break;	1066	break;
1067	case AH_ESP_V4_FLOW:	1067	case AH_ESP_V4_FLOW:
1068	case ESP_V4_FLOW:	1068	case ESP_V4_FLOW:
1069	sprintf(p, "\tSrc IP addr: 0x%x\n",	1069	sprintf(p, "\tSrc IP addr: 0x%x\n",
1070	fsc->fs.h_u.ah_ip4_spec.ip4src);	1070	fsc->fs.h_u.ah_ip4_spec.ip4src);
1071	p += ETH_GSTRING_LEN;	1071	p += ETH_GSTRING_LEN;
1072	num_strings++;	1072	num_strings++;
1073	sprintf(p, "\tSrc IP mask: 0x%x\n",	1073	sprintf(p, "\tSrc IP mask: 0x%x\n",
1074	fsc->fs.m_u.ah_ip4_spec.ip4src);	1074	fsc->fs.m_u.ah_ip4_spec.ip4src);
1075	p += ETH_GSTRING_LEN;	1075	p += ETH_GSTRING_LEN;
1076	num_strings++;	1076	num_strings++;
1077	sprintf(p, "\tDest IP addr: 0x%x\n",	1077	sprintf(p, "\tDest IP addr: 0x%x\n",
1078	fsc->fs.h_u.ah_ip4_spec.ip4dst);	1078	fsc->fs.h_u.ah_ip4_spec.ip4dst);
1079	p += ETH_GSTRING_LEN;	1079	p += ETH_GSTRING_LEN;
1080	num_strings++;	1080	num_strings++;
1081	sprintf(p, "\tDest IP mask: 0x%x\n",	1081	sprintf(p, "\tDest IP mask: 0x%x\n",
1082	fsc->fs.m_u.ah_ip4_spec.ip4dst);	1082	fsc->fs.m_u.ah_ip4_spec.ip4dst);
1083	p += ETH_GSTRING_LEN;	1083	p += ETH_GSTRING_LEN;
1084	num_strings++;	1084	num_strings++;
1085	sprintf(p, "\tSPI: %d, mask: 0x%x\n",	1085	sprintf(p, "\tSPI: %d, mask: 0x%x\n",
1086	fsc->fs.h_u.ah_ip4_spec.spi,	1086	fsc->fs.h_u.ah_ip4_spec.spi,
1087	fsc->fs.m_u.ah_ip4_spec.spi);	1087	fsc->fs.m_u.ah_ip4_spec.spi);
1088	p += ETH_GSTRING_LEN;	1088	p += ETH_GSTRING_LEN;
1089	num_strings++;	1089	num_strings++;
1090	sprintf(p, "\tTOS: %d, mask: 0x%x\n",	1090	sprintf(p, "\tTOS: %d, mask: 0x%x\n",
1091	fsc->fs.h_u.ah_ip4_spec.tos,	1091	fsc->fs.h_u.ah_ip4_spec.tos,
1092	fsc->fs.m_u.ah_ip4_spec.tos);	1092	fsc->fs.m_u.ah_ip4_spec.tos);
1093	p += ETH_GSTRING_LEN;	1093	p += ETH_GSTRING_LEN;
1094	num_strings++;	1094	num_strings++;
1095	break;	1095	break;
1096	case IP_USER_FLOW:	1096	case IP_USER_FLOW:
1097	sprintf(p, "\tSrc IP addr: 0x%x\n",	1097	sprintf(p, "\tSrc IP addr: 0x%x\n",
1098	fsc->fs.h_u.usr_ip4_spec.ip4src);	1098	fsc->fs.h_u.usr_ip4_spec.ip4src);
1099	p += ETH_GSTRING_LEN;	1099	p += ETH_GSTRING_LEN;
1100	num_strings++;	1100	num_strings++;
1101	sprintf(p, "\tSrc IP mask: 0x%x\n",	1101	sprintf(p, "\tSrc IP mask: 0x%x\n",
1102	fsc->fs.m_u.usr_ip4_spec.ip4src);	1102	fsc->fs.m_u.usr_ip4_spec.ip4src);
1103	p += ETH_GSTRING_LEN;	1103	p += ETH_GSTRING_LEN;
1104	num_strings++;	1104	num_strings++;
1105	sprintf(p, "\tDest IP addr: 0x%x\n",	1105	sprintf(p, "\tDest IP addr: 0x%x\n",
1106	fsc->fs.h_u.usr_ip4_spec.ip4dst);	1106	fsc->fs.h_u.usr_ip4_spec.ip4dst);
1107	p += ETH_GSTRING_LEN;	1107	p += ETH_GSTRING_LEN;
1108	num_strings++;	1108	num_strings++;
1109	sprintf(p, "\tDest IP mask: 0x%x\n",	1109	sprintf(p, "\tDest IP mask: 0x%x\n",
1110	fsc->fs.m_u.usr_ip4_spec.ip4dst);	1110	fsc->fs.m_u.usr_ip4_spec.ip4dst);
1111	p += ETH_GSTRING_LEN;	1111	p += ETH_GSTRING_LEN;
1112	num_strings++;	1112	num_strings++;
1113	break;	1113	break;
1114	case IPV4_FLOW:	1114	case IPV4_FLOW:
1115	sprintf(p, "\tSrc IP addr: 0x%x\n",	1115	sprintf(p, "\tSrc IP addr: 0x%x\n",
1116	fsc->fs.h_u.usr_ip4_spec.ip4src);	1116	fsc->fs.h_u.usr_ip4_spec.ip4src);
1117	p += ETH_GSTRING_LEN;	1117	p += ETH_GSTRING_LEN;
1118	num_strings++;	1118	num_strings++;
1119	sprintf(p, "\tSrc IP mask: 0x%x\n",	1119	sprintf(p, "\tSrc IP mask: 0x%x\n",
1120	fsc->fs.m_u.usr_ip4_spec.ip4src);	1120	fsc->fs.m_u.usr_ip4_spec.ip4src);
1121	p += ETH_GSTRING_LEN;	1121	p += ETH_GSTRING_LEN;
1122	num_strings++;	1122	num_strings++;
1123	sprintf(p, "\tDest IP addr: 0x%x\n",	1123	sprintf(p, "\tDest IP addr: 0x%x\n",
1124	fsc->fs.h_u.usr_ip4_spec.ip4dst);	1124	fsc->fs.h_u.usr_ip4_spec.ip4dst);
1125	p += ETH_GSTRING_LEN;	1125	p += ETH_GSTRING_LEN;
1126	num_strings++;	1126	num_strings++;
1127	sprintf(p, "\tDest IP mask: 0x%x\n",	1127	sprintf(p, "\tDest IP mask: 0x%x\n",
1128	fsc->fs.m_u.usr_ip4_spec.ip4dst);	1128	fsc->fs.m_u.usr_ip4_spec.ip4dst);
1129	p += ETH_GSTRING_LEN;	1129	p += ETH_GSTRING_LEN;
1130	num_strings++;	1130	num_strings++;
1131	sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",	1131	sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",
1132	fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,	1132	fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
1133	fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);	1133	fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
1134	p += ETH_GSTRING_LEN;	1134	p += ETH_GSTRING_LEN;
1135	num_strings++;	1135	num_strings++;
1136	sprintf(p, "\tTOS: %d, mask: 0x%x\n",	1136	sprintf(p, "\tTOS: %d, mask: 0x%x\n",
1137	fsc->fs.h_u.usr_ip4_spec.tos,	1137	fsc->fs.h_u.usr_ip4_spec.tos,
1138	fsc->fs.m_u.usr_ip4_spec.tos);	1138	fsc->fs.m_u.usr_ip4_spec.tos);
1139	p += ETH_GSTRING_LEN;	1139	p += ETH_GSTRING_LEN;
1140	num_strings++;	1140	num_strings++;
1141	sprintf(p, "\tIP Version: %d, mask: 0x%x\n",	1141	sprintf(p, "\tIP Version: %d, mask: 0x%x\n",
1142	fsc->fs.h_u.usr_ip4_spec.ip_ver,	1142	fsc->fs.h_u.usr_ip4_spec.ip_ver,
1143	fsc->fs.m_u.usr_ip4_spec.ip_ver);	1143	fsc->fs.m_u.usr_ip4_spec.ip_ver);
1144	p += ETH_GSTRING_LEN;	1144	p += ETH_GSTRING_LEN;
1145	num_strings++;	1145	num_strings++;
1146	sprintf(p, "\tProtocol: %d, mask: 0x%x\n",	1146	sprintf(p, "\tProtocol: %d, mask: 0x%x\n",
1147	fsc->fs.h_u.usr_ip4_spec.proto,	1147	fsc->fs.h_u.usr_ip4_spec.proto,
1148	fsc->fs.m_u.usr_ip4_spec.proto);	1148	fsc->fs.m_u.usr_ip4_spec.proto);
1149	p += ETH_GSTRING_LEN;	1149	p += ETH_GSTRING_LEN;
1150	num_strings++;	1150	num_strings++;
1151	break;	1151	break;
1152	}	1152	}
1153	sprintf(p, "\tVLAN: %d, mask: 0x%x\n",	1153	sprintf(p, "\tVLAN: %d, mask: 0x%x\n",
1154	fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);	1154	fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
1155	p += ETH_GSTRING_LEN;	1155	p += ETH_GSTRING_LEN;
1156	num_strings++;	1156	num_strings++;
1157	sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);	1157	sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);
1158	p += ETH_GSTRING_LEN;	1158	p += ETH_GSTRING_LEN;
1159	num_strings++;	1159	num_strings++;
1160	sprintf(p, "\tUser-defined mask: 0x%Lx\n", fsc->fs.data_mask);	1160	sprintf(p, "\tUser-defined mask: 0x%Lx\n", fsc->fs.data_mask);
1161	p += ETH_GSTRING_LEN;	1161	p += ETH_GSTRING_LEN;
1162	num_strings++;	1162	num_strings++;
1163	if (fsc->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)	1163	if (fsc->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)
1164	sprintf(p, "\tAction: Drop\n");	1164	sprintf(p, "\tAction: Drop\n");
1165	else	1165	else
1166	sprintf(p, "\tAction: Direct to queue %d\n",	1166	sprintf(p, "\tAction: Direct to queue %d\n",
1167	fsc->fs.action);	1167	fsc->fs.action);
1168	p += ETH_GSTRING_LEN;	1168	p += ETH_GSTRING_LEN;
1169	num_strings++;	1169	num_strings++;
1170	unknown_filter:	1170	unknown_filter:
1171	i++;	1171	i++;
1172	}	1172	}
1173	copy:	1173	copy:
1174	/* indicate to userspace how many strings we actually have */	1174	/* indicate to userspace how many strings we actually have */
1175	gstrings.len = num_strings;	1175	gstrings.len = num_strings;
1176	ret = -EFAULT;	1176	ret = -EFAULT;
1177	if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))	1177	if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1178	goto out;	1178	goto out;
1179	useraddr += sizeof(gstrings);	1179	useraddr += sizeof(gstrings);
1180	if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))	1180	if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1181	goto out;	1181	goto out;
1182	ret = 0;	1182	ret = 0;
1183		1183
1184	out:	1184	out:
1185	kfree(data);	1185	kfree(data);
1186	return ret;	1186	return ret;
1187	}	1187	}
1188		1188
1189	static int ethtool_get_regs(struct net_device dev, char __user useraddr)	1189	static int ethtool_get_regs(struct net_device dev, char __user useraddr)
1190	{	1190	{
1191	struct ethtool_regs regs;	1191	struct ethtool_regs regs;
1192	const struct ethtool_ops *ops = dev->ethtool_ops;	1192	const struct ethtool_ops *ops = dev->ethtool_ops;
1193	void *regbuf;	1193	void *regbuf;
1194	int reglen, ret;	1194	int reglen, ret;
1195		1195
1196	if (!ops->get_regs \|\| !ops->get_regs_len)	1196	if (!ops->get_regs \|\| !ops->get_regs_len)
1197	return -EOPNOTSUPP;	1197	return -EOPNOTSUPP;
1198		1198
1199	if (copy_from_user(&regs, useraddr, sizeof(regs)))	1199	if (copy_from_user(&regs, useraddr, sizeof(regs)))
1200	return -EFAULT;	1200	return -EFAULT;
1201		1201
1202	reglen = ops->get_regs_len(dev);	1202	reglen = ops->get_regs_len(dev);
1203	if (regs.len > reglen)	1203	if (regs.len > reglen)
1204	regs.len = reglen;	1204	regs.len = reglen;
1205		1205
1206	regbuf = vzalloc(reglen);	1206	regbuf = vzalloc(reglen);
1207	if (!regbuf)	1207	if (!regbuf)
1208	return -ENOMEM;	1208	return -ENOMEM;
1209		1209
1210	ops->get_regs(dev, &regs, regbuf);	1210	ops->get_regs(dev, &regs, regbuf);
1211		1211
1212	ret = -EFAULT;	1212	ret = -EFAULT;
1213	if (copy_to_user(useraddr, &regs, sizeof(regs)))	1213	if (copy_to_user(useraddr, &regs, sizeof(regs)))
1214	goto out;	1214	goto out;
1215	useraddr += offsetof(struct ethtool_regs, data);	1215	useraddr += offsetof(struct ethtool_regs, data);
1216	if (copy_to_user(useraddr, regbuf, regs.len))	1216	if (copy_to_user(useraddr, regbuf, regs.len))
1217	goto out;	1217	goto out;
1218	ret = 0;	1218	ret = 0;
1219		1219
1220	out:	1220	out:
1221	vfree(regbuf);	1221	vfree(regbuf);
1222	return ret;	1222	return ret;
1223	}	1223	}
1224		1224
1225	static int ethtool_reset(struct net_device dev, char __user useraddr)	1225	static int ethtool_reset(struct net_device dev, char __user useraddr)
1226	{	1226	{
1227	struct ethtool_value reset;	1227	struct ethtool_value reset;
1228	int ret;	1228	int ret;
1229		1229
1230	if (!dev->ethtool_ops->reset)	1230	if (!dev->ethtool_ops->reset)
1231	return -EOPNOTSUPP;	1231	return -EOPNOTSUPP;
1232		1232
1233	if (copy_from_user(&reset, useraddr, sizeof(reset)))	1233	if (copy_from_user(&reset, useraddr, sizeof(reset)))
1234	return -EFAULT;	1234	return -EFAULT;
1235		1235
1236	ret = dev->ethtool_ops->reset(dev, &reset.data);	1236	ret = dev->ethtool_ops->reset(dev, &reset.data);
1237	if (ret)	1237	if (ret)
1238	return ret;	1238	return ret;
1239		1239
1240	if (copy_to_user(useraddr, &reset, sizeof(reset)))	1240	if (copy_to_user(useraddr, &reset, sizeof(reset)))
1241	return -EFAULT;	1241	return -EFAULT;
1242	return 0;	1242	return 0;
1243	}	1243	}
1244		1244
1245	static int ethtool_get_wol(struct net_device dev, char __user useraddr)	1245	static int ethtool_get_wol(struct net_device dev, char __user useraddr)
1246	{	1246	{
1247	struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };	1247	struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1248		1248
1249	if (!dev->ethtool_ops->get_wol)	1249	if (!dev->ethtool_ops->get_wol)
1250	return -EOPNOTSUPP;	1250	return -EOPNOTSUPP;
1251		1251
1252	dev->ethtool_ops->get_wol(dev, &wol);	1252	dev->ethtool_ops->get_wol(dev, &wol);
1253		1253
1254	if (copy_to_user(useraddr, &wol, sizeof(wol)))	1254	if (copy_to_user(useraddr, &wol, sizeof(wol)))
1255	return -EFAULT;	1255	return -EFAULT;
1256	return 0;	1256	return 0;
1257	}	1257	}
1258		1258
1259	static int ethtool_set_wol(struct net_device dev, char __user useraddr)	1259	static int ethtool_set_wol(struct net_device dev, char __user useraddr)
1260	{	1260	{
1261	struct ethtool_wolinfo wol;	1261	struct ethtool_wolinfo wol;
1262		1262
1263	if (!dev->ethtool_ops->set_wol)	1263	if (!dev->ethtool_ops->set_wol)
1264	return -EOPNOTSUPP;	1264	return -EOPNOTSUPP;
1265		1265
1266	if (copy_from_user(&wol, useraddr, sizeof(wol)))	1266	if (copy_from_user(&wol, useraddr, sizeof(wol)))
1267	return -EFAULT;	1267	return -EFAULT;
1268		1268
1269	return dev->ethtool_ops->set_wol(dev, &wol);	1269	return dev->ethtool_ops->set_wol(dev, &wol);
1270	}	1270	}
1271		1271
1272	static int ethtool_nway_reset(struct net_device *dev)	1272	static int ethtool_nway_reset(struct net_device *dev)
1273	{	1273	{
1274	if (!dev->ethtool_ops->nway_reset)	1274	if (!dev->ethtool_ops->nway_reset)
1275	return -EOPNOTSUPP;	1275	return -EOPNOTSUPP;
1276		1276
1277	return dev->ethtool_ops->nway_reset(dev);	1277	return dev->ethtool_ops->nway_reset(dev);
1278	}	1278	}
1279		1279
1280	static int ethtool_get_link(struct net_device dev, char __user useraddr)	1280	static int ethtool_get_link(struct net_device dev, char __user useraddr)
1281	{	1281	{
1282	struct ethtool_value edata = { .cmd = ETHTOOL_GLINK };	1282	struct ethtool_value edata = { .cmd = ETHTOOL_GLINK };
1283		1283
1284	if (!dev->ethtool_ops->get_link)	1284	if (!dev->ethtool_ops->get_link)
1285	return -EOPNOTSUPP;	1285	return -EOPNOTSUPP;
1286		1286
1287	edata.data = netif_running(dev) && dev->ethtool_ops->get_link(dev);	1287	edata.data = netif_running(dev) && dev->ethtool_ops->get_link(dev);
1288		1288
1289	if (copy_to_user(useraddr, &edata, sizeof(edata)))	1289	if (copy_to_user(useraddr, &edata, sizeof(edata)))
1290	return -EFAULT;	1290	return -EFAULT;
1291	return 0;	1291	return 0;
1292	}	1292	}
1293		1293
1294	static int ethtool_get_eeprom(struct net_device dev, void __user useraddr)	1294	static int ethtool_get_eeprom(struct net_device dev, void __user useraddr)
1295	{	1295	{
1296	struct ethtool_eeprom eeprom;	1296	struct ethtool_eeprom eeprom;
1297	const struct ethtool_ops *ops = dev->ethtool_ops;	1297	const struct ethtool_ops *ops = dev->ethtool_ops;
1298	void __user *userbuf = useraddr + sizeof(eeprom);	1298	void __user *userbuf = useraddr + sizeof(eeprom);
1299	u32 bytes_remaining;	1299	u32 bytes_remaining;
1300	u8 *data;	1300	u8 *data;
1301	int ret = 0;	1301	int ret = 0;
1302		1302
1303	if (!ops->get_eeprom \|\| !ops->get_eeprom_len)	1303	if (!ops->get_eeprom \|\| !ops->get_eeprom_len)
1304	return -EOPNOTSUPP;	1304	return -EOPNOTSUPP;
1305		1305
1306	if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))	1306	if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1307	return -EFAULT;	1307	return -EFAULT;
1308		1308
1309	/* Check for wrap and zero */	1309	/* Check for wrap and zero */
1310	if (eeprom.offset + eeprom.len <= eeprom.offset)	1310	if (eeprom.offset + eeprom.len <= eeprom.offset)
1311	return -EINVAL;	1311	return -EINVAL;
1312		1312
1313	/* Check for exceeding total eeprom len */	1313	/* Check for exceeding total eeprom len */
1314	if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))	1314	if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1315	return -EINVAL;	1315	return -EINVAL;
1316		1316
1317	data = kmalloc(PAGE_SIZE, GFP_USER);	1317	data = kmalloc(PAGE_SIZE, GFP_USER);
1318	if (!data)	1318	if (!data)
1319	return -ENOMEM;	1319	return -ENOMEM;
1320		1320
1321	bytes_remaining = eeprom.len;	1321	bytes_remaining = eeprom.len;
1322	while (bytes_remaining > 0) {	1322	while (bytes_remaining > 0) {
1323	eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);	1323	eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
1324		1324
1325	ret = ops->get_eeprom(dev, &eeprom, data);	1325	ret = ops->get_eeprom(dev, &eeprom, data);
1326	if (ret)	1326	if (ret)
1327	break;	1327	break;
1328	if (copy_to_user(userbuf, data, eeprom.len)) {	1328	if (copy_to_user(userbuf, data, eeprom.len)) {
1329	ret = -EFAULT;	1329	ret = -EFAULT;
1330	break;	1330	break;
1331	}	1331	}
1332	userbuf += eeprom.len;	1332	userbuf += eeprom.len;
1333	eeprom.offset += eeprom.len;	1333	eeprom.offset += eeprom.len;
1334	bytes_remaining -= eeprom.len;	1334	bytes_remaining -= eeprom.len;
1335	}	1335	}
1336		1336
1337	eeprom.len = userbuf - (useraddr + sizeof(eeprom));	1337	eeprom.len = userbuf - (useraddr + sizeof(eeprom));
1338	eeprom.offset -= eeprom.len;	1338	eeprom.offset -= eeprom.len;
1339	if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))	1339	if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
1340	ret = -EFAULT;	1340	ret = -EFAULT;
1341		1341
1342	kfree(data);	1342	kfree(data);
1343	return ret;	1343	return ret;
1344	}	1344	}
1345		1345
1346	static int ethtool_set_eeprom(struct net_device dev, void __user useraddr)	1346	static int ethtool_set_eeprom(struct net_device dev, void __user useraddr)
1347	{	1347	{
1348	struct ethtool_eeprom eeprom;	1348	struct ethtool_eeprom eeprom;
1349	const struct ethtool_ops *ops = dev->ethtool_ops;	1349	const struct ethtool_ops *ops = dev->ethtool_ops;
1350	void __user *userbuf = useraddr + sizeof(eeprom);	1350	void __user *userbuf = useraddr + sizeof(eeprom);
1351	u32 bytes_remaining;	1351	u32 bytes_remaining;
1352	u8 *data;	1352	u8 *data;
1353	int ret = 0;	1353	int ret = 0;
1354		1354
1355	if (!ops->set_eeprom \|\| !ops->get_eeprom_len)	1355	if (!ops->set_eeprom \|\| !ops->get_eeprom_len)
1356	return -EOPNOTSUPP;	1356	return -EOPNOTSUPP;
1357		1357
1358	if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))	1358	if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1359	return -EFAULT;	1359	return -EFAULT;
1360		1360
1361	/* Check for wrap and zero */	1361	/* Check for wrap and zero */
1362	if (eeprom.offset + eeprom.len <= eeprom.offset)	1362	if (eeprom.offset + eeprom.len <= eeprom.offset)
1363	return -EINVAL;	1363	return -EINVAL;
1364		1364
1365	/* Check for exceeding total eeprom len */	1365	/* Check for exceeding total eeprom len */
1366	if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))	1366	if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1367	return -EINVAL;	1367	return -EINVAL;
1368		1368
1369	data = kmalloc(PAGE_SIZE, GFP_USER);	1369	data = kmalloc(PAGE_SIZE, GFP_USER);
1370	if (!data)	1370	if (!data)
1371	return -ENOMEM;	1371	return -ENOMEM;
1372		1372
1373	bytes_remaining = eeprom.len;	1373	bytes_remaining = eeprom.len;
1374	while (bytes_remaining > 0) {	1374	while (bytes_remaining > 0) {
1375	eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);	1375	eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
1376		1376
1377	if (copy_from_user(data, userbuf, eeprom.len)) {	1377	if (copy_from_user(data, userbuf, eeprom.len)) {
1378	ret = -EFAULT;	1378	ret = -EFAULT;
1379	break;	1379	break;
1380	}	1380	}
1381	ret = ops->set_eeprom(dev, &eeprom, data);	1381	ret = ops->set_eeprom(dev, &eeprom, data);
1382	if (ret)	1382	if (ret)
1383	break;	1383	break;
1384	userbuf += eeprom.len;	1384	userbuf += eeprom.len;
1385	eeprom.offset += eeprom.len;	1385	eeprom.offset += eeprom.len;
1386	bytes_remaining -= eeprom.len;	1386	bytes_remaining -= eeprom.len;
1387	}	1387	}
1388		1388
1389	kfree(data);	1389	kfree(data);
1390	return ret;	1390	return ret;
1391	}	1391	}
1392		1392
1393	static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,	1393	static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
1394	void __user *useraddr)	1394	void __user *useraddr)
1395	{	1395	{
1396	struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };	1396	struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
1397		1397
1398	if (!dev->ethtool_ops->get_coalesce)	1398	if (!dev->ethtool_ops->get_coalesce)
1399	return -EOPNOTSUPP;	1399	return -EOPNOTSUPP;
1400		1400
1401	dev->ethtool_ops->get_coalesce(dev, &coalesce);	1401	dev->ethtool_ops->get_coalesce(dev, &coalesce);
1402		1402
1403	if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))	1403	if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
1404	return -EFAULT;	1404	return -EFAULT;
1405	return 0;	1405	return 0;
1406	}	1406	}
1407		1407
1408	static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,	1408	static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
1409	void __user *useraddr)	1409	void __user *useraddr)
1410	{	1410	{
1411	struct ethtool_coalesce coalesce;	1411	struct ethtool_coalesce coalesce;
1412		1412
1413	if (!dev->ethtool_ops->set_coalesce)	1413	if (!dev->ethtool_ops->set_coalesce)
1414	return -EOPNOTSUPP;	1414	return -EOPNOTSUPP;
1415		1415
1416	if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))	1416	if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
1417	return -EFAULT;	1417	return -EFAULT;
1418		1418
1419	return dev->ethtool_ops->set_coalesce(dev, &coalesce);	1419	return dev->ethtool_ops->set_coalesce(dev, &coalesce);
1420	}	1420	}
1421		1421
1422	static int ethtool_get_ringparam(struct net_device dev, void __user useraddr)	1422	static int ethtool_get_ringparam(struct net_device dev, void __user useraddr)
1423	{	1423	{
1424	struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };	1424	struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
1425		1425
1426	if (!dev->ethtool_ops->get_ringparam)	1426	if (!dev->ethtool_ops->get_ringparam)
1427	return -EOPNOTSUPP;	1427	return -EOPNOTSUPP;
1428		1428
1429	dev->ethtool_ops->get_ringparam(dev, &ringparam);	1429	dev->ethtool_ops->get_ringparam(dev, &ringparam);
1430		1430
1431	if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))	1431	if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
1432	return -EFAULT;	1432	return -EFAULT;
1433	return 0;	1433	return 0;
1434	}	1434	}
1435		1435
1436	static int ethtool_set_ringparam(struct net_device dev, void __user useraddr)	1436	static int ethtool_set_ringparam(struct net_device dev, void __user useraddr)
1437	{	1437	{
1438	struct ethtool_ringparam ringparam;	1438	struct ethtool_ringparam ringparam;
1439		1439
1440	if (!dev->ethtool_ops->set_ringparam)	1440	if (!dev->ethtool_ops->set_ringparam)
1441	return -EOPNOTSUPP;	1441	return -EOPNOTSUPP;
1442		1442
1443	if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))	1443	if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
1444	return -EFAULT;	1444	return -EFAULT;
1445		1445
1446	return dev->ethtool_ops->set_ringparam(dev, &ringparam);	1446	return dev->ethtool_ops->set_ringparam(dev, &ringparam);
1447	}	1447	}
1448		1448
1449	static noinline_for_stack int ethtool_get_channels(struct net_device *dev,	1449	static noinline_for_stack int ethtool_get_channels(struct net_device *dev,
1450	void __user *useraddr)	1450	void __user *useraddr)
1451	{	1451	{
1452	struct ethtool_channels channels = { .cmd = ETHTOOL_GCHANNELS };	1452	struct ethtool_channels channels = { .cmd = ETHTOOL_GCHANNELS };
1453		1453
1454	if (!dev->ethtool_ops->get_channels)	1454	if (!dev->ethtool_ops->get_channels)
1455	return -EOPNOTSUPP;	1455	return -EOPNOTSUPP;
1456		1456
1457	dev->ethtool_ops->get_channels(dev, &channels);	1457	dev->ethtool_ops->get_channels(dev, &channels);
1458		1458
1459	if (copy_to_user(useraddr, &channels, sizeof(channels)))	1459	if (copy_to_user(useraddr, &channels, sizeof(channels)))
1460	return -EFAULT;	1460	return -EFAULT;
1461	return 0;	1461	return 0;
1462	}	1462	}
1463		1463
1464	static noinline_for_stack int ethtool_set_channels(struct net_device *dev,	1464	static noinline_for_stack int ethtool_set_channels(struct net_device *dev,
1465	void __user *useraddr)	1465	void __user *useraddr)
1466	{	1466	{
1467	struct ethtool_channels channels;	1467	struct ethtool_channels channels;
1468		1468
1469	if (!dev->ethtool_ops->set_channels)	1469	if (!dev->ethtool_ops->set_channels)
1470	return -EOPNOTSUPP;	1470	return -EOPNOTSUPP;
1471		1471
1472	if (copy_from_user(&channels, useraddr, sizeof(channels)))	1472	if (copy_from_user(&channels, useraddr, sizeof(channels)))
1473	return -EFAULT;	1473	return -EFAULT;
1474		1474
1475	return dev->ethtool_ops->set_channels(dev, &channels);	1475	return dev->ethtool_ops->set_channels(dev, &channels);
1476	}	1476	}
1477		1477
1478	static int ethtool_get_pauseparam(struct net_device dev, void __user useraddr)	1478	static int ethtool_get_pauseparam(struct net_device dev, void __user useraddr)
1479	{	1479	{
1480	struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };	1480	struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
1481		1481
1482	if (!dev->ethtool_ops->get_pauseparam)	1482	if (!dev->ethtool_ops->get_pauseparam)
1483	return -EOPNOTSUPP;	1483	return -EOPNOTSUPP;
1484		1484
1485	dev->ethtool_ops->get_pauseparam(dev, &pauseparam);	1485	dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
1486		1486
1487	if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))	1487	if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
1488	return -EFAULT;	1488	return -EFAULT;
1489	return 0;	1489	return 0;
1490	}	1490	}
1491		1491
1492	static int ethtool_set_pauseparam(struct net_device dev, void __user useraddr)	1492	static int ethtool_set_pauseparam(struct net_device dev, void __user useraddr)
1493	{	1493	{
1494	struct ethtool_pauseparam pauseparam;	1494	struct ethtool_pauseparam pauseparam;
1495		1495
1496	if (!dev->ethtool_ops->set_pauseparam)	1496	if (!dev->ethtool_ops->set_pauseparam)
1497	return -EOPNOTSUPP;	1497	return -EOPNOTSUPP;
1498		1498
1499	if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))	1499	if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
1500	return -EFAULT;	1500	return -EFAULT;
1501		1501
1502	return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);	1502	return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
1503	}	1503	}
1504		1504
1505	static int __ethtool_set_sg(struct net_device *dev, u32 data)	1505	static int __ethtool_set_sg(struct net_device *dev, u32 data)
1506	{	1506	{
1507	int err;	1507	int err;
1508		1508
1509	if (!dev->ethtool_ops->set_sg)	1509	if (!dev->ethtool_ops->set_sg)
1510	return -EOPNOTSUPP;	1510	return -EOPNOTSUPP;
1511		1511
1512	if (data && !(dev->features & NETIF_F_ALL_CSUM))	1512	if (data && !(dev->features & NETIF_F_ALL_CSUM))
1513	return -EINVAL;	1513	return -EINVAL;
1514		1514
1515	if (!data && dev->ethtool_ops->set_tso) {	1515	if (!data && dev->ethtool_ops->set_tso) {
1516	err = dev->ethtool_ops->set_tso(dev, 0);	1516	err = dev->ethtool_ops->set_tso(dev, 0);
1517	if (err)	1517	if (err)
1518	return err;	1518	return err;
1519	}	1519	}
1520		1520
1521	if (!data && dev->ethtool_ops->set_ufo) {	1521	if (!data && dev->ethtool_ops->set_ufo) {
1522	err = dev->ethtool_ops->set_ufo(dev, 0);	1522	err = dev->ethtool_ops->set_ufo(dev, 0);
1523	if (err)	1523	if (err)
1524	return err;	1524	return err;
1525	}	1525	}
1526	return dev->ethtool_ops->set_sg(dev, data);	1526	return dev->ethtool_ops->set_sg(dev, data);
1527	}	1527	}
1528		1528
1529	static int __ethtool_set_tx_csum(struct net_device *dev, u32 data)	1529	static int __ethtool_set_tx_csum(struct net_device *dev, u32 data)
1530	{	1530	{
1531	int err;	1531	int err;
1532		1532
1533	if (!dev->ethtool_ops->set_tx_csum)	1533	if (!dev->ethtool_ops->set_tx_csum)
1534	return -EOPNOTSUPP;	1534	return -EOPNOTSUPP;
1535		1535
1536	if (!data && dev->ethtool_ops->set_sg) {	1536	if (!data && dev->ethtool_ops->set_sg) {
1537	err = __ethtool_set_sg(dev, 0);	1537	err = __ethtool_set_sg(dev, 0);
1538	if (err)	1538	if (err)
1539	return err;	1539	return err;
1540	}	1540	}
1541		1541
1542	return dev->ethtool_ops->set_tx_csum(dev, data);	1542	return dev->ethtool_ops->set_tx_csum(dev, data);
1543	}	1543	}
1544		1544
1545	static int __ethtool_set_rx_csum(struct net_device *dev, u32 data)	1545	static int __ethtool_set_rx_csum(struct net_device *dev, u32 data)
1546	{	1546	{
1547	if (!dev->ethtool_ops->set_rx_csum)	1547	if (!dev->ethtool_ops->set_rx_csum)
1548	return -EOPNOTSUPP;	1548	return -EOPNOTSUPP;
1549		1549
1550	if (!data)	1550	if (!data)
1551	dev->features &= ~NETIF_F_GRO;	1551	dev->features &= ~NETIF_F_GRO;
1552		1552
1553	return dev->ethtool_ops->set_rx_csum(dev, data);	1553	return dev->ethtool_ops->set_rx_csum(dev, data);
1554	}	1554	}
1555		1555
1556	static int __ethtool_set_tso(struct net_device *dev, u32 data)	1556	static int __ethtool_set_tso(struct net_device *dev, u32 data)
1557	{	1557	{
1558	if (!dev->ethtool_ops->set_tso)	1558	if (!dev->ethtool_ops->set_tso)
1559	return -EOPNOTSUPP;	1559	return -EOPNOTSUPP;
1560		1560
1561	if (data && !(dev->features & NETIF_F_SG))	1561	if (data && !(dev->features & NETIF_F_SG))
1562	return -EINVAL;	1562	return -EINVAL;
1563		1563
1564	return dev->ethtool_ops->set_tso(dev, data);	1564	return dev->ethtool_ops->set_tso(dev, data);
1565	}	1565	}
1566		1566
1567	static int __ethtool_set_ufo(struct net_device *dev, u32 data)	1567	static int __ethtool_set_ufo(struct net_device *dev, u32 data)
1568	{	1568	{
1569	if (!dev->ethtool_ops->set_ufo)	1569	if (!dev->ethtool_ops->set_ufo)
1570	return -EOPNOTSUPP;	1570	return -EOPNOTSUPP;
1571	if (data && !(dev->features & NETIF_F_SG))	1571	if (data && !(dev->features & NETIF_F_SG))
1572	return -EINVAL;	1572	return -EINVAL;
1573	if (data && !((dev->features & NETIF_F_GEN_CSUM) \|\|	1573	if (data && !((dev->features & NETIF_F_GEN_CSUM) \|\|
1574	(dev->features & (NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM))	1574	(dev->features & (NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM))
1575	== (NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM)))	1575	== (NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM)))
1576	return -EINVAL;	1576	return -EINVAL;
1577	return dev->ethtool_ops->set_ufo(dev, data);	1577	return dev->ethtool_ops->set_ufo(dev, data);
1578	}	1578	}
1579		1579
1580	static int ethtool_self_test(struct net_device dev, char __user useraddr)	1580	static int ethtool_self_test(struct net_device dev, char __user useraddr)
1581	{	1581	{
1582	struct ethtool_test test;	1582	struct ethtool_test test;
1583	const struct ethtool_ops *ops = dev->ethtool_ops;	1583	const struct ethtool_ops *ops = dev->ethtool_ops;
1584	u64 *data;	1584	u64 *data;
1585	int ret, test_len;	1585	int ret, test_len;
1586		1586
1587	if (!ops->self_test \|\| !ops->get_sset_count)	1587	if (!ops->self_test \|\| !ops->get_sset_count)
1588	return -EOPNOTSUPP;	1588	return -EOPNOTSUPP;
1589		1589
1590	test_len = ops->get_sset_count(dev, ETH_SS_TEST);	1590	test_len = ops->get_sset_count(dev, ETH_SS_TEST);
1591	if (test_len < 0)	1591	if (test_len < 0)
1592	return test_len;	1592	return test_len;
1593	WARN_ON(test_len == 0);	1593	WARN_ON(test_len == 0);
1594		1594
1595	if (copy_from_user(&test, useraddr, sizeof(test)))	1595	if (copy_from_user(&test, useraddr, sizeof(test)))
1596	return -EFAULT;	1596	return -EFAULT;
1597		1597
1598	test.len = test_len;	1598	test.len = test_len;
1599	data = kmalloc(test_len * sizeof(u64), GFP_USER);	1599	data = kmalloc(test_len * sizeof(u64), GFP_USER);
1600	if (!data)	1600	if (!data)
1601	return -ENOMEM;	1601	return -ENOMEM;
1602		1602
1603	ops->self_test(dev, &test, data);	1603	ops->self_test(dev, &test, data);
1604		1604
1605	ret = -EFAULT;	1605	ret = -EFAULT;
1606	if (copy_to_user(useraddr, &test, sizeof(test)))	1606	if (copy_to_user(useraddr, &test, sizeof(test)))
1607	goto out;	1607	goto out;
1608	useraddr += sizeof(test);	1608	useraddr += sizeof(test);
1609	if (copy_to_user(useraddr, data, test.len * sizeof(u64)))	1609	if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
1610	goto out;	1610	goto out;
1611	ret = 0;	1611	ret = 0;
1612		1612
1613	out:	1613	out:
1614	kfree(data);	1614	kfree(data);
1615	return ret;	1615	return ret;
1616	}	1616	}
1617		1617
1618	static int ethtool_get_strings(struct net_device dev, void __user useraddr)	1618	static int ethtool_get_strings(struct net_device dev, void __user useraddr)
1619	{	1619	{
1620	struct ethtool_gstrings gstrings;	1620	struct ethtool_gstrings gstrings;
1621	u8 *data;	1621	u8 *data;
1622	int ret;	1622	int ret;
1623		1623
1624	if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))	1624	if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
1625	return -EFAULT;	1625	return -EFAULT;
1626		1626
1627	ret = __ethtool_get_sset_count(dev, gstrings.string_set);	1627	ret = __ethtool_get_sset_count(dev, gstrings.string_set);
1628	if (ret < 0)	1628	if (ret < 0)
1629	return ret;	1629	return ret;
1630		1630
1631	gstrings.len = ret;	1631	gstrings.len = ret;
1632		1632
1633	data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);	1633	data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
1634	if (!data)	1634	if (!data)
1635	return -ENOMEM;	1635	return -ENOMEM;
1636		1636
1637	__ethtool_get_strings(dev, gstrings.string_set, data);	1637	__ethtool_get_strings(dev, gstrings.string_set, data);
1638		1638
1639	ret = -EFAULT;	1639	ret = -EFAULT;
1640	if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))	1640	if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1641	goto out;	1641	goto out;
1642	useraddr += sizeof(gstrings);	1642	useraddr += sizeof(gstrings);
1643	if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))	1643	if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1644	goto out;	1644	goto out;
1645	ret = 0;	1645	ret = 0;
1646		1646
1647	out:	1647	out:
1648	kfree(data);	1648	kfree(data);
1649	return ret;	1649	return ret;
1650	}	1650	}
1651		1651
1652	static int ethtool_phys_id(struct net_device dev, void __user useraddr)	1652	static int ethtool_phys_id(struct net_device dev, void __user useraddr)
1653	{	1653	{
1654	struct ethtool_value id;	1654	struct ethtool_value id;
1655	static bool busy;	1655	static bool busy;
1656	int rc;	1656	int rc;
1657		1657
1658	if (!dev->ethtool_ops->set_phys_id)	1658	if (!dev->ethtool_ops->set_phys_id)
1659	return -EOPNOTSUPP;	1659	return -EOPNOTSUPP;
1660		1660
1661	if (busy)	1661	if (busy)
1662	return -EBUSY;	1662	return -EBUSY;
1663		1663
1664	if (copy_from_user(&id, useraddr, sizeof(id)))	1664	if (copy_from_user(&id, useraddr, sizeof(id)))
1665	return -EFAULT;	1665	return -EFAULT;
1666		1666
1667	rc = dev->ethtool_ops->set_phys_id(dev, ETHTOOL_ID_ACTIVE);	1667	rc = dev->ethtool_ops->set_phys_id(dev, ETHTOOL_ID_ACTIVE);
1668	if (rc < 0)	1668	if (rc < 0)
1669	return rc;	1669	return rc;
1670		1670
1671	/* Drop the RTNL lock while waiting, but prevent reentry or	1671	/* Drop the RTNL lock while waiting, but prevent reentry or
1672	* removal of the device.	1672	* removal of the device.
1673	*/	1673	*/
1674	busy = true;	1674	busy = true;
1675	dev_hold(dev);	1675	dev_hold(dev);
1676	rtnl_unlock();	1676	rtnl_unlock();
1677		1677
1678	if (rc == 0) {	1678	if (rc == 0) {
1679	/* Driver will handle this itself */	1679	/* Driver will handle this itself */
1680	schedule_timeout_interruptible(	1680	schedule_timeout_interruptible(
1681	id.data ? (id.data * HZ) : MAX_SCHEDULE_TIMEOUT);	1681	id.data ? (id.data * HZ) : MAX_SCHEDULE_TIMEOUT);
1682	} else {	1682	} else {
1683	/* Driver expects to be called at twice the frequency in rc */	1683	/* Driver expects to be called at twice the frequency in rc */
1684	int n = rc * 2, i, interval = HZ / n;	1684	int n = rc * 2, i, interval = HZ / n;
1685		1685
1686	/* Count down seconds */	1686	/* Count down seconds */
1687	do {	1687	do {
1688	/* Count down iterations per second */	1688	/* Count down iterations per second */
1689	i = n;	1689	i = n;
1690	do {	1690	do {
1691	rtnl_lock();	1691	rtnl_lock();
1692	rc = dev->ethtool_ops->set_phys_id(dev,	1692	rc = dev->ethtool_ops->set_phys_id(dev,
1693	(i & 1) ? ETHTOOL_ID_OFF : ETHTOOL_ID_ON);	1693	(i & 1) ? ETHTOOL_ID_OFF : ETHTOOL_ID_ON);
1694	rtnl_unlock();	1694	rtnl_unlock();
1695	if (rc)	1695	if (rc)
1696	break;	1696	break;
1697	schedule_timeout_interruptible(interval);	1697	schedule_timeout_interruptible(interval);
1698	} while (!signal_pending(current) && --i != 0);	1698	} while (!signal_pending(current) && --i != 0);
1699	} while (!signal_pending(current) &&	1699	} while (!signal_pending(current) &&
1700	(id.data == 0 \|\| --id.data != 0));	1700	(id.data == 0 \|\| --id.data != 0));
1701	}	1701	}
1702		1702
1703	rtnl_lock();	1703	rtnl_lock();
1704	dev_put(dev);	1704	dev_put(dev);
1705	busy = false;	1705	busy = false;
1706		1706
1707	(void)dev->ethtool_ops->set_phys_id(dev, ETHTOOL_ID_INACTIVE);	1707	(void)dev->ethtool_ops->set_phys_id(dev, ETHTOOL_ID_INACTIVE);
1708	return rc;	1708	return rc;
1709	}	1709	}
1710		1710
1711	static int ethtool_get_stats(struct net_device dev, void __user useraddr)	1711	static int ethtool_get_stats(struct net_device dev, void __user useraddr)
1712	{	1712	{
1713	struct ethtool_stats stats;	1713	struct ethtool_stats stats;
1714	const struct ethtool_ops *ops = dev->ethtool_ops;	1714	const struct ethtool_ops *ops = dev->ethtool_ops;
1715	u64 *data;	1715	u64 *data;
1716	int ret, n_stats;	1716	int ret, n_stats;
1717		1717
1718	if (!ops->get_ethtool_stats \|\| !ops->get_sset_count)	1718	if (!ops->get_ethtool_stats \|\| !ops->get_sset_count)
1719	return -EOPNOTSUPP;	1719	return -EOPNOTSUPP;
1720		1720
1721	n_stats = ops->get_sset_count(dev, ETH_SS_STATS);	1721	n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
1722	if (n_stats < 0)	1722	if (n_stats < 0)
1723	return n_stats;	1723	return n_stats;
1724	WARN_ON(n_stats == 0);	1724	WARN_ON(n_stats == 0);
1725		1725
1726	if (copy_from_user(&stats, useraddr, sizeof(stats)))	1726	if (copy_from_user(&stats, useraddr, sizeof(stats)))
1727	return -EFAULT;	1727	return -EFAULT;
1728		1728
1729	stats.n_stats = n_stats;	1729	stats.n_stats = n_stats;
1730	data = kmalloc(n_stats * sizeof(u64), GFP_USER);	1730	data = kmalloc(n_stats * sizeof(u64), GFP_USER);
1731	if (!data)	1731	if (!data)
1732	return -ENOMEM;	1732	return -ENOMEM;
1733		1733
1734	ops->get_ethtool_stats(dev, &stats, data);	1734	ops->get_ethtool_stats(dev, &stats, data);
1735		1735
1736	ret = -EFAULT;	1736	ret = -EFAULT;
1737	if (copy_to_user(useraddr, &stats, sizeof(stats)))	1737	if (copy_to_user(useraddr, &stats, sizeof(stats)))
1738	goto out;	1738	goto out;
1739	useraddr += sizeof(stats);	1739	useraddr += sizeof(stats);
1740	if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))	1740	if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
1741	goto out;	1741	goto out;
1742	ret = 0;	1742	ret = 0;
1743		1743
1744	out:	1744	out:
1745	kfree(data);	1745	kfree(data);
1746	return ret;	1746	return ret;
1747	}	1747	}
1748		1748
1749	static int ethtool_get_perm_addr(struct net_device dev, void __user useraddr)	1749	static int ethtool_get_perm_addr(struct net_device dev, void __user useraddr)
1750	{	1750	{
1751	struct ethtool_perm_addr epaddr;	1751	struct ethtool_perm_addr epaddr;
1752		1752
1753	if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))	1753	if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
1754	return -EFAULT;	1754	return -EFAULT;
1755		1755
1756	if (epaddr.size < dev->addr_len)	1756	if (epaddr.size < dev->addr_len)
1757	return -ETOOSMALL;	1757	return -ETOOSMALL;
1758	epaddr.size = dev->addr_len;	1758	epaddr.size = dev->addr_len;
1759		1759
1760	if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))	1760	if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
1761	return -EFAULT;	1761	return -EFAULT;
1762	useraddr += sizeof(epaddr);	1762	useraddr += sizeof(epaddr);
1763	if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))	1763	if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
1764	return -EFAULT;	1764	return -EFAULT;
1765	return 0;	1765	return 0;
1766	}	1766	}
1767		1767
1768	static int ethtool_get_value(struct net_device dev, char __user useraddr,	1768	static int ethtool_get_value(struct net_device dev, char __user useraddr,
1769	u32 cmd, u32 (actor)(struct net_device ))	1769	u32 cmd, u32 (actor)(struct net_device ))
1770	{	1770	{
1771	struct ethtool_value edata = { .cmd = cmd };	1771	struct ethtool_value edata = { .cmd = cmd };
1772		1772
1773	if (!actor)	1773	if (!actor)
1774	return -EOPNOTSUPP;	1774	return -EOPNOTSUPP;
1775		1775
1776	edata.data = actor(dev);	1776	edata.data = actor(dev);
1777		1777
1778	if (copy_to_user(useraddr, &edata, sizeof(edata)))	1778	if (copy_to_user(useraddr, &edata, sizeof(edata)))
1779	return -EFAULT;	1779	return -EFAULT;
1780	return 0;	1780	return 0;
1781	}	1781	}
1782		1782
1783	static int ethtool_set_value_void(struct net_device dev, char __user useraddr,	1783	static int ethtool_set_value_void(struct net_device dev, char __user useraddr,
1784	void (actor)(struct net_device , u32))	1784	void (actor)(struct net_device , u32))
1785	{	1785	{
1786	struct ethtool_value edata;	1786	struct ethtool_value edata;
1787		1787
1788	if (!actor)	1788	if (!actor)
1789	return -EOPNOTSUPP;	1789	return -EOPNOTSUPP;
1790		1790
1791	if (copy_from_user(&edata, useraddr, sizeof(edata)))	1791	if (copy_from_user(&edata, useraddr, sizeof(edata)))
1792	return -EFAULT;	1792	return -EFAULT;
1793		1793
1794	actor(dev, edata.data);	1794	actor(dev, edata.data);
1795	return 0;	1795	return 0;
1796	}	1796	}
1797		1797
1798	static int ethtool_set_value(struct net_device dev, char __user useraddr,	1798	static int ethtool_set_value(struct net_device dev, char __user useraddr,
1799	int (actor)(struct net_device , u32))	1799	int (actor)(struct net_device , u32))
1800	{	1800	{
1801	struct ethtool_value edata;	1801	struct ethtool_value edata;
1802		1802
1803	if (!actor)	1803	if (!actor)
1804	return -EOPNOTSUPP;	1804	return -EOPNOTSUPP;
1805		1805
1806	if (copy_from_user(&edata, useraddr, sizeof(edata)))	1806	if (copy_from_user(&edata, useraddr, sizeof(edata)))
1807	return -EFAULT;	1807	return -EFAULT;
1808		1808
1809	return actor(dev, edata.data);	1809	return actor(dev, edata.data);
1810	}	1810	}
1811		1811
1812	static noinline_for_stack int ethtool_flash_device(struct net_device *dev,	1812	static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
1813	char __user *useraddr)	1813	char __user *useraddr)
1814	{	1814	{
1815	struct ethtool_flash efl;	1815	struct ethtool_flash efl;
1816		1816
1817	if (copy_from_user(&efl, useraddr, sizeof(efl)))	1817	if (copy_from_user(&efl, useraddr, sizeof(efl)))
1818	return -EFAULT;	1818	return -EFAULT;
1819		1819
1820	if (!dev->ethtool_ops->flash_device)	1820	if (!dev->ethtool_ops->flash_device)
1821	return -EOPNOTSUPP;	1821	return -EOPNOTSUPP;
1822		1822
1823	return dev->ethtool_ops->flash_device(dev, &efl);	1823	return dev->ethtool_ops->flash_device(dev, &efl);
1824	}	1824	}
1825		1825
1826	/* The main entry point in this file. Called from net/core/dev.c */	1826	/* The main entry point in this file. Called from net/core/dev.c */
1827		1827
1828	int dev_ethtool(struct net net, struct ifreq ifr)	1828	int dev_ethtool(struct net net, struct ifreq ifr)
1829	{	1829	{
1830	struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);	1830	struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
1831	void __user *useraddr = ifr->ifr_data;	1831	void __user *useraddr = ifr->ifr_data;
1832	u32 ethcmd;	1832	u32 ethcmd;
1833	int rc;	1833	int rc;
1834	u32 old_features;	1834	u32 old_features;
1835		1835
1836	if (!dev \|\| !netif_device_present(dev))	1836	if (!dev \|\| !netif_device_present(dev))
1837	return -ENODEV;	1837	return -ENODEV;
1838		1838
1839	if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))	1839	if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1840	return -EFAULT;	1840	return -EFAULT;
1841		1841
1842	if (!dev->ethtool_ops) {	1842	if (!dev->ethtool_ops) {
1843	/* ETHTOOL_GDRVINFO does not require any driver support.	1843	/* ETHTOOL_GDRVINFO does not require any driver support.
1844	* It is also unprivileged and does not change anything,	1844	* It is also unprivileged and does not change anything,
1845	* so we can take a shortcut to it. */	1845	* so we can take a shortcut to it. */
1846	if (ethcmd == ETHTOOL_GDRVINFO)	1846	if (ethcmd == ETHTOOL_GDRVINFO)
1847	return ethtool_get_drvinfo(dev, useraddr);	1847	return ethtool_get_drvinfo(dev, useraddr);
1848	else	1848	else
1849	return -EOPNOTSUPP;	1849	return -EOPNOTSUPP;
1850	}	1850	}
1851		1851
1852	/* Allow some commands to be done by anyone */	1852	/* Allow some commands to be done by anyone */
1853	switch (ethcmd) {	1853	switch (ethcmd) {
1854	case ETHTOOL_GSET:	1854	case ETHTOOL_GSET:
1855	case ETHTOOL_GDRVINFO:	1855	case ETHTOOL_GDRVINFO:
1856	case ETHTOOL_GMSGLVL:	1856	case ETHTOOL_GMSGLVL:
1857	case ETHTOOL_GCOALESCE:	1857	case ETHTOOL_GCOALESCE:
1858	case ETHTOOL_GRINGPARAM:	1858	case ETHTOOL_GRINGPARAM:
1859	case ETHTOOL_GPAUSEPARAM:	1859	case ETHTOOL_GPAUSEPARAM:
1860	case ETHTOOL_GRXCSUM:	1860	case ETHTOOL_GRXCSUM:
1861	case ETHTOOL_GTXCSUM:	1861	case ETHTOOL_GTXCSUM:
1862	case ETHTOOL_GSG:	1862	case ETHTOOL_GSG:
1863	case ETHTOOL_GSTRINGS:	1863	case ETHTOOL_GSTRINGS:
1864	case ETHTOOL_GTSO:	1864	case ETHTOOL_GTSO:
1865	case ETHTOOL_GPERMADDR:	1865	case ETHTOOL_GPERMADDR:
1866	case ETHTOOL_GUFO:	1866	case ETHTOOL_GUFO:
1867	case ETHTOOL_GGSO:	1867	case ETHTOOL_GGSO:
1868	case ETHTOOL_GGRO:	1868	case ETHTOOL_GGRO:
1869	case ETHTOOL_GFLAGS:	1869	case ETHTOOL_GFLAGS:
1870	case ETHTOOL_GPFLAGS:	1870	case ETHTOOL_GPFLAGS:
1871	case ETHTOOL_GRXFH:	1871	case ETHTOOL_GRXFH:
1872	case ETHTOOL_GRXRINGS:	1872	case ETHTOOL_GRXRINGS:
1873	case ETHTOOL_GRXCLSRLCNT:	1873	case ETHTOOL_GRXCLSRLCNT:
1874	case ETHTOOL_GRXCLSRULE:	1874	case ETHTOOL_GRXCLSRULE:
1875	case ETHTOOL_GRXCLSRLALL:	1875	case ETHTOOL_GRXCLSRLALL:
1876	case ETHTOOL_GFEATURES:	1876	case ETHTOOL_GFEATURES:
1877	break;	1877	break;
1878	default:	1878	default:
1879	if (!capable(CAP_NET_ADMIN))	1879	if (!capable(CAP_NET_ADMIN))
1880	return -EPERM;	1880	return -EPERM;
1881	}	1881	}
1882		1882
1883	if (dev->ethtool_ops->begin) {	1883	if (dev->ethtool_ops->begin) {
1884	rc = dev->ethtool_ops->begin(dev);	1884	rc = dev->ethtool_ops->begin(dev);
1885	if (rc < 0)	1885	if (rc < 0)
1886	return rc;	1886	return rc;
1887	}	1887	}
1888	old_features = dev->features;	1888	old_features = dev->features;
1889		1889
1890	switch (ethcmd) {	1890	switch (ethcmd) {
1891	case ETHTOOL_GSET:	1891	case ETHTOOL_GSET:
1892	rc = ethtool_get_settings(dev, useraddr);	1892	rc = ethtool_get_settings(dev, useraddr);
1893	break;	1893	break;
1894	case ETHTOOL_SSET:	1894	case ETHTOOL_SSET:
1895	rc = ethtool_set_settings(dev, useraddr);	1895	rc = ethtool_set_settings(dev, useraddr);
1896	break;	1896	break;
1897	case ETHTOOL_GDRVINFO:	1897	case ETHTOOL_GDRVINFO:
1898	rc = ethtool_get_drvinfo(dev, useraddr);	1898	rc = ethtool_get_drvinfo(dev, useraddr);
1899	break;	1899	break;
1900	case ETHTOOL_GREGS:	1900	case ETHTOOL_GREGS:
1901	rc = ethtool_get_regs(dev, useraddr);	1901	rc = ethtool_get_regs(dev, useraddr);
1902	break;	1902	break;
1903	case ETHTOOL_GWOL:	1903	case ETHTOOL_GWOL:
1904	rc = ethtool_get_wol(dev, useraddr);	1904	rc = ethtool_get_wol(dev, useraddr);
1905	break;	1905	break;
1906	case ETHTOOL_SWOL:	1906	case ETHTOOL_SWOL:
1907	rc = ethtool_set_wol(dev, useraddr);	1907	rc = ethtool_set_wol(dev, useraddr);
1908	break;	1908	break;
1909	case ETHTOOL_GMSGLVL:	1909	case ETHTOOL_GMSGLVL:
1910	rc = ethtool_get_value(dev, useraddr, ethcmd,	1910	rc = ethtool_get_value(dev, useraddr, ethcmd,
1911	dev->ethtool_ops->get_msglevel);	1911	dev->ethtool_ops->get_msglevel);
1912	break;	1912	break;
1913	case ETHTOOL_SMSGLVL:	1913	case ETHTOOL_SMSGLVL:
1914	rc = ethtool_set_value_void(dev, useraddr,	1914	rc = ethtool_set_value_void(dev, useraddr,
1915	dev->ethtool_ops->set_msglevel);	1915	dev->ethtool_ops->set_msglevel);
1916	break;	1916	break;
1917	case ETHTOOL_NWAY_RST:	1917	case ETHTOOL_NWAY_RST:
1918	rc = ethtool_nway_reset(dev);	1918	rc = ethtool_nway_reset(dev);
1919	break;	1919	break;
1920	case ETHTOOL_GLINK:	1920	case ETHTOOL_GLINK:
1921	rc = ethtool_get_link(dev, useraddr);	1921	rc = ethtool_get_link(dev, useraddr);
1922	break;	1922	break;
1923	case ETHTOOL_GEEPROM:	1923	case ETHTOOL_GEEPROM:
1924	rc = ethtool_get_eeprom(dev, useraddr);	1924	rc = ethtool_get_eeprom(dev, useraddr);
1925	break;	1925	break;
1926	case ETHTOOL_SEEPROM:	1926	case ETHTOOL_SEEPROM:
1927	rc = ethtool_set_eeprom(dev, useraddr);	1927	rc = ethtool_set_eeprom(dev, useraddr);
1928	break;	1928	break;
1929	case ETHTOOL_GCOALESCE:	1929	case ETHTOOL_GCOALESCE:
1930	rc = ethtool_get_coalesce(dev, useraddr);	1930	rc = ethtool_get_coalesce(dev, useraddr);
1931	break;	1931	break;
1932	case ETHTOOL_SCOALESCE:	1932	case ETHTOOL_SCOALESCE:
1933	rc = ethtool_set_coalesce(dev, useraddr);	1933	rc = ethtool_set_coalesce(dev, useraddr);
1934	break;	1934	break;
1935	case ETHTOOL_GRINGPARAM:	1935	case ETHTOOL_GRINGPARAM:
1936	rc = ethtool_get_ringparam(dev, useraddr);	1936	rc = ethtool_get_ringparam(dev, useraddr);
1937	break;	1937	break;
1938	case ETHTOOL_SRINGPARAM:	1938	case ETHTOOL_SRINGPARAM:
1939	rc = ethtool_set_ringparam(dev, useraddr);	1939	rc = ethtool_set_ringparam(dev, useraddr);
1940	break;	1940	break;
1941	case ETHTOOL_GPAUSEPARAM:	1941	case ETHTOOL_GPAUSEPARAM:
1942	rc = ethtool_get_pauseparam(dev, useraddr);	1942	rc = ethtool_get_pauseparam(dev, useraddr);
1943	break;	1943	break;
1944	case ETHTOOL_SPAUSEPARAM:	1944	case ETHTOOL_SPAUSEPARAM:
1945	rc = ethtool_set_pauseparam(dev, useraddr);	1945	rc = ethtool_set_pauseparam(dev, useraddr);
1946	break;	1946	break;
1947	case ETHTOOL_TEST:	1947	case ETHTOOL_TEST:
1948	rc = ethtool_self_test(dev, useraddr);	1948	rc = ethtool_self_test(dev, useraddr);
1949	break;	1949	break;
1950	case ETHTOOL_GSTRINGS:	1950	case ETHTOOL_GSTRINGS:
1951	rc = ethtool_get_strings(dev, useraddr);	1951	rc = ethtool_get_strings(dev, useraddr);
1952	break;	1952	break;
1953	case ETHTOOL_PHYS_ID:	1953	case ETHTOOL_PHYS_ID:
1954	rc = ethtool_phys_id(dev, useraddr);	1954	rc = ethtool_phys_id(dev, useraddr);
1955	break;	1955	break;
1956	case ETHTOOL_GSTATS:	1956	case ETHTOOL_GSTATS:
1957	rc = ethtool_get_stats(dev, useraddr);	1957	rc = ethtool_get_stats(dev, useraddr);
1958	break;	1958	break;
1959	case ETHTOOL_GPERMADDR:	1959	case ETHTOOL_GPERMADDR:
1960	rc = ethtool_get_perm_addr(dev, useraddr);	1960	rc = ethtool_get_perm_addr(dev, useraddr);
1961	break;	1961	break;
1962	case ETHTOOL_GFLAGS:	1962	case ETHTOOL_GFLAGS:
1963	rc = ethtool_get_value(dev, useraddr, ethcmd,	1963	rc = ethtool_get_value(dev, useraddr, ethcmd,
1964	(dev->ethtool_ops->get_flags ?	1964	(dev->ethtool_ops->get_flags ?
1965	dev->ethtool_ops->get_flags :	1965	dev->ethtool_ops->get_flags :
1966	ethtool_op_get_flags));	1966	ethtool_op_get_flags));
1967	break;	1967	break;
1968	case ETHTOOL_SFLAGS:	1968	case ETHTOOL_SFLAGS:
1969	rc = ethtool_set_value(dev, useraddr, __ethtool_set_flags);	1969	rc = ethtool_set_value(dev, useraddr, __ethtool_set_flags);
1970	break;	1970	break;
1971	case ETHTOOL_GPFLAGS:	1971	case ETHTOOL_GPFLAGS:
1972	rc = ethtool_get_value(dev, useraddr, ethcmd,	1972	rc = ethtool_get_value(dev, useraddr, ethcmd,
1973	dev->ethtool_ops->get_priv_flags);	1973	dev->ethtool_ops->get_priv_flags);
1974	break;	1974	break;
1975	case ETHTOOL_SPFLAGS:	1975	case ETHTOOL_SPFLAGS:
1976	rc = ethtool_set_value(dev, useraddr,	1976	rc = ethtool_set_value(dev, useraddr,
1977	dev->ethtool_ops->set_priv_flags);	1977	dev->ethtool_ops->set_priv_flags);
1978	break;	1978	break;
1979	case ETHTOOL_GRXFH:	1979	case ETHTOOL_GRXFH:
1980	case ETHTOOL_GRXRINGS:	1980	case ETHTOOL_GRXRINGS:
1981	case ETHTOOL_GRXCLSRLCNT:	1981	case ETHTOOL_GRXCLSRLCNT:
1982	case ETHTOOL_GRXCLSRULE:	1982	case ETHTOOL_GRXCLSRULE:
1983	case ETHTOOL_GRXCLSRLALL:	1983	case ETHTOOL_GRXCLSRLALL:
1984	rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);	1984	rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
1985	break;	1985	break;
1986	case ETHTOOL_SRXFH:	1986	case ETHTOOL_SRXFH:
1987	case ETHTOOL_SRXCLSRLDEL:	1987	case ETHTOOL_SRXCLSRLDEL:
1988	case ETHTOOL_SRXCLSRLINS:	1988	case ETHTOOL_SRXCLSRLINS:
1989	rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);	1989	rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
1990	break;	1990	break;
1991	case ETHTOOL_FLASHDEV:	1991	case ETHTOOL_FLASHDEV:
1992	rc = ethtool_flash_device(dev, useraddr);	1992	rc = ethtool_flash_device(dev, useraddr);
1993	break;	1993	break;
1994	case ETHTOOL_RESET:	1994	case ETHTOOL_RESET:
1995	rc = ethtool_reset(dev, useraddr);	1995	rc = ethtool_reset(dev, useraddr);
1996	break;	1996	break;
1997	case ETHTOOL_SRXNTUPLE:	1997	case ETHTOOL_SRXNTUPLE:
1998	rc = ethtool_set_rx_ntuple(dev, useraddr);	1998	rc = ethtool_set_rx_ntuple(dev, useraddr);
1999	break;	1999	break;
2000	case ETHTOOL_GRXNTUPLE:	2000	case ETHTOOL_GRXNTUPLE:
2001	rc = ethtool_get_rx_ntuple(dev, useraddr);	2001	rc = ethtool_get_rx_ntuple(dev, useraddr);
2002	break;	2002	break;
2003	case ETHTOOL_GSSET_INFO:	2003	case ETHTOOL_GSSET_INFO:
2004	rc = ethtool_get_sset_info(dev, useraddr);	2004	rc = ethtool_get_sset_info(dev, useraddr);
2005	break;	2005	break;
2006	case ETHTOOL_GRXFHINDIR:	2006	case ETHTOOL_GRXFHINDIR:
2007	rc = ethtool_get_rxfh_indir(dev, useraddr);	2007	rc = ethtool_get_rxfh_indir(dev, useraddr);
2008	break;	2008	break;
2009	case ETHTOOL_SRXFHINDIR:	2009	case ETHTOOL_SRXFHINDIR:
2010	rc = ethtool_set_rxfh_indir(dev, useraddr);	2010	rc = ethtool_set_rxfh_indir(dev, useraddr);
2011	break;	2011	break;
2012	case ETHTOOL_GFEATURES:	2012	case ETHTOOL_GFEATURES:
2013	rc = ethtool_get_features(dev, useraddr);	2013	rc = ethtool_get_features(dev, useraddr);
2014	break;	2014	break;
2015	case ETHTOOL_SFEATURES:	2015	case ETHTOOL_SFEATURES:
2016	rc = ethtool_set_features(dev, useraddr);	2016	rc = ethtool_set_features(dev, useraddr);
2017	break;	2017	break;
2018	case ETHTOOL_GTXCSUM:	2018	case ETHTOOL_GTXCSUM:
2019	case ETHTOOL_GRXCSUM:	2019	case ETHTOOL_GRXCSUM:
2020	case ETHTOOL_GSG:	2020	case ETHTOOL_GSG:
2021	case ETHTOOL_GTSO:	2021	case ETHTOOL_GTSO:
2022	case ETHTOOL_GUFO:	2022	case ETHTOOL_GUFO:
2023	case ETHTOOL_GGSO:	2023	case ETHTOOL_GGSO:
2024	case ETHTOOL_GGRO:	2024	case ETHTOOL_GGRO:
2025	rc = ethtool_get_one_feature(dev, useraddr, ethcmd);	2025	rc = ethtool_get_one_feature(dev, useraddr, ethcmd);
2026	break;	2026	break;
2027	case ETHTOOL_STXCSUM:	2027	case ETHTOOL_STXCSUM:
2028	case ETHTOOL_SRXCSUM:	2028	case ETHTOOL_SRXCSUM:
2029	case ETHTOOL_SSG:	2029	case ETHTOOL_SSG:
2030	case ETHTOOL_STSO:	2030	case ETHTOOL_STSO:
2031	case ETHTOOL_SUFO:	2031	case ETHTOOL_SUFO:
2032	case ETHTOOL_SGSO:	2032	case ETHTOOL_SGSO:
2033	case ETHTOOL_SGRO:	2033	case ETHTOOL_SGRO:
2034	rc = ethtool_set_one_feature(dev, useraddr, ethcmd);	2034	rc = ethtool_set_one_feature(dev, useraddr, ethcmd);
2035	break;	2035	break;
2036	case ETHTOOL_GCHANNELS:	2036	case ETHTOOL_GCHANNELS:
2037	rc = ethtool_get_channels(dev, useraddr);	2037	rc = ethtool_get_channels(dev, useraddr);
2038	break;	2038	break;
2039	case ETHTOOL_SCHANNELS:	2039	case ETHTOOL_SCHANNELS:
2040	rc = ethtool_set_channels(dev, useraddr);	2040	rc = ethtool_set_channels(dev, useraddr);
2041	break;	2041	break;
2042	default:	2042	default:
2043	rc = -EOPNOTSUPP;	2043	rc = -EOPNOTSUPP;
2044	}	2044	}
2045		2045
2046	if (dev->ethtool_ops->complete)	2046	if (dev->ethtool_ops->complete)
2047	dev->ethtool_ops->complete(dev);	2047	dev->ethtool_ops->complete(dev);
2048		2048
2049	if (old_features != dev->features)	2049	if (old_features != dev->features)
2050	netdev_features_change(dev);	2050	netdev_features_change(dev);
2051		2051
2052	return rc;	2052	return rc;
2053	}	2053	}
2054		2054