/*
   * 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.h>

  #include <linux/timer.h>

  #include <linux/delay.h>

  #include <linux/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/dynamic_queue_limits.h>

  #include <linux/ethtool.h>

  #include <net/net_namespace.h>

  #include <net/dsa.h>

  #ifdef CONFIG_DCB

  #include <net/dcbnl.h>
  #endif

  #include <net/netprio_cgroup.h>

  #include <linux/netdev_features.h>

  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) )

  /* 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) || IS_ENABLED(CONFIG_AX25)

  # if defined(CONFIG_MAC80211_MESH)
  #  define LL_MAX_HEADER 128
  # else
  #  define LL_MAX_HEADER 96
  # endif

  #elif IS_ENABLED(CONFIG_TR)

  # define LL_MAX_HEADER 48

  #else

  # define LL_MAX_HEADER 32

  #endif

  #if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
      !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)

  #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>

  #ifdef CONFIG_RPS
  #include <linux/jump_label.h>
  extern struct jump_label_key rps_needed;
  #endif

  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 {

  	u16		hh_len;

  	u16		__pad;

  	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)];
  };
  
  /* 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.
   */
  #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)

  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);

  	int	(*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);

  	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_DRV_XOFF,
  	__QUEUE_STATE_STACK_XOFF,

  	__QUEUE_STATE_FROZEN,

  #define QUEUE_STATE_ANY_XOFF ((1 << __QUEUE_STATE_DRV_XOFF)		| \
  			      (1 << __QUEUE_STATE_STACK_XOFF))
  #define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF		| \
  					(1 << __QUEUE_STATE_FROZEN))

  };

  /*
   * __QUEUE_STATE_DRV_XOFF is used by drivers to stop the transmit queue.  The
   * netif_tx_* functions below are used to manipulate this flag.  The
   * __QUEUE_STATE_STACK_XOFF flag is used by the stack to stop the transmit
   * queue independently.  The netif_xmit_*stopped functions below are called
   * to check if the queue has been stopped by the driver or stack (either
   * of the XOFF bits are set in the state).  Drivers should not need to call
   * netif_xmit*stopped functions, they should only be using netif_tx_*.
   */

  struct netdev_queue {

  /*
   * read mostly part
   */

  	struct net_device	*dev;

  	struct Qdisc		*qdisc;
  	struct Qdisc		*qdisc_sleeping;

  #ifdef CONFIG_SYSFS

  	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;

  
  	/*
  	 * Number of TX timeouts for this queue
  	 * (/sys/class/net/DEV/Q/trans_timeout)
  	 */
  	unsigned long		trans_timeout;

  
  	unsigned long		state;
  
  #ifdef CONFIG_BQL
  	struct dql		dql;
  #endif

  } ____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;
  };

  #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
  /*
   * This structure is to hold information about the device
   * configured to run FCoE protocol stack.
   */
  struct netdev_fcoe_hbainfo {
  	char	manufacturer[64];
  	char	serial_number[64];
  	char	hardware_version[64];
  	char	driver_version[64];
  	char	optionrom_version[64];
  	char	firmware_version[64];
  	char	model[256];
  	char	model_description[256];
  };
  #endif

  /*
   * 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.

   *	If driver handles unicast address filtering, it should set
   *	IFF_UNICAST_FLT to its priv_flags.

   *
   * 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.

   *

   * int (*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.
   *

   * int (*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_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);

   * 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_hbainfo)(struct net_device *dev,
   *			       struct netdev_fcoe_hbainfo *hbainfo);
   *	Called when the FCoE Protocol stack wants information on the underlying
   *	device. This information is utilized by the FCoE protocol stack to
   *	register attributes with Fiber Channel management service as per the
   *	FC-GS Fabric Device Management Information(FDMI) specification.
   *

   * 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.

   * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
   *		netdev_features_t 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, netdev_features_t 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.
   *

   */
  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);

  	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);

  	int			(*ndo_vlan_rx_add_vid)(struct net_device *dev,

  						       unsigned short vid);

  	int			(*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_set_vf_spoofchk)(struct net_device *dev,
  						       int vf, bool setting);

  	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 IS_ENABLED(CONFIG_FCOE)

  	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);

  	int			(*ndo_fcoe_get_hbainfo)(struct net_device *dev,
  							struct netdev_fcoe_hbainfo *hbainfo);

  #endif

  #if IS_ENABLED(CONFIG_LIBFCOE)

  #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);

  	netdev_features_t	(*ndo_fix_features)(struct net_device *dev,
  						    netdev_features_t features);

  	int			(*ndo_set_features)(struct net_device *dev,

  						    netdev_features_t features);

  	int			(*ndo_neigh_construct)(struct neighbour *n);

  	void			(*ndo_neigh_destroy)(struct neighbour *n);

  };

  /*

   *	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	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 long		state;

  	struct list_head	dev_list;

  	struct list_head	napi_list;

  	struct list_head	unreg_list;

  	/* currently active device features */

  	netdev_features_t	features;

  	/* user-changeable features */

  	netdev_features_t	hw_features;

  	/* user-requested features */

  	netdev_features_t	wanted_features;

  	/* mask of features inheritable by VLAN devices */

  	netdev_features_t	vlan_features;

  	/* 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 int		priv_flags; /* Like 'flags' but invisible to userspace. */

  	unsigned short		gflags;

  	unsigned short		padded;	/* How much padding added by alloc_netdev() */

  	unsigned char		operstate; /* RFC2863 operstate */
  	unsigned char		link_mode; /* mapping policy to operstate */

  	unsigned char		if_port;	/* Selectable AUI, TP,..*/
  	unsigned char		dma;		/* DMA channel		*/

  	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 char		neigh_priv_len;

  	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 */

  	bool			uc_promisc;

  	unsigned int		promiscuity;
  	unsigned int		allmulti;

  
  	/* Protocol specific pointers */

  #if IS_ENABLED(CONFIG_VLAN_8021Q)

  	struct vlan_info __rcu	*vlan_info;	/* VLAN info */

  #endif

  #if IS_ENABLED(CONFIG_NET_DSA)

  	struct dsa_switch_tree	*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_SYSFS

  	struct kset		*queues_kset;

  #endif

  #ifdef CONFIG_RPS

  	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:8;
  
  	bool dismantle; /* device is going do be freed */

  
  	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 IS_ENABLED(CONFIG_FCOE)

  	/* max exchange id for FCoE LRO by ddp */
  	unsigned int		fcoe_ddp_xid;
  #endif

  #if IS_ENABLED(CONFIG_NETPRIO_CGROUP)
  	struct netprio_map __rcu *priomap;
  #endif

  	/* 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,

  						netdev_features_t 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/notifier.h>

  /* netdevice notifier chain. Please remember to update the rtnetlink
   * notification exclusion list in rtnetlink_event() when adding new
   * types.
   */
  #define NETDEV_UP	0x0001	/* For now you can't veto a device up/down */
  #define NETDEV_DOWN	0x0002
  #define NETDEV_REBOOT	0x0003	/* Tell a protocol stack a network interface
  				   detected a hardware crash and restarted
  				   - we can use this eg to kick tcp sessions
  				   once done */
  #define NETDEV_CHANGE	0x0004	/* Notify device state change */
  #define NETDEV_REGISTER 0x0005
  #define NETDEV_UNREGISTER	0x0006
  #define NETDEV_CHANGEMTU	0x0007
  #define NETDEV_CHANGEADDR	0x0008
  #define NETDEV_GOING_DOWN	0x0009
  #define NETDEV_CHANGENAME	0x000A
  #define NETDEV_FEAT_CHANGE	0x000B
  #define NETDEV_BONDING_FAILOVER 0x000C
  #define NETDEV_PRE_UP		0x000D
  #define NETDEV_PRE_TYPE_CHANGE	0x000E
  #define NETDEV_POST_TYPE_CHANGE	0x000F
  #define NETDEV_POST_INIT	0x0010
  #define NETDEV_UNREGISTER_BATCH 0x0011
  #define NETDEV_RELEASE		0x0012
  #define NETDEV_NOTIFY_PEERS	0x0013
  #define NETDEV_JOIN		0x0014
  
  extern int register_netdevice_notifier(struct notifier_block *nb);
  extern int unregister_netdevice_notifier(struct notifier_block *nb);
  extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);

  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		init_dummy_netdev(struct net_device *dev);

  extern void		netdev_resync_ops(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)
  {

  	if (!pskb_may_pull(skb, hlen))
  		return NULL;

  	NAPI_GRO_CB(skb)->frag0 = NULL;
  	NAPI_GRO_CB(skb)->frag0_len = 0;

  	return skb->data + offset;

  }

  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);

  extern void __netif_schedule(struct Qdisc *q);

  static inline void netif_schedule_queue(struct netdev_queue *txq)

  {

  	if (!(txq->state & QUEUE_STATE_ANY_XOFF))

  		__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_DRV_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_DRV_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()
  ");

  		return;
  	}

  	set_bit(__QUEUE_STATE_DRV_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_DRV_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_xmit_stopped(const struct netdev_queue *dev_queue)

  {

  	return dev_queue->state & QUEUE_STATE_ANY_XOFF;
  }
  
  static inline int netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
  {
  	return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
  }

  static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
  					unsigned int bytes)
  {

  #ifdef CONFIG_BQL
  	dql_queued(&dev_queue->dql, bytes);
  	if (unlikely(dql_avail(&dev_queue->dql) < 0)) {
  		set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
  		if (unlikely(dql_avail(&dev_queue->dql) >= 0))
  			clear_bit(__QUEUE_STATE_STACK_XOFF,
  			    &dev_queue->state);
  	}
  #endif

  }
  
  static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
  {
  	netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes);
  }
  
  static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
  					     unsigned pkts, unsigned bytes)
  {

  #ifdef CONFIG_BQL
  	if (likely(bytes)) {
  		dql_completed(&dev_queue->dql, bytes);
  		if (unlikely(test_bit(__QUEUE_STATE_STACK_XOFF,
  		    &dev_queue->state) &&
  		    dql_avail(&dev_queue->dql) >= 0)) {
  			if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF,
  			     &dev_queue->state))
  				netif_schedule_queue(dev_queue);
  		}
  	}
  #endif

  }
  
  static inline void netdev_completed_queue(struct net_device *dev,
  					  unsigned pkts, unsigned bytes)
  {
  	netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes);
  }
  
  static inline void netdev_tx_reset_queue(struct netdev_queue *q)
  {

  #ifdef CONFIG_BQL
  	dql_reset(&q->dql);
  #endif