p!ranha?
Server IP : 103.169.32.36  /  Your IP : 216.73.217.13
Web Server : Apache
System : Linux web.dpmptsp 3.10.0-1160.119.1.el7.x86_64 #1 SMP Tue Jun 4 14:43:51 UTC 2024 x86_64
User : apache ( 48)
PHP Version : 5.6.40
Disable Function : NONE
MySQL : ON  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : ON  |  Sudo : ON  |  Pkexec : ON
Directory :  /usr/lib/modules/3.10.0-1160.105.1.el7.x86_64/source/include/linux/

Upload File :
Curr3nt_D!r [ Writeable ] D0cum3nt_r0Ot [ Writeable ]

 
Command :
Current File : /usr/lib/modules/3.10.0-1160.105.1.el7.x86_64/source/include/linux/netdevice.h
/*
 * 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/pm_qos.h>
#include <linux/timer.h>
#include <linux/bug.h>
#include <linux/delay.h>
#include <linux/atomic.h>
#include <linux/prefetch.h>
#include <asm/cache.h>
#include <asm/byteorder.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 <net/xdp.h>

#include <linux/netdev_features.h>
#include <linux/neighbour.h>
#include <uapi/linux/netdevice.h>
#include <uapi/linux/if_bonding.h>
#include <uapi/linux/pkt_cls.h>
#include <linux/hashtable.h>

#include <linux/rh_kabi.h>

struct netpoll_info;
struct device;
struct phy_device;
/* 802.11 specific */
struct wireless_dev;
/* 802.15.4 specific */
struct wpan_dev;
/* UDP Tunnel offloads */
struct udp_tunnel_info;
struct bpf_prog;
struct xdp_buff;

struct netdev_xdp;
#define netdev_bpf netdev_xdp

struct net_device_extended;
					/* source back-compat hooks */
#define SET_ETHTOOL_OPS(netdev,ops) \
	( (netdev)->ethtool_ops = (ops) )

void netdev_set_default_ethtool_ops(struct net_device *dev,
				    const struct 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 */
#define NET_ADDR_SET		3	/* address is set using
					 * dev_set_mac_address() */

/* 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_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;
}

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


#include <linux/cache.h>
#include <linux/skbuff.h>

#ifdef CONFIG_RPS
#include <linux/static_key.h>
extern struct static_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			global_use;
	int			sync_cnt;
	int			refcount;
	int			synced;
	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 int 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

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;
	unsigned int		gro_count;
	int			(*poll)(struct napi_struct *, int);
#ifdef CONFIG_NETPOLL
	RH_KABI_DEPRECATE(spinlock_t, poll_lock)
	int			poll_owner;
#endif
	struct net_device	*dev;
	struct sk_buff		*gro_list;
	struct sk_buff		*skb;
	struct list_head	dev_list;
	struct hlist_node	napi_hash_node;
	unsigned int		napi_id;
	RH_KABI_EXTEND(size_t	size)
	RH_KABI_EXTEND(struct hrtimer	timer)
};

#define NAPI_STRUCT_HAS(napi, member)				\
	({ const struct napi_struct *__n = napi;			\
	   (test_bit(NAPI_STATE_EXT, &__n->state) &&		\
	   (offsetof(struct napi_struct, member) < __n->size)); })

enum {
	NAPI_STATE_SCHED,	/* Poll is scheduled */
	NAPI_STATE_DISABLE,	/* Disable pending */
	NAPI_STATE_NPSVC,	/* Netpoll - don't dequeue from poll_list */
	NAPI_STATE_HASHED,	/* In NAPI hash */
	NAPI_STATE_EXT,		/* Extended napi_struct */
	NAPI_STATE_NO_BUSY_POLL,/* Do not add in napi_hash, no busy polling */
	NAPI_STATE_IN_BUSY_POLL,/* sk_busy_loop() owns this NAPI */
	NAPI_STATE_MISSED,	/* reschedule a napi */
};

enum {
	NAPIF_STATE_SCHED	 = BIT(NAPI_STATE_SCHED),
	NAPIF_STATE_MISSED	 = BIT(NAPI_STATE_MISSED),
	NAPIF_STATE_DISABLE	 = BIT(NAPI_STATE_DISABLE),
	NAPIF_STATE_NPSVC	 = BIT(NAPI_STATE_NPSVC),
	NAPIF_STATE_HASHED	 = BIT(NAPI_STATE_HASHED),
	NAPIF_STATE_NO_BUSY_POLL = BIT(NAPI_STATE_NO_BUSY_POLL),
	NAPIF_STATE_IN_BUSY_POLL = BIT(NAPI_STATE_IN_BUSY_POLL),
};

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

void __napi_schedule(struct napi_struct *n);
void __napi_schedule_irqoff(struct napi_struct *n);

static inline bool napi_disable_pending(struct napi_struct *n)
{
	return test_bit(NAPI_STATE_DISABLE, &n->state);
}

bool napi_schedule_prep(struct napi_struct *n);

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

/**
 *	napi_schedule_irqoff - schedule NAPI poll
 *	@n: napi context
 *
 * Variant of napi_schedule(), assuming hard irqs are masked.
 */
static inline void napi_schedule_irqoff(struct napi_struct *n)
{
	if (napi_schedule_prep(n))
		__napi_schedule_irqoff(n);
}

/* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
static inline bool napi_reschedule(struct napi_struct *napi)
{
	if (napi_schedule_prep(napi)) {
		__napi_schedule(napi);
		return true;
	}
	return false;
}

RH_KABI_REPLACE_UNSAFE(void __napi_complete(struct napi_struct *n),
		       bool __napi_complete(struct napi_struct *n))
bool napi_complete_done(struct napi_struct *n, int work_done);
/**
 *	napi_complete - NAPI processing complete
 *	@n: napi context
 *
 * Mark NAPI processing as complete.
 * Consider using napi_complete_done() instead.
 * Return false if device should avoid rearming interrupts.
 */
static inline bool _napi_complete(struct napi_struct *n)
{
	return napi_complete_done(n, 0);
}

/* RHEL has napi_complete in KABI so we need to keep it for binary
 * modules. Newly compiled modules will use inlined function. */
void napi_complete(struct napi_struct *n);
#define napi_complete _napi_complete

/**
 *	napi_hash_add - add a NAPI to global hashtable
 *	@napi: napi context
 *
 * generate a new napi_id and store a @napi under it in napi_hash
 * Used for busy polling (CONFIG_NET_RX_BUSY_POLL)
 * Note: This is normally automatically done from netif_napi_add(),
 * so might disappear in a future linux version.
 */
void napi_hash_add(struct napi_struct *napi);

/**
 *	napi_hash_del - remove a NAPI from global table
 *	@napi: napi context
 *
 * Warning: caller must observe rcu grace period
 * before freeing memory containing @napi, if
 * this function returns true.
 * Note: core networking stack automatically calls it
 * from netif_napi_del()
 * Drivers might want to call this helper to combine all
 * the needed rcu grace periods into a single one.
 */
bool napi_hash_del(struct napi_struct *napi);

/**
 *	napi_disable - prevent NAPI from scheduling
 *	@n: napi context
 *
 * Stop NAPI from being scheduled on this context.
 * Waits till any outstanding processing completes.
 */
void napi_disable(struct napi_struct *n);

/**
 *	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);
	clear_bit(NAPI_STATE_NPSVC, &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

/**
 *	napi_if_scheduled_mark_missed - if napi is running, set the
 *	NAPIF_STATE_MISSED
 *	@n: NAPI context
 *
 * If napi is running, set the NAPIF_STATE_MISSED, and return true if
 * NAPI is scheduled.
 **/
static inline bool napi_if_scheduled_mark_missed(struct napi_struct *n)
{
	unsigned long val, new;

	do {
		val = READ_ONCE(n->state);
		if (val & NAPIF_STATE_DISABLE)
			return true;

		if (!(val & NAPIF_STATE_SCHED))
			return false;

		new = val | NAPIF_STATE_MISSED;
	} while (cmpxchg(&n->state, val, new) != val);

	return true;
}

enum netdev_queue_state_t {
	__QUEUE_STATE_DRV_XOFF,
	__QUEUE_STATE_STACK_XOFF,
	__QUEUE_STATE_FROZEN,
};

#define QUEUE_STATE_DRV_XOFF	(1 << __QUEUE_STATE_DRV_XOFF)
#define QUEUE_STATE_STACK_XOFF	(1 << __QUEUE_STATE_STACK_XOFF)
#define QUEUE_STATE_FROZEN	(1 << __QUEUE_STATE_FROZEN)

#define QUEUE_STATE_ANY_XOFF	(QUEUE_STATE_DRV_XOFF | QUEUE_STATE_STACK_XOFF)
#define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
					QUEUE_STATE_FROZEN)
#define QUEUE_STATE_DRV_XOFF_OR_FROZEN (QUEUE_STATE_DRV_XOFF | \
					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 __rcu	*qdisc;
	struct Qdisc		*qdisc_sleeping;
#ifdef CONFIG_SYSFS
	struct kobject		kobj;
#endif
#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
	int			numa_node;
#endif
	/* There is a hole that can be used for additional struct members
	 * without kABI breakage.
	 * There are 36 bytes available on all supported platforms.
	 */
/*
 * write mostly part
 */
	spinlock_t		_xmit_lock ____cacheline_aligned_in_smp;
	int			xmit_lock_owner;
	/*
	 * Time (in jiffies) of last Tx
	 */
	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;

	/* There is a hole that can be used for additional struct members
	 * without kABI breakage.
	 * There are 32 bytes available on all supported platforms.
	 */
	RH_KABI_FILL_HOLE(unsigned long	tx_maxrate)	/* 8 bytes */
	/* 24 bytes remaining */
#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 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
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(_tcs) (sizeof(struct xps_dev_maps) +		\
	(nr_cpu_ids * (_tcs) * 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

#define MAX_PHYS_PORT_ID_LEN 32
#define MAX_PHYS_ITEM_ID_LEN MAX_PHYS_PORT_ID_LEN

/* This structure holds a unique identifier to identify some
 * physical item (port for example) used by a netdevice.
 */
struct netdev_phys_port_id {
	unsigned char id[MAX_PHYS_ITEM_ID_LEN];
	unsigned char id_len;
};
#define netdev_phys_item_id netdev_phys_port_id

static inline bool netdev_phys_item_id_same(struct netdev_phys_item_id *a,
					    struct netdev_phys_item_id *b)
{
	return a->id_len == b->id_len &&
	       memcmp(a->id, b->id, a->id_len) == 0;
}

typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
				       struct sk_buff *skb);

enum tc_setup_type {
	TC_SETUP_QDISC_MQPRIO,
	TC_SETUP_CLSU32,
	TC_SETUP_CLSFLOWER,
	TC_SETUP_CLSMATCHALL,
	TC_SETUP_CLSBPF,
	TC_SETUP_BLOCK,
	TC_SETUP_QDISC_CBS,
	TC_SETUP_QDISC_RED,
	TC_SETUP_QDISC_PRIO,
};

/* Forward declaration of tc_to_netdev structure used by __rh_call_ndo_setup_tc
 * wrapper for out-of-tree drivers compiled against RHEL7.4.
 */
struct tc_to_netdev_rh74;

struct tc_cls_u32_offload;

struct tc_to_netdev {
	unsigned int type;
	union {
		u8 tc;
		struct tc_cls_u32_offload *cls_u32;
		struct tc_cls_flower_offload *cls_flower;
		struct tc_cls_matchall_offload *cls_mall;
		struct tc_cls_bpf_offload *cls_bpf;
	};
	bool egress_dev;
};

/* This structure defines the management hooks for network devices.
 * It is an extension of net_device_ops. Drivers that want to use any of the
 * fields defined here must initialize net_device_ops->ndo_size to
 * sizeof(struct net_device_ops).
 *
 * void* (*ndo_dfwd_add_station)(struct net_device *pdev,
 *				 struct net_device *dev)
 *	Called by upper layer devices to accelerate switching or other
 *	station functionality into hardware. 'pdev is the lowerdev
 *	to use for the offload and 'dev' is the net device that will
 *	back the offload. Returns a pointer to the private structure
 *	the upper layer will maintain.
 * void (*ndo_dfwd_del_station)(struct net_device *pdev, void *priv)
 *	Called by upper layer device to delete the station created
 *	by 'ndo_dfwd_add_station'. 'pdev' is the net device backing
 *	the station and priv is the structure returned by the add
 *	operation.
 * int (*ndo_set_tx_maxrate)(struct net_device *dev,
 *			     int queue_index, u32 maxrate);
 *	Called when a user wants to set a max-rate limitation of specific
 *	TX queue.
 * void (*ndo_set_rx_headroom)(struct net_device *dev, int needed_headroom);
 *	This function is used to specify the headroom that the skb must
 *	consider when allocation skb during packet reception. Setting
 *	appropriate rx headroom value allows avoiding skb head copy on
 *	forward. Setting a negative value reset the rx headroom to the
 *	default value.
 * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
 *		       struct net_device *dev, struct net_device *filter_dev,
 *		       int *idx)
 *	Used to add FDB entries to dump requests. Implementers should add
 *	entries to skb and update idx with the number of entries.
 * void (*ndo_change_proto_down)(struct net_device *dev,
 *				 bool proto_down);
 *	This function is used to pass protocol port error state information
 *	to the switch driver. The switch driver can react to the proto_down
 *      by doing a phys down on the associated switch port.
 * void (*ndo_udp_tunnel_add)(struct net_device *dev,
 *			      struct udp_tunnel_info *ti);
 *	Called by UDP tunnel to notify a driver about the UDP port and socket
 *	address family that a UDP tunnel is listnening to. It is called only
 *	when a new port starts listening. The operation is protected by the
 *	RTNL.
 *
 * void (*ndo_udp_tunnel_del)(struct net_device *dev,
 *			      struct udp_tunnel_info *ti);
 *	Called by UDP tunnel to notify the driver about a UDP port and socket
 *	address family that the UDP tunnel is not listening to anymore. The
 *	operation is protected by the RTNL.
 *
 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan,
 *			  u8 qos, __be16 proto);
 *
 * bool (*ndo_has_offload_stats)(const struct net_device *dev, int attr_id)
 *	Return true if this device supports offload stats of this attr_id.
 *
 * int (*ndo_get_offload_stats)(int attr_id, const struct net_device *dev,
 *	void *attr_data)
 *	Get statistics for offload operations by attr_id. Write it into the
 *	attr_data pointer.
 *
 * 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.
 *	RHEL: This is an entry point for network device drivers that
 *	      use central MTU range checking provided by network core.
 *
 * int (*ndo_setup_tc)(struct net_device *dev, enum tc_setup_type type,
 *		       void *type_data);
 *	Called to setup any 'tc' scheduler, classifier or action on @dev.
 *	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.
 *	RHEL: Note that this callback is not part of kABI and its prototype
 *	and semantic can be changed across releases.
 * int (*ndo_xdp)(struct net_device *dev, struct netdev_xdp *xdp);
 *	This function is used to set or query state related to XDP on the
 *	netdevice. See definition of enum xdp_netdev_command for details.
 * int (*ndo_xdp_xmit)(struct net_device *dev, int n, struct xdp_frame **xdp,
 *			u32 flags);
 *	This function is used to submit @n XDP packets for transmit on a
 *	netdevice. Returns number of frames successfully transmitted, frames
 *	that got dropped are freed/returned via xdp_return_frame().
 *	Returns negative number, means general error invoking ndo, meaning
 *	no frames were xmit'ed and core-caller will free all frames.
 * void (*ndo_xdp_flush)(struct net_device *dev);
 *	This function is used to inform the driver to flush a paticular
 *	xpd tx queue. Must be called on same CPU as xdp_xmit.
 */
struct net_device_ops_extended {
	int			(*ndo_set_vf_trust)(struct net_device *dev,
						    int vf, bool setting);
	void*			(*ndo_dfwd_add_station)(struct net_device *pdev,
							struct net_device *dev);
	void			(*ndo_dfwd_del_station)(struct net_device *pdev,
							void *priv);
	int			(*ndo_set_tx_maxrate)(struct net_device *dev,
						      int queue_index,
						      u32 maxrate);
	void			(*ndo_set_rx_headroom)(struct net_device *dev,
						       int needed_headroom);
	int			(*ndo_set_vf_guid)(struct net_device *dev,
						   int vf, u64 guid,
						   int guid_type);
	int			(*ndo_fdb_dump_rh73)(struct sk_buff *skb,
						struct netlink_callback *cb,
						struct net_device *dev,
						struct net_device *filter_dev,
						int idx);
	int			(*ndo_get_phys_port_name)(struct net_device *dev,
							  char *name, size_t len);
	int			(*ndo_change_proto_down)(struct net_device *dev,
							 bool proto_down);
	void			(*ndo_udp_tunnel_add)(struct net_device *dev,
						      struct udp_tunnel_info *ti);
	void			(*ndo_udp_tunnel_del)(struct net_device *dev,
						      struct udp_tunnel_info *ti);
	int			(*ndo_neigh_construct)(struct net_device *dev,
						       struct neighbour *n);
	void			(*ndo_neigh_destroy)(struct net_device *dev,
						     struct neighbour *n);
	int			(*ndo_set_vf_vlan)(struct net_device *dev,
						   int vf, u16 vlan, u8 qos,
						   __be16 proto);
	int			(*ndo_fdb_dump)(struct sk_buff *skb,
						struct netlink_callback *cb,
						struct net_device *dev,
						struct net_device *filter_dev,
						int *idx);
	bool			(*ndo_has_offload_stats)(const struct net_device *dev, int attr_id);
	int			(*ndo_get_offload_stats)(int attr_id,
							 const struct net_device *dev,
							 void *attr_data);
	int			(*ndo_change_mtu)(struct net_device *dev,
						  int new_mtu);
	/*
	 * RHEL: Note that this callback is not part of kABI and its prototype
	 * and semantic can be changed across releases.
	 */
	int			(*ndo_setup_tc_rh)(struct net_device *dev,
						   enum tc_setup_type type,
						   void *type_data);
	int			(*ndo_xdp)(struct net_device *dev,
						  struct netdev_xdp *xdp);
	int			(*ndo_xdp_xmit)(struct net_device *dev, int n,
						struct xdp_frame **xdp,
						u32 flags);
	void                    (*ndo_xdp_flush)(struct net_device *dev);
	int                     (*ndo_bpf)(struct net_device *dev,
					   struct netdev_bpf *bpf);
	int			(*ndo_xsk_async_xmit)(struct net_device *dev,
						      u32 queue_id);
};

/* These structures hold the attributes of xdp state that are being passed
 * to the netdevice through the xdp op.
 */
enum xdp_netdev_command {
	/* Set or clear a bpf program used in the earliest stages of packet
	 * rx. The prog will have been loaded as BPF_PROG_TYPE_XDP. The callee
	 * is responsible for calling bpf_prog_put on any old progs that are
	 * stored. In case of error, the callee need not release the new prog
	 * reference, but on success it takes ownership and must bpf_prog_put
	 * when it is no longer used.
	 */
	XDP_SETUP_PROG,
	XDP_QUERY_PROG,
	XDP_QUERY_XSK_UMEM,
	XDP_SETUP_XSK_UMEM,
};

struct xdp_umem;

struct netdev_xdp {
	enum xdp_netdev_command command;
	union {
		/* XDP_SETUP_PROG */
		struct bpf_prog *prog;
		/* XDP_QUERY_PROG */
		struct {
			u32 prog_id;
		};
		/* XDP_SETUP_XSK_UMEM */
		struct {
			struct xdp_umem *umem;
			u16 queue_id;
		} xsk;
	};
};

/*
 * 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,
 *                         void *accel_priv, select_queue_fallback_t fallback);
 *	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.
 *
 * void (*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, __be16 proto, u16t vid);
 *	If device support VLAN filtering 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 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_rate)(struct net_device *dev, int vf, int min_tx_rate,
 *			  int max_tx_rate);
 * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);
 * int (*ndo_set_vf_trust)(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_link_state)(struct net_device *dev, int vf, int link_state);
 * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
 *			  struct nlattr *port[]);
 *
 *      Enable or disable the VF ability to query its RSS Redirection Table and
 *      Hash Key. This is needed since on some devices VF share this information
 *      with PF and querying it may adduce a theoretical security risk.
 * int (*ndo_set_vf_rss_query_en)(struct net_device *dev, int vf, bool setting);
 * 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).
 * 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.
 *
 * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[],
 *		      struct net_device *dev,
 *		      const unsigned char *addr, u16 vid, u16 flags)
 *	Adds an FDB entry to dev for addr.
 * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
 *		      struct net_device *dev,
 *		      const unsigned char *addr, u16 vid)
 *	Deletes the FDB entry from dev coresponding to addr.
 * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh,
 *			     u16 flags)
 * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq,
 *			     struct net_device *dev, u32 filter_mask,
 *			     int nlflags)
 * int (*ndo_bridge_dellink)(struct net_device *dev, struct nlmsghdr *nlh,
 *			     u16 flags);
 *
 * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier);
 *	Called to change device carrier. Soft-devices (like dummy, team, etc)
 *	which do not represent real hardware may define this to allow their
 *	userspace components to manage their virtual carrier state. Devices
 *	that determine carrier state from physical hardware properties (eg
 *	network cables) or protocol-dependent mechanisms (eg
 *	USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
 *
 * int (*ndo_get_phys_port_id)(struct net_device *dev,
 *			       struct netdev_phys_item_id *ppid);
 *	Called to get ID of physical port of this device. If driver does
 *	not implement this, it is assumed that the hw is not able to have
 *	multiple net devices on single physical port.
 *
 * void (*ndo_add_vxlan_port)(struct  net_device *dev,
 *			      sa_family_t sa_family, __be16 port);
 *	Called by vxlan to notiy a driver about the UDP port and socket
 *	address family that vxlan is listnening to. It is called only when
 *	a new port starts listening. The operation is protected by the
 *	vxlan_net->sock_lock.
 *
 * void (*ndo_add_geneve_port)(struct net_device *dev,
 *			      sa_family_t sa_family, __be16 port);
 *	Called by geneve to notify a driver about the UDP port and socket
 *	address family that geneve is listnening to. It is called only when
 *	a new port starts listening. The operation is protected by the
 *	geneve_net->sock_lock.
 *
 * void (*ndo_del_geneve_port)(struct net_device *dev,
 *			      sa_family_t sa_family, __be16 port);
 *	Called by geneve to notify the driver about a UDP port and socket
 *	address family that geneve is not listening to anymore. The operation
 *	is protected by the geneve_net->sock_lock.
 *
 * void (*ndo_del_vxlan_port)(struct  net_device *dev,
 *			      sa_family_t sa_family, __be16 port);
 *	Called by vxlan to notify the driver about a UDP port and socket
 *	address family that vxlan is not listening to anymore. The operation
 *	is protected by the vxlan_net->sock_lock.
 *
 * int (*ndo_get_iflink)(const struct net_device *dev);
 *	Called to get the iflink value of this device.
 *
 * netdev_features_t (*ndo_features_check) (struct sk_buff *skb,
 *					    struct net_device *dev
 *					    netdev_features_t features);
 *	Called by core transmit path to determine if device is capable of
 *	performing offload operations on a given packet. This is to give
 *	the device an opportunity to implement any restrictions that cannot
 *	be otherwise expressed by feature flags. The check is called with
 *	the set of features that the stack has calculated and it returns
 *	those the driver believes to be appropriate.
 * int (*ndo_fill_metadata_dst)(struct net_device *dev, struct sk_buff *skb);
 *	This function is used to get egress tunnel information for given skb.
 *	This is useful for retrieving outer tunnel header parameters while
 *	sampling packet.
 */
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);
	RH_KABI_REPLACE(u16	(*ndo_select_queue)(struct net_device *dev,
						    struct sk_buff *skb),
			u16	(*ndo_select_queue)(struct net_device *dev,
						    struct sk_buff *skb,
						    void *accel_priv,
						    select_queue_fallback_t fallback))
	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);
	RH_KABI_RENAME(int	(*ndo_change_mtu),
		       int	(*ndo_change_mtu_rh74))(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);

	RH_KABI_REPLACE(
		struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
							     struct rtnl_link_stats64 *storage),
		void		(*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,
						       __be16 proto, u16 vid);
	int			(*ndo_vlan_rx_kill_vid)(struct net_device *dev,
						        __be16 proto, u16 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,
						     gfp_t gfp);
	void			(*ndo_netpoll_cleanup)(struct net_device *dev);
#endif
#ifdef CONFIG_NET_RX_BUSY_POLL
	int			(*ndo_busy_poll)(struct napi_struct *dev);
#endif
	int			(*ndo_set_vf_mac)(struct net_device *dev,
						  int queue, u8 *mac);
	RH_KABI_RENAME(int      (*ndo_set_vf_vlan),
		       int      (*ndo_set_vf_vlan_rh73))(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_link_state)(struct net_device *dev,
							 int vf, int link_state);
	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);
	RH_KABI_RENAME(int	(*ndo_setup_tc),
		       int	(*ndo_setup_tc_rh72))(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);
	RH_KABI_RENAME(int	(*ndo_neigh_construct),
		       int	(*ndo_neigh_construct_rh73))(struct neighbour *n);
	RH_KABI_RENAME(void	(*ndo_neigh_destroy),
		       void	(*ndo_neigh_destroy_rh73))(struct neighbour *n);

	RH_KABI_RENAME(int	(*ndo_fdb_add),
		       int	(*ndo_fdb_add_rh72))(struct ndmsg *ndm,
					       struct nlattr *tb[],
					       struct net_device *dev,
					       const unsigned char *addr,
					       u16 flags);
	RH_KABI_REPLACE(int	(*ndo_fdb_del)(struct ndmsg *ndm,
					       struct nlattr *tb[],
					       struct net_device *dev,
					       const unsigned char *addr),
			int	(*ndo_fdb_del)(struct ndmsg *ndm,
					       struct nlattr *tb[],
					       struct net_device *dev,
					       const unsigned char *addr,
					       u16 vid))
	RH_KABI_RENAME(int	(*ndo_fdb_dump),
		       int	(*ndo_fdb_dump_rh72))(struct sk_buff *skb,
						struct netlink_callback *cb,
						struct net_device *dev,
						int idx);
	RH_KABI_REPLACE(int	(*ndo_bridge_setlink)(struct net_device *dev,
						      struct nlmsghdr *nlh),
			int	(*ndo_bridge_setlink)(struct net_device *dev,
						      struct nlmsghdr *nlh,
						      u16 flags))
	RH_KABI_REPLACE(int	(*ndo_bridge_getlink)(struct sk_buff *skb,
						      u32 pid, u32 seq,
						      struct net_device *dev,
						      u32 filter_mask),
			int	(*ndo_bridge_getlink)(struct sk_buff *skb,
						      u32 pid, u32 seq,
						      struct net_device *dev,
						      u32 filter_mask,
						      int nlflags))
	RH_KABI_REPLACE(int	(*ndo_bridge_dellink)(struct net_device *dev,
						      struct nlmsghdr *nlh),
			int	(*ndo_bridge_dellink)(struct net_device *dev,
						      struct nlmsghdr *nlh,
						      u16 flags))
	int			(*ndo_change_carrier)(struct net_device *dev,
						      bool new_carrier);
	int			(*ndo_get_phys_port_id)(struct net_device *dev,
							struct netdev_phys_item_id *ppid);
	void			(*ndo_add_vxlan_port)(struct  net_device *dev,
						      sa_family_t sa_family,
						      __be16 port);
	void			(*ndo_del_vxlan_port)(struct  net_device *dev,
						      sa_family_t sa_family,
						      __be16 port);

	/* RHEL SPECIFIC
	 *
	 * The following padding has been inserted before ABI freeze to
	 * allow extending the structure while preserve ABI. Feel free
	 * to replace reserved slots with required structure field
	 * additions of your backport.
	 */
	RH_KABI_USE_P(1, int	(*ndo_get_iflink)(const struct net_device *dev))
	RH_KABI_USE_P(2, netdev_features_t
				(*ndo_features_check)(struct sk_buff *skb,
						      struct net_device *dev,
						      netdev_features_t features))
	RH_KABI_USE_P(3, int	(*ndo_set_vf_rate)(struct net_device *dev,
						   int vf, int min_tx_rate,
						   int max_tx_rate))
	RH_KABI_USE_P(4, int	(*ndo_get_vf_stats)(struct net_device *dev,
						    int vf,
						    struct ifla_vf_stats
						    *vf_stats))
	RH_KABI_USE_P(5, int    (*ndo_set_vf_rss_query_en)(struct net_device *dev,
							   int vf, bool setting))

	RH_KABI_USE_P(6, int	(*ndo_fdb_add)(struct ndmsg *ndm,
					       struct nlattr *tb[],
					       struct net_device *dev,
					       const unsigned char *addr,
					       u16 vid,
					       u16 flags))
	RH_KABI_USE_P(7,int	(*ndo_setup_tc_rh74)(struct net_device *dev,
						     u32 handle,
						     __be16 protocol,
						     struct tc_to_netdev_rh74 *tc))
	RH_KABI_USE_P(8, int	(*ndo_fill_metadata_dst)(struct net_device *dev,
						       struct sk_buff *skb))
	RH_KABI_USE_P(9, void	(*ndo_add_geneve_port)(struct  net_device *dev,
						       sa_family_t sa_family,
						       __be16 port))
	RH_KABI_USE_P(10, void	(*ndo_del_geneve_port)(struct  net_device *dev,
						       sa_family_t sa_family,
						       __be16 port))
	RH_KABI_RESERVE_P(11)
	RH_KABI_RESERVE_P(12)
	RH_KABI_RESERVE_P(13)
	RH_KABI_RESERVE_P(14)
	RH_KABI_RESERVE_P(15)
	RH_KABI_USE_P(16, size_t ndo_size)
	/* RHEL: put all new non-performance critical ndo's into
	 * net_device_ops_extended. The reserved slots above can be used
	 * only for performance critical operations.
	 * Drivers may access the extended fields directly from
	 * net_device_ops, if they allocated the net_device_ops structure
	 * themselves (usually statically). The kernel core and drivers
	 * using others' net_device_ops must access the extended fields
	 * using the get_ndo_ext macro.
	 */
	RH_KABI_EXTEND(struct net_device_ops_extended extended)
};

#define get_ndo_ext(ops, field)		({				\
	const struct net_device_ops *__ops = (ops);			\
	size_t __off = offsetof(struct net_device_ops, extended.field);	\
	__ops->ndo_size > __off ? __ops->extended.field : NULL;		\
	})

/**
 * enum net_device_priv_flags - &struct net_device priv_flags
 *
 * These are the &struct net_device, they are only set internally
 * by drivers and used in the kernel. These flags are invisible to
 * userspace, this means that the order of these flags can change
 * during any kernel release.
 *
 * You should have a pretty good reason to be extending these flags.
 *
 * @IFF_802_1Q_VLAN: 802.1Q VLAN device
 * @IFF_EBRIDGE: Ethernet bridging device
 * @IFF_SLAVE_INACTIVE: bonding slave not the curr. active
 * @IFF_MASTER_8023AD: bonding master, 802.3ad
 * @IFF_MASTER_ALB: bonding master, balance-alb
 * @IFF_BONDING: bonding master or slave
 * @IFF_SLAVE_NEEDARP: need ARPs for validation
 * @IFF_ISATAP: ISATAP interface (RFC4214)
 * @IFF_MASTER_ARPMON: bonding master, ARP mon in use
 * @IFF_WAN_HDLC: WAN HDLC device
 * @IFF_XMIT_DST_RELEASE: dev_hard_start_xmit() is allowed to
 *	release skb->dst
 * @IFF_DONT_BRIDGE: disallow bridging this ether dev
 * @IFF_DISABLE_NETPOLL: disable netpoll at run-time
 * @IFF_MACVLAN_PORT: device used as macvlan port
 * @IFF_BRIDGE_PORT: device used as bridge port
 * @IFF_OVS_DATAPATH: device used as Open vSwitch datapath port
 * @IFF_TX_SKB_SHARING: The interface supports sharing skbs on transmit
 * @IFF_UNICAST_FLT: Supports unicast filtering
 * @IFF_TEAM_PORT: device used as team port
 * @IFF_SUPP_NOFCS: device supports sending custom FCS
 * @IFF_LIVE_ADDR_CHANGE: device supports hardware address
 *	change when it's running
 * @IFF_MACVLAN: Macvlan device
 * @IFF_NO_QUEUE: device can run without qdisc attached
 * @IFF_OPENVSWITCH: device is a Open vSwitch master
 * @IFF_TEAM: device is a team device
 * @IFF_RXFH_CONFIGURED: device has had Rx Flow indirection table configured
 * @IFF_PHONY_HEADROOM: the headroom value is controlled by an external
 *	entity (i.e. the master device for bridged veth)
 * @IFF_MACSEC: device is a MACsec device
 * @IFF_FAILOVER: device is a failover master device
 * @IFF_FAILOVER_SLAVE: device is lower dev of a failover master device
 */
enum netdev_priv_flags {
	IFF_802_1Q_VLAN			= 1<<0,
	IFF_EBRIDGE			= 1<<1,
	IFF_SLAVE_INACTIVE		= 1<<2,
	IFF_MASTER_8023AD		= 1<<3,
	IFF_MASTER_ALB			= 1<<4,
	IFF_BONDING			= 1<<5,
	IFF_SLAVE_NEEDARP		= 1<<6,
	IFF_ISATAP			= 1<<7,
	IFF_MASTER_ARPMON		= 1<<8,
	IFF_WAN_HDLC			= 1<<9,
	IFF_XMIT_DST_RELEASE		= 1<<10,
	IFF_DONT_BRIDGE			= 1<<11,
	IFF_DISABLE_NETPOLL		= 1<<12,
	IFF_MACVLAN_PORT		= 1<<13,
	IFF_BRIDGE_PORT			= 1<<14,
	IFF_OVS_DATAPATH		= 1<<15,
	IFF_TX_SKB_SHARING		= 1<<16,
	IFF_UNICAST_FLT			= 1<<17,
	IFF_TEAM_PORT			= 1<<18,
	IFF_SUPP_NOFCS			= 1<<19,
	IFF_LIVE_ADDR_CHANGE		= 1<<20,
	IFF_MACVLAN			= 1<<21,
	IFF_XMIT_DST_RELEASE_PERM	= 1<<22,
	IFF_OPENVSWITCH			= 1<<23,
	IFF_TEAM			= 1<<24,
	IFF_RXFH_CONFIGURED		= 1<<25,
	IFF_NO_QUEUE			= 1<<26,
	IFF_PHONY_HEADROOM		= 1<<27,
	IFF_MACSEC			= 1<<28,
	IFF_FAILOVER			= 1<<27,
	IFF_FAILOVER_SLAVE		= 1<<28,
};

#define IFF_802_1Q_VLAN			IFF_802_1Q_VLAN
#define IFF_EBRIDGE			IFF_EBRIDGE
#define IFF_SLAVE_INACTIVE		IFF_SLAVE_INACTIVE
#define IFF_MASTER_8023AD		IFF_MASTER_8023AD
#define IFF_MASTER_ALB			IFF_MASTER_ALB
#define IFF_BONDING			IFF_BONDING
#define IFF_SLAVE_NEEDARP		IFF_SLAVE_NEEDARP
#define IFF_ISATAP			IFF_ISATAP
#define IFF_MASTER_ARPMON		IFF_MASTER_ARPMON
#define IFF_WAN_HDLC			IFF_WAN_HDLC
#define IFF_XMIT_DST_RELEASE		IFF_XMIT_DST_RELEASE
#define IFF_DONT_BRIDGE			IFF_DONT_BRIDGE
#define IFF_DISABLE_NETPOLL		IFF_DISABLE_NETPOLL
#define IFF_MACVLAN_PORT		IFF_MACVLAN_PORT
#define IFF_BRIDGE_PORT			IFF_BRIDGE_PORT
#define IFF_OVS_DATAPATH		IFF_OVS_DATAPATH
#define IFF_TX_SKB_SHARING		IFF_TX_SKB_SHARING
#define IFF_UNICAST_FLT			IFF_UNICAST_FLT
#define IFF_TEAM_PORT			IFF_TEAM_PORT
#define IFF_SUPP_NOFCS			IFF_SUPP_NOFCS
#define IFF_LIVE_ADDR_CHANGE		IFF_LIVE_ADDR_CHANGE
#define IFF_MACVLAN			IFF_MACVLAN
#define IFF_XMIT_DST_RELEASE_PERM	IFF_XMIT_DST_RELEASE_PERM
#define IFF_NO_QUEUE			IFF_NO_QUEUE
#define IFF_OPENVSWITCH			IFF_OPENVSWITCH
#define IFF_TEAM			IFF_TEAM
#define IFF_RXFH_CONFIGURED		IFF_RXFH_CONFIGURED
#define IFF_MACSEC			IFF_MACSEC
#define IFF_FAILOVER			IFF_FAILOVER
#define IFF_FAILOVER_SLAVE		IFF_FAILOVER_SLAVE

/*
 *	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.
 *
 *	@proto_down:	protocol port state information can be sent to the
 *			switch driver and used to set the phys state of the
 *			switch port.
 *
 *	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];

	/* device name hash chain, please keep it close to name[] */
	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;
	struct list_head	upper_dev_list; /* List of upper devices */


	/* 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;
	/* mask of features inherited by encapsulating devices
	 * This field indicates what encapsulation offloads
	 * the hardware is capable of doing, and drivers will
	 * need to set them appropriately.
	 */
	netdev_features_t	hw_enc_features;
	/* mask of fetures inheritable by MPLS */
	netdev_features_t	mpls_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.
					     * See if.h for definitions. */
	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		*/

	/* Note : dev->mtu is often read without holding a lock.
	 * Writers usually hold RTNL.
	 * It is recommended to use READ_ONCE() to annotate the reads,
	 * and to use WRITE_ONCE() to annotate the writes.
	 */
	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		neigh_priv_len;
	unsigned short          dev_id;		/* for shared network cards */

	RH_KABI_FILL_HOLE(unsigned short dev_port) /* Used to differentiate
						 * devices that share the same
						 * function
						 */
	spinlock_t		addr_list_lock;
	struct netdev_hw_addr_list	uc;	/* Unicast mac addresses */
	struct netdev_hw_addr_list	mc;	/* Multicast mac addresses */
	struct netdev_hw_addr_list	dev_addrs; /* list of device
						    * hw addresses
						    */
#ifdef CONFIG_SYSFS
	struct kset		*queues_kset;
#endif

	bool			uc_promisc;
	RH_KABI_FILL_HOLE(bool	proto_down)
	/* RH_KABI: 2 bytes hole remain here */
	unsigned int		promiscuity;
	unsigned int		allmulti;

	/* Stats to monitor carrier on<->off transitions */
	RH_KABI_FILL_HOLE(atomic_t	carrier_changes)

	/* 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			*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())
 */
	RH_KABI_DEPRECATE(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.
						 */

	/* Interface address info used in eth_type_trans() */
	unsigned char		*dev_addr;	/* hw address, (before bcast
						   because most packets are
						   unicast) */


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

#endif

	rx_handler_func_t __rcu	*rx_handler;
	void __rcu		*rx_handler_data;

	struct netdev_queue __rcu *ingress_queue;
	unsigned char		broadcast[MAX_ADDR_LEN];	/* hw bcast add	*/

#ifdef CONFIG_NET_CLS_ACT
	RH_KABI_FILL_HOLE(struct mini_Qdisc __rcu *miniq_ingress)
#endif
	/* Hole: 16 bytes remain */

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

	/* These may be needed for future network-power-down code. */

	RH_KABI_DEPRECATE(unsigned long, trans_start)

	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 __rcu	*npinfo;
#endif

	/* Network namespace this network device is inside */
	possible_net_t			nd_net;

	/* mid-layer private */
	union {
		void				*ml_priv;
		struct pcpu_lstats __percpu	*lstats; /* loopback stats */
		RH_KABI_REPLACE(struct pcpu_tstats __percpu	*tstats, struct pcpu_sw_netstats __percpu	*tstats)
		struct pcpu_dstats __percpu	*dstats; /* dummy stats */
		struct pcpu_vstats __percpu	*vstats; /* veth stats */
	};
	/* GARP */
	struct garp_port __rcu	*garp_port;
	/* MRP */
	struct mrp_port __rcu	*mrp_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;
#define GSO_MAX_SEGS		65535
	u16			gso_max_segs;

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

	struct lock_class_key *qdisc_tx_busylock;

	/* group the device belongs to */
	int group;

	/* RHEL: e1000e was the only in-tree driver that used this */
	RH_KABI_DEPRECATE(struct pm_qos_request, pm_qos_req)

	/* RHEL SPECIFIC
	 *
	 * The following padding has been inserted before ABI freeze to
	 * allow extending the structure while preserve ABI. Feel free
	 * to replace reserved slots with required structure field
	 * additions of your backport.
	 */
	RH_KABI_USE_P(1, unsigned long	gro_flush_timeout)
	RH_KABI_USE_P(2, atomic_long_t  rx_nohandler) /* inactive slave drops */
#ifndef __GENKSYMS__
	struct list_head	lower_dev_list;

	/* directly linked devices, like slaves for bonding */
	struct {
		struct list_head upper;
		struct list_head lower;
	} adj_list;

	/*
	 * RHEL ONLY: upstream has a matching all_adj_list that replaces
	 * upper_dev_list and lower_dev_list directly, but making that
	 * replacement would be a kabi nightmare, even more than we've
	 * already got right here.
	 */
#else
	/*
	 * struct list_head contains two pointers, no easy way to make use of
	 * two reserved pointers in a single RH_KABI_* macro, so we're going
	 * old school and using __GENKSYMS wrappers directly here.
	 */
	RH_KABI_USE_P(3, lower_dev_list.prev)
	RH_KABI_USE_P(4, lower_dev_list.next)
	RH_KABI_USE_P(5, adj_list.upper.prev)
	RH_KABI_USE_P(6, adj_list.upper.next)
	RH_KABI_USE_P(7, adj_list.lower.prev)
	RH_KABI_USE_P(8, adj_list.lower.next)
#endif
	RH_KABI_USE_P(9, const struct forwarding_accel_ops *fwd_ops)
	RH_KABI_USE_P(10, const struct dcbnl_rtnl_ops_ext *dcbnl_ops_ext)
	RH_KABI_USE_P(11, struct wpan_dev *ieee802154_ptr)
#ifndef __GENKSYMS__
	/*
	 * We can't use the RH_KABI_* helpers cleanly here, since
	 * list_head requires two reserved fields.
	 * Mark them as used anyway.
	 */
	struct list_head	close_list;
#else
	RH_KABI_USE_P(12, close_list.prev)
	RH_KABI_USE_P(13, close_list.next)
#endif
	RH_KABI_USE_P(14, const struct switchdev_ops *switchdev_ops)
	RH_KABI_USE_P(15, netdev_features_t gso_partial_features)
	RH_KABI_USE_P(16, struct net_device_extended *extended)
};

/* RHEL specific: Extension of struct net_device. Place new fields at the
 * end of this struct. Be careful, we're not guarded by the automatic kABI
 * checks, yet any changes here are kABI protected.
 * This means only appends to this structure are allowed. Changes are
 * generally disallowed with the exception of field renames (but not type
 * changes nor any shuffling!).
 *
 *	@ndisc_ops:	Includes callbacks for different IPv6 neighbour
 *			discovery handling. Necessary for e.g. 6LoWPAN.
 *
 *	@min_mtu:	Interface Minimum MTU value
 *	@max_mtu:	Interface Maximum MTU value
 *	RHEL note: These bounds are only checked when the old
 *		.ndo_change_mtu_rh74 handler is *not* provided.
 *		See dev_set_mtu() in net/core/dev.c
 *	@needs_free_netdev:	Should unregister perform free_netdev?
 *	@priv_destructor:	Called from unregister
 */
struct net_device_extended {
#if IS_ENABLED(CONFIG_IPV6)
	const struct ndisc_ops *ndisc_ops;
#endif
	unsigned int		min_mtu;
	unsigned int		max_mtu;
	struct list_head	ptype_all;
	struct list_head	ptype_specific;

	bool needs_free_netdev;
	void (*priv_destructor)(struct net_device *dev);
#ifdef CONFIG_NET_CLS_ACT
	struct mini_Qdisc __rcu	*miniq_egress;
#endif
#ifdef CONFIG_NET_SCHED
	DECLARE_HASHTABLE	(qdisc_hash, 4);
#endif
};

#define to_net_dev(d) container_of(d, struct net_device, dev)

#define	NETDEV_ALIGN		32

static inline
bool __rh_has_ndo_setup_tc(const struct net_device *dev)
{
	const struct net_device_ops *ops = dev->netdev_ops;

	return (get_ndo_ext(ops, ndo_setup_tc_rh) ||
		ops->ndo_setup_tc_rh74 ||
		ops->ndo_setup_tc_rh72) ? true : false;
}

int __rh_call_ndo_setup_tc(struct net_device *dev, u32 handle,
			   enum tc_setup_type type, void *type_data);

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

int netdev_txq_to_tc(struct net_device *dev, unsigned int txq);
void netdev_reset_tc(struct net_device *dev);
int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset);
int netdev_set_num_tc(struct net_device *dev, u8 num_tc);

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 struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
						    const struct sk_buff *skb)
{
	return netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
}

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

#define netdev_lockdep_set_classes(dev)				\
{								\
	static struct lock_class_key qdisc_tx_busylock_key;	\
	static struct lock_class_key qdisc_xmit_lock_key;	\
	static struct lock_class_key dev_addr_list_lock_key;	\
	unsigned int i;						\
								\
	(dev)->qdisc_tx_busylock = &qdisc_tx_busylock_key;	\
	lockdep_set_class(&(dev)->addr_list_lock,		\
			  &dev_addr_list_lock_key); 		\
	for (i = 0; i < (dev)->num_tx_queues; i++)		\
		lockdep_set_class(&(dev)->_tx[i]._xmit_lock,	\
				  &qdisc_xmit_lock_key);	\
}

struct netdev_queue *netdev_pick_tx(struct net_device *dev,
				    struct sk_buff *skb,
				    void *accel_priv);

/* returns the headroom that the master device needs to take in account
 * when forwarding to this dev
 */
static inline unsigned netdev_get_fwd_headroom(struct net_device *dev)
{
	return dev->priv_flags & IFF_PHONY_HEADROOM ? 0 : dev->needed_headroom;
}

static inline void netdev_set_rx_headroom(struct net_device *dev, int new_hr)
{
	if (get_ndo_ext(dev->netdev_ops, ndo_set_rx_headroom))
		get_ndo_ext(dev->netdev_ops, ndo_set_rx_headroom)(dev, new_hr);
}

/* set the device rx headroom to the dev's default */
static inline void netdev_reset_rx_headroom(struct net_device *dev)
{
	netdev_set_rx_headroom(dev, -1);
}

/*
 * 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)
{
	write_pnet(&dev->nd_net, net);
}

static inline bool netdev_uses_dsa(struct net_device *dev)
{
#ifdef CONFIG_NET_DSA
	return dev->dsa_ptr != NULL;
#else
	return false;
#endif
}

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

/* Default NAPI poll() weight
 * Device drivers are strongly advised to not use bigger value
 */
#define NAPI_POLL_WEIGHT 64

void __netif_napi_add(struct net_device *dev, struct napi_struct *napi,
		      int (*poll)(struct napi_struct *, int), int weight,
		      size_t size);

/**
 *	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.
 */
static inline void _netif_napi_add(struct net_device *dev,
				   struct napi_struct *napi,
				   int (*poll)(struct napi_struct *, int),
				   int weight)
{
	__netif_napi_add(dev, napi, poll, weight, sizeof(struct napi_struct));
}

/* RHEL has netif_napi_add in KABI so we need to keep it for binary
 * modules. Another reason is that older binary modules uses non-extended
 * napi_struct. Newly compiled modules will use inlined function that uses
 * current (extended) napi_struct. */
void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
		    int (*poll)(struct napi_struct *, int), int weight);
#define netif_napi_add _netif_napi_add

/**
 *	netif_tx_napi_add - initialize a napi context
 *	@dev:  network device
 *	@napi: napi context
 *	@poll: polling function
 *	@weight: default weight
 *
 * This variant of netif_napi_add() should be used from drivers using NAPI
 * to exclusively poll a TX queue.
 * This will avoid we add it into napi_hash[], thus polluting this hash table.
 */
static inline void netif_tx_napi_add(struct net_device *dev,
				     struct napi_struct *napi,
				     int (*poll)(struct napi_struct *, int),
				     int weight)
{
	set_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state);
	netif_napi_add(dev, napi, poll, 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 cannot be merged with the new skb. */
	u16	flush;

	/* Save the IP ID here and check when we get to the transport layer */
	u16	flush_id;

	/* Number of segments aggregated. */
	u16	count;

	/* Start offset for remote checksum offload */
	u16	gro_remcsum_start;

	/* jiffies when first packet was created/queued */
	unsigned long age;

	/* Used in ipv6_gro_receive() and foo-over-udp */
	u16	proto;

	/* Used in tunnel GRO receive */
	u8	encap_mark:1;

	/* GRO checksum is valid */
	u8	csum_valid:1;

	/* Number of checksums via CHECKSUM_UNNECESSARY */
	u8	csum_cnt:3;

	/* Used in foo-over-udp, set in udp[46]_gro_receive */
	u8	is_ipv6:1;

	/* Free the skb? */
	u8	free:2;
#define NAPI_GRO_FREE		  1
#define NAPI_GRO_FREE_STOLEN_HEAD 2

	/* This is non-zero if the packet may be of the same flow. */
	u8	same_flow:1;

	/* Number of gro_receive callbacks this packet already went through */
	u8 recursion_counter:4;

	/* Used to determine if flush_id can be ignored */
	u8	is_atomic:1;

	/* 2 bit hole */

	/* used to support CHECKSUM_COMPLETE for tunneling protocols */
	__wsum	csum;

	/* used in skb_gro_receive() slow path */
	struct sk_buff *last;
};

#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)

#define GRO_RECURSION_LIMIT 15
static inline int gro_recursion_inc_test(struct sk_buff *skb)
{
	return ++NAPI_GRO_CB(skb)->recursion_counter == GRO_RECURSION_LIMIT;
}

typedef struct sk_buff **(*gro_receive_t)(struct sk_buff **, struct sk_buff *);
static inline struct sk_buff **call_gro_receive(gro_receive_t cb,
						struct sk_buff **head,
						struct sk_buff *skb)
{
	if (gro_recursion_inc_test(skb)) {
		NAPI_GRO_CB(skb)->flush |= 1;
		return NULL;
	}

	return cb(head, skb);
}

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 *);
	bool			(*id_match)(struct packet_type *ptype,
					    struct sock *sk);
	void			*af_packet_priv;
	struct list_head	list;
	RH_KABI_RESERVE(1)
	RH_KABI_RESERVE(2)
	RH_KABI_RESERVE(3)
	RH_KABI_RESERVE(4)
};

struct offload_callbacks {
	struct sk_buff		*(*gso_segment)(struct sk_buff *skb,
						netdev_features_t features);
	struct sk_buff		**(*gro_receive)(struct sk_buff **head,
						 struct sk_buff *skb);
	int			(*gro_complete)(struct sk_buff *skb, int nhoff);
};

struct packet_offload {
	__be16			 type;	/* This is really htons(ether_type). */
	u16			 priority;
	struct offload_callbacks callbacks;
	struct list_head	 list;
};

struct dsa_device_ops {
	netdev_tx_t (*xmit)(struct sk_buff *skb, struct net_device *dev);
	int (*rcv)(struct sk_buff *skb, struct net_device *dev,
		   struct packet_type *pt, struct net_device *orig_dev);
};


/* often modified stats are per cpu, other are shared (netdev->stats) */
struct pcpu_sw_netstats {
	u64     rx_packets;
	u64     rx_bytes;
	u64     tx_packets;
	u64     tx_bytes;
	struct u64_stats_sync   syncp;
};

#define __netdev_alloc_pcpu_stats(type, gfp)				\
({									\
	typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
	if (pcpu_stats)	{						\
		int __cpu;						\
		for_each_possible_cpu(__cpu) {				\
			typeof(type) *stat;				\
			stat = per_cpu_ptr(pcpu_stats, __cpu);		\
			u64_stats_init(&stat->syncp);			\
		}							\
	}								\
	pcpu_stats;							\
})

#define netdev_alloc_pcpu_stats(type)					\
	__netdev_alloc_pcpu_stats(type, GFP_KERNEL)

enum netdev_lag_tx_type {
	NETDEV_LAG_TX_TYPE_UNKNOWN,
	NETDEV_LAG_TX_TYPE_RANDOM,
	NETDEV_LAG_TX_TYPE_BROADCAST,
	NETDEV_LAG_TX_TYPE_ROUNDROBIN,
	NETDEV_LAG_TX_TYPE_ACTIVEBACKUP,
	NETDEV_LAG_TX_TYPE_HASH,
};

enum netdev_lag_hash {
	NETDEV_LAG_HASH_NONE,
	NETDEV_LAG_HASH_L2,
	NETDEV_LAG_HASH_L34,
	NETDEV_LAG_HASH_L23,
	NETDEV_LAG_HASH_E23,
	NETDEV_LAG_HASH_E34,
	NETDEV_LAG_HASH_UNKNOWN,
};

struct netdev_lag_upper_info {
	enum netdev_lag_tx_type tx_type;
	enum netdev_lag_hash hash_type;
};

struct netdev_lag_lower_state_info {
	u8 link_up : 1,
	   tx_enabled : 1;
};

#include <linux/notifier.h>

/* netdevice notifier chain. Please remember to update netdev_cmd_to_name()
 * and the rtnetlink notification exclusion list in rtnetlink_event() when
 * adding new types.
 */
enum netdev_cmd {
	NETDEV_UP	= 1,	/* For now you can't veto a device up/down */
	NETDEV_DOWN,
	NETDEV_REBOOT,		/* Tell a protocol stack a network interface
				   detected a hardware crash and restarted
				   - we can use this eg to kick tcp sessions
				   once done */
	NETDEV_CHANGE,		/* Notify device state change */
	NETDEV_REGISTER,
	NETDEV_UNREGISTER,
	NETDEV_CHANGEMTU,	/* notify after mtu change happened */
	NETDEV_CHANGEADDR,
	NETDEV_GOING_DOWN,
	NETDEV_CHANGENAME,
	NETDEV_FEAT_CHANGE,
	NETDEV_BONDING_FAILOVER,
	NETDEV_PRE_UP,
	NETDEV_PRE_TYPE_CHANGE,
	NETDEV_POST_TYPE_CHANGE,
	NETDEV_POST_INIT,
	NETDEV_UNREGISTER_FINAL,
	NETDEV_RELEASE,
	NETDEV_NOTIFY_PEERS,
	NETDEV_JOIN,
	NETDEV_CHANGEUPPER,
	NETDEV_RESEND_IGMP,
	NETDEV_PRECHANGEMTU,	/* notify before mtu change happened */
	NETDEV_CHANGEINFODATA,
	NETDEV_BONDING_INFO,
	NETDEV_PRECHANGEUPPER,
	NETDEV_CHANGELOWERSTATE,
	NETDEV_OFFLOAD_PUSH_VXLAN,
	NETDEV_OFFLOAD_PUSH_GENEVE,
	NETDEV_UDP_TUNNEL_PUSH_INFO,
	NETDEV_CHANGE_TX_QUEUE_LEN,
	NETDEV_UDP_TUNNEL_DROP_INFO,
	/* RHEL: New values need to be placed at the end to avoid
	 * re-numbering of existing ones.
	 */
};
const char *netdev_cmd_to_name(enum netdev_cmd cmd);

/* (Un)registration functions for the notifiers that takes
 * 'struct net_device *' as parameter
 */
int register_netdevice_notifier(struct notifier_block *nb);
int unregister_netdevice_notifier(struct notifier_block *nb);

/* (Un)registration functions for the notifiers that takes
 * 'struct netdev_notifier_info *' as parameter
 */
int register_netdevice_notifier_rh(struct notifier_block *nb);
int unregister_netdevice_notifier_rh(struct notifier_block *nb);

struct netdev_notifier_info {
	struct net_device *dev;
};

struct netdev_notifier_info_ext {
	struct netdev_notifier_info info; /* must be first */
	union {
		u32 mtu;
	} ext;
};

struct netdev_notifier_change_info {
	struct netdev_notifier_info info; /* must be first */
	unsigned int flags_changed;
};

struct netdev_notifier_changeupper_info {
	struct netdev_notifier_info info; /* must be first */
	struct net_device *upper_dev; /* new upper dev */
	bool master; /* is upper dev master */
	bool linking; /* is the nofication for link or unlink */
	void *upper_info; /* upper dev info */
};

struct netdev_notifier_changelowerstate_info {
	struct netdev_notifier_info info; /* must be first */
	void *lower_state_info; /* is lower dev state */
};

static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
					     struct net_device *dev)
{
	info->dev = dev;
}

static inline struct net_device *
netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
{
	return info->dev;
}

int call_netdevice_notifiers_info(unsigned long val, struct net_device *dev,
				  struct netdev_notifier_info *info);
int call_netdevice_notifiers(unsigned long val, struct net_device *dev);


extern rwlock_t				dev_base_lock;		/* Device list lock */

extern seqcount_t	devnet_rename_seq;	/* Device rename seq */


#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 for_each_netdev_in_bond_rcu(bond, slave)	\
		for_each_netdev_rcu(&init_net, slave)	\
			if (netdev_master_upper_dev_get_rcu(slave) == bond)
#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);
}

int netdev_boot_setup_check(struct net_device *dev);
unsigned long netdev_boot_base(const char *prefix, int unit);
struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
				       const char *hwaddr);
struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
void dev_add_pack(struct packet_type *pt);
void dev_remove_pack(struct packet_type *pt);
void __dev_remove_pack(struct packet_type *pt);
void dev_add_offload(struct packet_offload *po);
void dev_remove_offload(struct packet_offload *po);
void __dev_remove_offload(struct packet_offload *po);

int dev_get_iflink(const struct net_device *dev);
int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb);
struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
				      unsigned short mask);
struct net_device *dev_get_by_name(struct net *net, const char *name);
struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
struct net_device *__dev_get_by_name(struct net *net, const char *name);
int dev_alloc_name(struct net_device *dev, const char *name);
int dev_open(struct net_device *dev);
int dev_close(struct net_device *dev);
void dev_disable_lro(struct net_device *dev);
int dev_loopback_xmit(struct sock *sk, struct sk_buff *newskb);
int dev_queue_xmit_sk(struct sock *sk, struct sk_buff *skb);
int dev_queue_xmit(struct sk_buff *skb);
int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv);
int register_netdevice(struct net_device *dev);
void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
void unregister_netdevice_many(struct list_head *head);
static inline void unregister_netdevice(struct net_device *dev)
{
	unregister_netdevice_queue(dev, NULL);
}

int netdev_refcnt_read(const struct net_device *dev);
void free_netdev(struct net_device *dev);
void netdev_freemem(struct net_device *dev);
void synchronize_net(void);
int init_dummy_netdev(struct net_device *dev);

DECLARE_PER_CPU(int, xmit_recursion);
static inline int dev_recursion_level(void)
{
	return this_cpu_read(xmit_recursion);
}

struct net_device *dev_get_by_index(struct net *net, int ifindex);
struct net_device *__dev_get_by_index(struct net *net, int ifindex);
struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
struct net_device *dev_get_by_napi_id(unsigned int napi_id);
int netdev_get_name(struct net *net, char *name, int ifindex);
int dev_restart(struct net_device *dev);
#ifdef CONFIG_NETPOLL_TRAP
int netpoll_trap(void);
#endif
int skb_gro_receive(struct sk_buff **head, 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_frag0_invalidate(struct sk_buff *skb)
{
	NAPI_GRO_CB(skb)->frag0 = NULL;
	NAPI_GRO_CB(skb)->frag0_len = 0;
}

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;

	skb_gro_frag0_invalidate(skb);
	return skb->data + offset;
}

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 void skb_gro_postpull_rcsum(struct sk_buff *skb,
					const void *start, unsigned int len)
{
	if (NAPI_GRO_CB(skb)->csum_valid)
		NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
						  csum_partial(start, len, 0));
}

/* GRO checksum functions. These are logical equivalents of the normal
 * checksum functions (in skbuff.h) except that they operate on the GRO
 * offsets and fields in sk_buff.
 */

__sum16 __skb_gro_checksum_complete(struct sk_buff *skb);

static inline bool skb_at_gro_remcsum_start(struct sk_buff *skb)
{
	return (NAPI_GRO_CB(skb)->gro_remcsum_start == skb_gro_offset(skb));
}

static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
						      bool zero_okay,
						      __sum16 check)
{
	return ((skb->ip_summed != CHECKSUM_PARTIAL ||
		skb_checksum_start_offset(skb) <
		 skb_gro_offset(skb)) &&
		!skb_at_gro_remcsum_start(skb) &&
		NAPI_GRO_CB(skb)->csum_cnt == 0 &&
		(!zero_okay || check));
}

static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
							   __wsum psum)
{
	if (NAPI_GRO_CB(skb)->csum_valid &&
	    !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
		return 0;

	NAPI_GRO_CB(skb)->csum = psum;

	return __skb_gro_checksum_complete(skb);
}

static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
{
	if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
		/* Consume a checksum from CHECKSUM_UNNECESSARY */
		NAPI_GRO_CB(skb)->csum_cnt--;
	} else {
		/* Update skb for CHECKSUM_UNNECESSARY and csum_level when we
		 * verified a new top level checksum or an encapsulated one
		 * during GRO. This saves work if we fallback to normal path.
		 */
		__skb_incr_checksum_unnecessary(skb);
	}
}

#define __skb_gro_checksum_validate(skb, proto, zero_okay, check,	\
				    compute_pseudo)			\
({									\
	__sum16 __ret = 0;						\
	if (__skb_gro_checksum_validate_needed(skb, zero_okay, check))	\
		__ret = __skb_gro_checksum_validate_complete(skb,	\
				compute_pseudo(skb, proto));		\
	if (!__ret)							\
		skb_gro_incr_csum_unnecessary(skb);			\
	__ret;								\
})

#define skb_gro_checksum_validate(skb, proto, compute_pseudo)		\
	__skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)

#define skb_gro_checksum_validate_zero_check(skb, proto, check,		\
					     compute_pseudo)		\
	__skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)

#define skb_gro_checksum_simple_validate(skb)				\
	__skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)

static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
{
	return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
		!NAPI_GRO_CB(skb)->csum_valid);
}

static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
					      __sum16 check, __wsum pseudo)
{
	NAPI_GRO_CB(skb)->csum = ~pseudo;
	NAPI_GRO_CB(skb)->csum_valid = 1;
}

#define skb_gro_checksum_try_convert(skb, proto, check, compute_pseudo)	\
do {									\
	if (__skb_gro_checksum_convert_check(skb))			\
		__skb_gro_checksum_convert(skb, check,			\
					   compute_pseudo(skb, proto));	\
} while (0)

struct gro_remcsum {
	int offset;
	__wsum delta;
};

static inline void skb_gro_remcsum_init(struct gro_remcsum *grc)
{
	grc->delta = 0;
}

static inline void *skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
					    unsigned int off, size_t hdrlen,
					    int start, int offset,
					    struct gro_remcsum *grc,
					    bool nopartial)
{
	__wsum delta;
	size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);

	BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);

	if (!nopartial) {
		NAPI_GRO_CB(skb)->gro_remcsum_start = off + hdrlen + start;
		return ptr;
	}

	ptr = skb_gro_header_fast(skb, off);
	if (skb_gro_header_hard(skb, off + plen)) {
		ptr = skb_gro_header_slow(skb, off + plen, off);
		if (!ptr)
			return NULL;
	}

	delta = remcsum_adjust(ptr + hdrlen, NAPI_GRO_CB(skb)->csum,
			       start, offset);

	/* Adjust skb->csum since we changed the packet */
	NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);

	grc->offset = off + hdrlen + offset;
	grc->delta = delta;

	return ptr;
}

static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
					   struct gro_remcsum *grc)
{
	void *ptr;
	size_t plen = grc->offset + sizeof(u16);

	if (!grc->delta)
		return;

	ptr = skb_gro_header_fast(skb, grc->offset);
	if (skb_gro_header_hard(skb, grc->offset + sizeof(u16))) {
		ptr = skb_gro_header_slow(skb, plen, grc->offset);
		if (!ptr)
			return;
	}

	remcsum_unadjust((__sum16 *)ptr, grc->delta);
}

static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
				  unsigned short type,
				  const void *daddr, const void *saddr,
				  unsigned int 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);
}

static inline int dev_rebuild_header(struct sk_buff *skb)
{
	const struct net_device *dev = skb->dev;

	if (!dev->header_ops || !dev->header_ops->rebuild)
		return 0;
	return dev->header_ops->rebuild(skb);
}

typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
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 int		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);

void __netif_schedule(struct Qdisc *q);
void netif_schedule_queue(struct netdev_queue *txq);

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

void netif_tx_wake_queue(struct netdev_queue *dev_queue);

/**
 *	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_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 bool 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 bool netif_queue_stopped(const struct net_device *dev)
{
	return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
}

static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
{
	return dev_queue->state & QUEUE_STATE_ANY_XOFF;
}

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

static inline bool
netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
{
	return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
}

/**
 *	netdev_txq_bql_enqueue_prefetchw - prefetch bql data for write
 *	@dev_queue: pointer to transmit queue
 *
 * BQL enabled drivers might use this helper in their ndo_start_xmit(),
 * to give appropriate hint to the cpu.
 */
static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
{
#ifdef CONFIG_BQL
	prefetchw(&dev_queue->dql.num_queued);
#endif
}

/**
 *	netdev_txq_bql_complete_prefetchw - prefetch bql data for write
 *	@dev_queue: pointer to transmit queue
 *
 * BQL enabled drivers might use this helper in their TX completion path,
 * to give appropriate hint to the cpu.
 */
static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
{
#ifdef CONFIG_BQL
	prefetchw(&dev_queue->dql.limit);
#endif
}

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 (likely(dql_avail(&dev_queue->dql) >= 0))
		return;

	set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);

	/*
	 * The XOFF flag must be set before checking the dql_avail below,
	 * because in netdev_tx_completed_queue we update the dql_completed
	 * before checking the XOFF flag.
	 */
	smp_mb();

	/* check again in case another CPU has just made room avail */
	if (unlikely(dql_avail(&dev_queue->dql) >= 0))
		clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
#endif
}

/* Variant of netdev_tx_sent_queue() for drivers that are aware
 * that they should not test BQL status themselves.
 * We do want to change __QUEUE_STATE_STACK_XOFF only for the last
 * skb of a batch.
 * Returns true if the doorbell must be used to kick the NIC.
 */
static inline bool __netdev_tx_sent_queue(struct netdev_queue *dev_queue,
					  unsigned int bytes,
					  bool xmit_more)
{
	if (xmit_more) {
#ifdef CONFIG_BQL
		dql_queued(&dev_queue->dql, bytes);
#endif
		return netif_tx_queue_stopped(dev_queue);
	}
	netdev_tx_sent_queue(dev_queue, bytes);
	return true;
}

/**
 * 	netdev_sent_queue - report the number of bytes queued to hardware
 * 	@dev: network device
 * 	@bytes: number of bytes queued to the hardware device queue
 *
 * 	Report the number of bytes queued for sending/completion to the network
 * 	device hardware queue. @bytes should be a good approximation and should
 * 	exactly match netdev_completed_queue() @bytes
 */
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 bool __netdev_sent_queue(struct net_device *dev,
				       unsigned int bytes,
				       bool xmit_more)
{
	return __netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes,
				      xmit_more);
}

static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
					     unsigned int pkts, unsigned int bytes)
{
#ifdef CONFIG_BQL
	if (unlikely(!bytes))
		return;

	dql_completed(&dev_queue->dql, bytes);

	/*
	 * Without the memory barrier there is a small possiblity that
	 * netdev_tx_sent_queue will miss the update and cause the queue to
	 * be stopped forever
	 */
	smp_mb();

	if (dql_avail(&dev_queue->dql) < 0)
		return;

	if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
		netif_schedule_queue(dev_queue);
#endif
}

/**
 * 	netdev_completed_queue - report bytes and packets completed by device
 * 	@dev: network device
 * 	@pkts: actual number of packets sent over the medium
 * 	@bytes: actual number of bytes sent over the medium
 *
 * 	Report the number of bytes and packets transmitted by the network device
 * 	hardware queue over the physical medium, @bytes must exactly match the
 * 	@bytes amount passed to netdev_sent_queue()
 */
static inline void netdev_completed_queue(struct net_device *dev,
					  unsigned int pkts, unsigned int 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
	clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
	dql_reset(&q->dql);
#endif
}

/**
 * 	netdev_reset_queue - reset the packets and bytes count of a network device
 * 	@dev_queue: network device
 *
 * 	Reset the bytes and packet count of a network device and clear the
 * 	software flow control OFF bit for this network device
 */
static inline void netdev_reset_queue(struct net_device *dev_queue)
{
	netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0));
}

/**
 * 	netdev_cap_txqueue - check if selected tx queue exceeds device queues
 * 	@dev: network device
 * 	@queue_index: given tx queue index
 *
 * 	Returns 0 if given tx queue index >= number of device tx queues,
 * 	otherwise returns the originally passed tx queue index.
 */
static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
{
	if (unlikely(queue_index >= dev->real_num_tx_queues)) {
		net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
				     dev->name, queue_index,
				     dev->real_num_tx_queues);
		return 0;
	}

	return queue_index;
}

/**
 *	netif_running - test if up
 *	@dev: network device
 *
 *	Test if the device has been brought up.
 */
static inline bool 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);
	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 bool __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 bool netif_subqueue_stopped(const struct net_device *dev,
					  struct sk_buff *skb)
{
	return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
}

void netif_wake_subqueue(struct net_device *dev, u16 queue_index);

#ifdef CONFIG_XPS
int netif_set_xps_queue(struct net_device *dev,
			const struct cpumask *mask,
			u16 index);
#else
static inline int netif_set_xps_queue(struct net_device *dev,
				      const struct cpumask *mask,
				      u16 index)
{
	return 0;
}
#endif

u16 __skb_tx_hash(const struct net_device *dev, struct sk_buff *skb,
		  unsigned int num_tx_queues);

/*
 * 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,
			      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 bool netif_is_multiqueue(const struct net_device *dev)
{
	return dev->num_tx_queues > 1;
}

int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);

#ifdef CONFIG_RPS
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)
{
	int err;

	err = netif_set_real_num_tx_queues(to_dev,
					   from_dev->real_num_tx_queues);
	if (err)
		return err;
#ifdef CONFIG_RPS
	return netif_set_real_num_rx_queues(to_dev,
					    from_dev->real_num_rx_queues);
#else
	return 0;
#endif
}

#define DEFAULT_MAX_NUM_RSS_QUEUES	(8)
int netif_get_num_default_rss_queues(void);

enum skb_free_reason {
	SKB_REASON_CONSUMED,
	SKB_REASON_DROPPED,
};

void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason);
void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason);

/*
 * It is not allowed to call kfree_skb() or consume_skb() from hardware
 * interrupt context or with hardware interrupts being disabled.
 * (in_irq() || irqs_disabled())
 *
 * We provide four helpers that can be used in following contexts :
 *
 * dev_kfree_skb_irq(skb) when caller drops a packet from irq context,
 *  replacing kfree_skb(skb)
 *
 * dev_consume_skb_irq(skb) when caller consumes a packet from irq context.
 *  Typically used in place of consume_skb(skb) in TX completion path
 *
 * dev_kfree_skb_any(skb) when caller doesn't know its current irq context,
 *  replacing kfree_skb(skb)
 *
 * dev_consume_skb_any(skb) when caller doesn't know its current irq context,
 *  and consumed a packet. Used in place of consume_skb(skb)
 */
static inline void _dev_kfree_skb_irq(struct sk_buff *skb)
{
	__dev_kfree_skb_irq(skb, SKB_REASON_DROPPED);
}

/* RHEL has dev_kfree_skb_irq in KABI so we need to keep it for binary
 * modules but we need to ensure that compiled modules use new inlined
 * function. */
void dev_kfree_skb_irq(struct sk_buff *skb);
#define dev_kfree_skb_irq _dev_kfree_skb_irq

static inline void dev_consume_skb_irq(struct sk_buff *skb)
{
	__dev_kfree_skb_irq(skb, SKB_REASON_CONSUMED);
}

static inline void _dev_kfree_skb_any(struct sk_buff *skb)
{
	__dev_kfree_skb_any(skb, SKB_REASON_DROPPED);
}

/* RHEL has dev_kfree_skb_any in KABI etc. (see above) */
void dev_kfree_skb_any(struct sk_buff *skb);
#define dev_kfree_skb_any _dev_kfree_skb_any

static inline void dev_consume_skb_any(struct sk_buff *skb)
{
	__dev_kfree_skb_any(skb, SKB_REASON_CONSUMED);
}

int netif_rx(struct sk_buff *skb);
int netif_rx_ni(struct sk_buff *skb);
int netif_receive_skb(struct sk_buff *skb);
gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
void napi_gro_flush(struct napi_struct *napi, bool flush_old);
struct sk_buff *napi_get_frags(struct napi_struct *napi);
gro_result_t napi_gro_frags(struct napi_struct *napi);
struct packet_offload *gro_find_receive_by_type(__be16 type);
struct packet_offload *gro_find_complete_by_type(__be16 type);

static inline void napi_free_frags(struct napi_struct *napi)
{
	kfree_skb(napi->skb);
	napi->skb = NULL;
}

bool netdev_is_rx_handler_busy(struct net_device *dev);
int netdev_rx_handler_register(struct net_device *dev,
			       rx_handler_func_t *rx_handler,
			       void *rx_handler_data);
void netdev_rx_handler_unregister(struct net_device *dev);

bool dev_valid_name(const char *name);
int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
int dev_ethtool(struct net *net, struct ifreq *);
unsigned int dev_get_flags(const struct net_device *);
int __dev_change_flags(struct net_device *, unsigned int flags);
int dev_change_flags(struct net_device *, unsigned int);
void __dev_notify_flags(struct net_device *, unsigned int old_flags,
			unsigned int gchanges);
int dev_change_name(struct net_device *, const char *);
int dev_set_alias(struct net_device *, const char *, size_t);
int dev_change_net_namespace(struct net_device *, struct net *, const char *);
int __dev_set_mtu(struct net_device *, int);
int dev_set_mtu(struct net_device *, int);
void dev_set_group(struct net_device *, int);
int dev_set_mac_address(struct net_device *, struct sockaddr *);
int dev_change_carrier(struct net_device *, bool new_carrier);
int dev_get_phys_port_id(struct net_device *dev,
			 struct netdev_phys_item_id *ppid);
int dev_get_phys_port_name(struct net_device *dev,
			   char *name, size_t len);
int dev_change_proto_down(struct net_device *dev, bool proto_down);
int dev_change_xdp_fd(struct net_device *dev, int fd);
struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev);
struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
				    struct netdev_queue *txq, int *ret);
int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
bool is_skb_forwardable(struct net_device *dev, struct sk_buff *skb);

extern int		netdev_budget;

/* Called by rtnetlink.c:rtnl_unlock() */
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)
{
	this_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)
{
	this_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.
 */

void linkwatch_init_dev(struct net_device *dev);
void linkwatch_fire_event(struct net_device *dev);
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 bool netif_carrier_ok(const struct net_device *dev)
{
	return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
}

unsigned long dev_trans_start(struct net_device *dev);

void __netdev_watchdog_up(struct net_device *dev);

void netif_carrier_on(struct net_device *dev);

void netif_carrier_off(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 bool 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 bool 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 bool netif_device_present(struct net_device *dev)
{
	return test_bit(__LINK_STATE_PRESENT, &dev->state);
}

void netif_device_detach(struct net_device *dev);

void netif_device_attach(struct net_device *dev);

/*
 * Network interface message level settings
 */

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 bool __netif_tx_trylock(struct netdev_queue *txq)
{
	bool 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;
}

/* legacy drivers only, netdev_start_xmit() sets txq->trans_start */
static inline void netif_trans_update(struct net_device *dev)
{
	struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);

	if (txq->trans_start != jiffies)
		txq->trans_start = jiffies;

	/* RHEL - update deprecated trans_start for old binary modules */
	dev->rh_reserved_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_nested(struct net_device *dev)
{
	spin_lock_nested(&dev->addr_list_lock, SINGLE_DEPTH_NESTING);
}

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

/*
 * RHEL 7.5+: The network core checks MTU value requested by an user
 * against minimum and maximum stored in .min_mtu and .max_mtu fields when
 * both .extended.ndo_change_mtu() as well as .ndo_change_mtu_rh74() are
 * not implemented by a driver. Default values for .{min,max}_mtu are
 * initialized by ether_setup() but because this function is on kABI
 * white-list we have to preserve its semantic so this initialization
 * cannot be placed there. Instead of this we have to create separate
 * ether_setup_rh() that additionally initializes .{min,max}_mtu.
 * Macro ether_setup ensures that old ether_setup (preserved for existing
 * binary modules) is not used by inbox drivers & o-o-box drivers compiled
 * against RHEL-7.5 and above.
 */
void ether_setup_rh(struct net_device *dev);
#define ether_setup ether_setup_rh

/* Support for loadable net-drivers */
struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
				    void (*setup)(struct net_device *),
				    unsigned int txqs, unsigned int rxqs);
int dev_get_valid_name(struct net *net, struct net_device *dev,
		       const char *name);

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

int register_netdev(struct net_device *dev);
void unregister_netdev(struct net_device *dev);

/* General hardware address lists handling functions */
int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
		   struct netdev_hw_addr_list *from_list, int addr_len);
void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
		      struct netdev_hw_addr_list *from_list, int addr_len);
int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
		       struct net_device *dev,
		       int (*sync)(struct net_device *, const unsigned char *),
		       int (*unsync)(struct net_device *,
				     const unsigned char *));
void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
			  struct net_device *dev,
			  int (*unsync)(struct net_device *,
					const unsigned char *));
void __hw_addr_init(struct netdev_hw_addr_list *list);

/* Functions used for device addresses handling */
int dev_addr_add(struct net_device *dev, const unsigned char *addr,
		 unsigned char addr_type);
int dev_addr_del(struct net_device *dev, const unsigned char *addr,
		 unsigned char addr_type);
void dev_addr_flush(struct net_device *dev);
int dev_addr_init(struct net_device *dev);

/* Functions used for unicast addresses handling */
int dev_uc_add(struct net_device *dev, const unsigned char *addr);
int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
int dev_uc_del(struct net_device *dev, const unsigned char *addr);
int dev_uc_sync(struct net_device *to, struct net_device *from);
int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
void dev_uc_unsync(struct net_device *to, struct net_device *from);
void dev_uc_flush(struct net_device *dev);
void dev_uc_init(struct net_device *dev);

/**
 *  __dev_uc_sync - Synchonize device's unicast list
 *  @dev:  device to sync
 *  @sync: function to call if address should be added
 *  @unsync: function to call if address should be removed
 *
 *  Add newly added addresses to the interface, and release
 *  addresses that have been deleted.
 **/
static inline int __dev_uc_sync(struct net_device *dev,
				int (*sync)(struct net_device *,
					    const unsigned char *),
				int (*unsync)(struct net_device *,
					      const unsigned char *))
{
	return __hw_addr_sync_dev(&dev->uc, dev, sync, unsync);
}

/**
 *  __dev_uc_unsync - Remove synchonized addresses from device
 *  @dev:  device to sync
 *  @unsync: function to call if address should be removed
 *
 *  Remove all addresses that were added to the device by dev_uc_sync().
 **/
static inline void __dev_uc_unsync(struct net_device *dev,
				   int (*unsync)(struct net_device *,
						 const unsigned char *))
{
	__hw_addr_unsync_dev(&dev->uc, dev, unsync);
}

/* Functions used for multicast addresses handling */
int dev_mc_add(struct net_device *dev, const unsigned char *addr);
int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
int dev_mc_del(struct net_device *dev, const unsigned char *addr);
int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
int dev_mc_sync(struct net_device *to, struct net_device *from);
int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
void dev_mc_unsync(struct net_device *to, struct net_device *from);
void dev_mc_flush(struct net_device *dev);
void dev_mc_init(struct net_device *dev);

/**
 *  __dev_mc_sync - Synchonize device's multicast list
 *  @dev:  device to sync
 *  @sync: function to call if address should be added
 *  @unsync: function to call if address should be removed
 *
 *  Add newly added addresses to the interface, and release
 *  addresses that have been deleted.
 **/
static inline int __dev_mc_sync(struct net_device *dev,
				int (*sync)(struct net_device *,
					    const unsigned char *),
				int (*unsync)(struct net_device *,
					      const unsigned char *))
{
	return __hw_addr_sync_dev(&dev->mc, dev, sync, unsync);
}

/**
 *  __dev_mc_unsync - Remove synchonized addresses from device
 *  @dev:  device to sync
 *  @unsync: function to call if address should be removed
 *
 *  Remove all addresses that were added to the device by dev_mc_sync().
 **/
static inline void __dev_mc_unsync(struct net_device *dev,
				   int (*unsync)(struct net_device *,
						 const unsigned char *))
{
	__hw_addr_unsync_dev(&dev->mc, dev, unsync);
}

/* Functions used for secondary unicast and multicast support */
void dev_set_rx_mode(struct net_device *dev);
void __dev_set_rx_mode(struct net_device *dev);
int dev_set_promiscuity(struct net_device *dev, int inc);
int dev_set_allmulti(struct net_device *dev, int inc);
void netdev_state_change(struct net_device *dev);
void netdev_notify_peers(struct net_device *dev);
void netdev_features_change(struct net_device *dev);
/* Load a device via the kmod */
void dev_load(struct net *net, const char *name);
struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
					struct rtnl_link_stats64 *storage);
void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
			     const struct net_device_stats *netdev_stats);

extern int		netdev_max_backlog;
extern int		netdev_tstamp_prequeue;
extern int		weight_p;
extern int		dev_weight_rx_bias;
extern int		dev_weight_tx_bias;
extern int		dev_rx_weight;
extern int		dev_tx_weight;
extern int		bpf_jit_enable;

bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev);
bool netdev_has_any_upper_dev(struct net_device *dev);
struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
						     struct list_head **iter);
struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev,
						     struct list_head **iter);

/* iterate through upper list, must be called under RCU read lock */
#define netdev_for_each_upper_dev_rcu(dev, updev, iter) \
	for (iter = &(dev)->adj_list.upper, \
	     updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \
	     updev; \
	     updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))

/* iterate through upper list, must be called under RCU read lock */
#define netdev_for_each_all_upper_dev_rcu(dev, updev, iter) \
	for (iter = &(dev)->upper_dev_list, \
	     updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)); \
	     updev; \
	     updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)))

int netdev_walk_all_upper_dev_rcu(struct net_device *dev,
				  int (*fn)(struct net_device *upper_dev,
					    void *data),
				  void *data);

bool netdev_has_upper_dev_all_rcu(struct net_device *dev,
				  struct net_device *upper_dev);

bool netdev_has_any_upper_dev(struct net_device *dev);

void *netdev_lower_get_next_private(struct net_device *dev,
				    struct list_head **iter);
void *netdev_lower_get_next_private_rcu(struct net_device *dev,
					struct list_head **iter);

#define netdev_for_each_lower_private(dev, priv, iter) \
	for (iter = (dev)->adj_list.lower.next, \
	     priv = netdev_lower_get_next_private(dev, &(iter)); \
	     priv; \
	     priv = netdev_lower_get_next_private(dev, &(iter)))

#define netdev_for_each_lower_private_rcu(dev, priv, iter) \
	for (iter = &(dev)->adj_list.lower, \
	     priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \
	     priv; \
	     priv = netdev_lower_get_next_private_rcu(dev, &(iter)))

void *netdev_lower_get_next(struct net_device *dev,
				struct list_head **iter);

#define netdev_for_each_lower_dev(dev, ldev, iter) \
	for (iter = &(dev)->adj_list.lower, \
	     ldev = netdev_lower_get_next(dev, &(iter)); \
	     ldev; \
	     ldev = netdev_lower_get_next(dev, &(iter)))

struct net_device *netdev_all_lower_get_next(struct net_device *dev,
					     struct list_head **iter);
struct net_device *netdev_all_lower_get_next_rcu(struct net_device *dev,
						 struct list_head **iter);

#define netdev_for_each_all_lower_dev(dev, ldev, iter) \
	for (iter = (dev)->lower_dev_list.next, \
	     ldev = netdev_all_lower_get_next(dev, &(iter)); \
	     ldev; \
	     ldev = netdev_all_lower_get_next(dev, &(iter)))

#define netdev_for_each_all_lower_dev_rcu(dev, ldev, iter) \
	for (iter = &(dev)->lower_dev_list, \
	     ldev = netdev_all_lower_get_next_rcu(dev, &(iter)); \
	     ldev; \
	     ldev = netdev_all_lower_get_next_rcu(dev, &(iter)))

int netdev_walk_all_lower_dev(struct net_device *dev,
			      int (*fn)(struct net_device *lower_dev,
					void *data),
			      void *data);
int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
				  int (*fn)(struct net_device *lower_dev,
					    void *data),
				  void *data);

void *netdev_adjacent_get_private(struct list_head *adj_list);
void *netdev_lower_get_first_private_rcu(struct net_device *dev);
struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev);
int netdev_master_upper_dev_link(struct net_device *dev,
				 struct net_device *upper_dev);
int netdev_master_upper_dev_link_rh(struct net_device *dev,
				    struct net_device *upper_dev,
				    void *upper_priv, void *upper_info);
#define netdev_master_upper_dev_link netdev_master_upper_dev_link_rh
void netdev_upper_dev_unlink(struct net_device *dev,
			     struct net_device *upper_dev);
void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
void *netdev_lower_dev_get_private_rcu(struct net_device *dev,
				       struct net_device *lower_dev);
void *netdev_lower_dev_get_private(struct net_device *dev,
				   struct net_device *lower_dev);
void netdev_lower_state_changed(struct net_device *lower_dev,
				void *lower_state_info);
int netdev_default_l2upper_neigh_construct(struct net_device *dev,
					   struct neighbour *n);
void netdev_default_l2upper_neigh_destroy(struct net_device *dev,
					  struct neighbour *n);

/* RSS keys are 40 or 52 bytes long */
#define NETDEV_RSS_KEY_LEN 52
extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
void netdev_rss_key_fill(void *buffer, size_t len);

int dev_get_nest_level(struct net_device *dev,
		       bool (*type_check)(const struct net_device *dev));
int skb_checksum_help(struct sk_buff *skb);
int skb_crc32c_csum_help(struct sk_buff *skb);
int skb_csum_hwoffload_help(struct sk_buff *skb,
			    const netdev_features_t features);

struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
				  netdev_features_t features, bool tx_path);
struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
				    netdev_features_t features);

struct netdev_bonding_info {
	ifslave	slave;
	ifbond	master;
};

struct netdev_notifier_bonding_info {
	struct netdev_notifier_info info; /* must be first */
	struct netdev_bonding_info  bonding_info;
};

void netdev_bonding_info_change(struct net_device *dev,
				struct netdev_bonding_info *bonding_info);

static inline
struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
{
	return __skb_gso_segment(skb, features, true);
}
__be16 skb_network_protocol(struct sk_buff *skb, int *depth);

static inline bool can_checksum_protocol(netdev_features_t features,
					 __be16 protocol)
{
	if (protocol == htons(ETH_P_FCOE))
		return !!(features & NETIF_F_FCOE_CRC);

	/* Assume this is an IP checksum (not SCTP CRC) */

	if (features & NETIF_F_HW_CSUM) {
		/* Can checksum everything */
		return true;
	}

	switch (protocol) {
	case htons(ETH_P_IP):
		return !!(features & NETIF_F_IP_CSUM);
	case htons(ETH_P_IPV6):
		return !!(features & NETIF_F_IPV6_CSUM);
	default:
		return false;
	}
}

#ifdef CONFIG_BUG
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 */
void net_enable_timestamp(void);
void net_disable_timestamp(void);

#ifdef CONFIG_PROC_FS
int __init dev_proc_init(void);
#else
#define dev_proc_init() 0
#endif

static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
					      struct sk_buff *skb, struct net_device *dev,
					      bool more)
{
	skb->xmit_more = more ? 1 : 0;
	return ops->ndo_start_xmit(skb, dev);
}

static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
					    struct netdev_queue *txq, bool more)
{
	const struct net_device_ops *ops = dev->netdev_ops;
	int rc;

	rc = __netdev_start_xmit(ops, skb, dev, more);
	if (rc == NETDEV_TX_OK)
		txq_trans_update(txq);

	return rc;
}

extern int netdev_class_create_file_ns(struct class_attribute *class_attr,
				       const void *ns);
extern void netdev_class_remove_file_ns(struct class_attribute *class_attr,
					const void *ns);

static inline int netdev_class_create_file(struct class_attribute *class_attr)
{
	return netdev_class_create_file_ns(class_attr, NULL);
}

static inline void netdev_class_remove_file(struct class_attribute *class_attr)
{
	netdev_class_remove_file_ns(class_attr, NULL);
}

extern struct kobj_ns_type_operations net_ns_type_operations;

const char *netdev_drivername(const struct net_device *dev);

void linkwatch_run_queue(void);

static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
							  netdev_features_t f2)
{
	if ((f1 ^ f2) & NETIF_F_HW_CSUM) {
		if (f1 & NETIF_F_HW_CSUM)
			f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
		else
			f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
	}

	return f1 & f2;
}

static inline netdev_features_t netdev_get_wanted_features(
	struct net_device *dev)
{
	return (dev->features & ~dev->hw_features) | dev->wanted_features;
}
netdev_features_t netdev_increment_features(netdev_features_t all,
	netdev_features_t one, netdev_features_t mask);

/* Allow TSO being used on stacked device :
 * Performing the GSO segmentation before last device
 * is a performance improvement.
 */
static inline netdev_features_t netdev_add_tso_features(netdev_features_t features,
							netdev_features_t mask)
{
	return netdev_increment_features(features, NETIF_F_ALL_TSO, mask);
}

int __netdev_update_features(struct net_device *dev);
void netdev_update_features(struct net_device *dev);
void netdev_change_features(struct net_device *dev);

void netif_stacked_transfer_operstate(const struct net_device *rootdev,
					struct net_device *dev);

netdev_features_t passthru_features_check(struct sk_buff *skb,
					  struct net_device *dev,
					  netdev_features_t features);
netdev_features_t netif_skb_features(struct sk_buff *skb);

static inline bool net_gso_ok(netdev_features_t features, int gso_type)
{
	netdev_features_t feature = gso_type & SKB_GSO1_MASK;

	feature <<= NETIF_F_GSO_SHIFT;

	if (gso_type & SKB_GSO2_MASK) {
		netdev_features_t f = gso_type & SKB_GSO2_MASK;
		f <<= NETIF_F_GSO2_SHIFT;
		feature |= f;
	}

	/* check flags correspondence */
	BUILD_BUG_ON(SKB_GSO_TCPV4   != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_UDP     != (NETIF_F_UFO >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_DODGY   != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_TCPV6   != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_FCOE    != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_GRE     != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_IPIP    != (NETIF_F_GSO_IPIP >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_SIT     != (NETIF_F_GSO_SIT >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));

	/* GSO2 flags, see netdev_features.h */
	BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO2_SHIFT));
	BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO2_SHIFT));
	BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO2_SHIFT));
	BUILD_BUG_ON(SKB_GSO_SCTP    != (NETIF_F_GSO_SCTP >> NETIF_F_GSO2_SHIFT));
	BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO2_SHIFT));

	return (features & feature) == feature;
}

static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
{
	return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
	       (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
}

static inline bool netif_needs_gso(struct sk_buff *skb,
				   netdev_features_t features)
{
	return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
		unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
			 (skb->ip_summed != CHECKSUM_UNNECESSARY)));
}

static inline void netif_set_gso_max_size(struct net_device *dev,
					  unsigned int size)
{
	dev->gso_max_size = size;
}

static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol,
					int pulled_hlen, u16 mac_offset,
					int mac_len)
{
	skb->protocol = protocol;
	skb->encapsulation = 1;
	skb_push(skb, pulled_hlen);
	skb_reset_transport_header(skb);
	skb->mac_header = mac_offset;
	skb->network_header = skb->mac_header + mac_len;
	skb->mac_len = mac_len;
}

static inline bool netif_is_macvlan(const struct net_device *dev)
{
	return dev->priv_flags & IFF_MACVLAN;
}

static inline bool netif_is_macsec(const struct net_device *dev)
{
	return dev->priv_flags & IFF_MACSEC;
}

static inline bool netif_is_macvlan_port(const struct net_device *dev)
{
	return dev->priv_flags & IFF_MACVLAN_PORT;
}

static inline bool netif_is_bond_master(const struct net_device *dev)
{
	return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
}

static inline bool netif_is_bond_slave(const struct net_device *dev)
{
	return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
}

static inline bool netif_is_bridge_port(const struct net_device *dev)
{
	return dev->priv_flags & IFF_BRIDGE_PORT;
}

static inline bool netif_supports_nofcs(struct net_device *dev)
{
	return dev->priv_flags & IFF_SUPP_NOFCS;
}

static inline bool netif_is_bridge_master(const struct net_device *dev)
{
	return dev->priv_flags & IFF_EBRIDGE;
}

static inline bool netif_is_ovs_master(const struct net_device *dev)
{
	return dev->priv_flags & IFF_OPENVSWITCH;
}

static inline bool netif_is_ovs_port(const struct net_device *dev)
{
	return dev->priv_flags & IFF_OVS_DATAPATH;
}

static inline bool netif_is_rxfh_configured(const struct net_device *dev)
{
	return dev->priv_flags & IFF_RXFH_CONFIGURED;
}

static inline bool netif_is_team_master(const struct net_device *dev)
{
	return dev->priv_flags & IFF_TEAM;
}

static inline bool netif_is_team_port(const struct net_device *dev)
{
	return dev->priv_flags & IFF_TEAM_PORT;
}

static inline bool netif_is_lag_master(const struct net_device *dev)
{
	return netif_is_bond_master(dev) || netif_is_team_master(dev);
}

static inline bool netif_is_lag_port(const struct net_device *dev)
{
	return netif_is_bond_slave(dev) || netif_is_team_port(dev);
}

static inline bool netif_is_failover(const struct net_device *dev)
{
	return dev->priv_flags & IFF_FAILOVER;
}

static inline bool netif_is_failover_slave(const struct net_device *dev)
{
	return dev->priv_flags & IFF_FAILOVER_SLAVE;
}

/* This device needs to keep skb dst for qdisc enqueue or ndo_start_xmit() */
static inline void netif_keep_dst(struct net_device *dev)
{
	dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
}

/* return true if dev can't cope with mtu frames that need vlan tag insertion */
static inline bool netif_reduces_vlan_mtu(struct net_device *dev)
{
	/* TODO: reserve and use an additional IFF bit, if we get more users */
	return dev->priv_flags & IFF_MACSEC;
}

extern struct pernet_operations __net_initdata loopback_net_ops;

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

static inline const char *netdev_reg_state(const struct net_device *dev)
{
	switch (dev->reg_state) {
	case NETREG_UNINITIALIZED: return " (uninitialized)";
	case NETREG_REGISTERED: return "";
	case NETREG_UNREGISTERING: return " (unregistering)";
	case NETREG_UNREGISTERED: return " (unregistered)";
	case NETREG_RELEASED: return " (released)";
	case NETREG_DUMMY: return " (dummy)";
	}

	WARN_ONCE(1, "%s: unknown reg_state %d\n", dev->name, dev->reg_state);
	return " (unknown)";
}

__printf(3, 4)
int netdev_printk(const char *level, const struct net_device *dev,
		  const char *format, ...);
__printf(2, 3)
int netdev_emerg(const struct net_device *dev, const char *format, ...);
__printf(2, 3)
int netdev_alert(const struct net_device *dev, const char *format, ...);
__printf(2, 3)
int netdev_crit(const struct net_device *dev, const char *format, ...);
__printf(2, 3)
int netdev_err(const struct net_device *dev, const char *format, ...);
__printf(2, 3)
int netdev_warn(const struct net_device *dev, const char *format, ...);
__printf(2, 3)
int netdev_notice(const struct net_device *dev, const char *format, ...);
__printf(2, 3)
int netdev_info(const struct net_device *dev, const char *format, ...);

#define netdev_level_once(level, dev, fmt, ...)			\
do {								\
	static bool __print_once __read_mostly;			\
								\
	if (!__print_once) {					\
		__print_once = true;				\
		netdev_printk(level, dev, fmt, ##__VA_ARGS__);	\
	}							\
} while (0)

#define netdev_emerg_once(dev, fmt, ...) \
	netdev_level_once(KERN_EMERG, dev, fmt, ##__VA_ARGS__)
#define netdev_alert_once(dev, fmt, ...) \
	netdev_level_once(KERN_ALERT, dev, fmt, ##__VA_ARGS__)
#define netdev_crit_once(dev, fmt, ...) \
	netdev_level_once(KERN_CRIT, dev, fmt, ##__VA_ARGS__)
#define netdev_err_once(dev, fmt, ...) \
	netdev_level_once(KERN_ERR, dev, fmt, ##__VA_ARGS__)
#define netdev_warn_once(dev, fmt, ...) \
	netdev_level_once(KERN_WARNING, dev, fmt, ##__VA_ARGS__)
#define netdev_notice_once(dev, fmt, ...) \
	netdev_level_once(KERN_NOTICE, dev, fmt, ##__VA_ARGS__)
#define netdev_info_once(dev, fmt, ...) \
	netdev_level_once(KERN_INFO, dev, fmt, ##__VA_ARGS__)

#define MODULE_ALIAS_NETDEV(device) \
	MODULE_ALIAS("netdev-" device)

#if defined(CONFIG_DYNAMIC_DEBUG)
#define netdev_dbg(__dev, format, args...)			\
do {								\
	dynamic_netdev_dbg(__dev, format, ##args);		\
} while (0)
#elif defined(DEBUG)
#define netdev_dbg(__dev, format, args...)			\
	netdev_printk(KERN_DEBUG, __dev, format, ##args)
#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%s: " format, netdev_name(dev),	\
	     netdev_reg_state(dev), ##args)

#define netdev_WARN_ONCE(dev, format, args...)				\
	WARN_ONCE(1, "netdevice: %s%s: " format, netdev_name(dev),	\
		  netdev_reg_state(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(CONFIG_DYNAMIC_DEBUG)
#define netif_dbg(priv, type, netdev, format, args...)		\
do {								\
	if (netif_msg_##type(priv))				\
		dynamic_netdev_dbg(netdev, format, ##args);	\
} while (0)
#elif defined(DEBUG)
#define netif_dbg(priv, type, dev, format, args...)		\
	netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
#else
#define netif_dbg(priv, type, dev, format, args...)			\
({									\
	if (0)								\
		netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
	0;								\
})
#endif

/* if @cond then downgrade to debug, else print at @level */
#define netif_cond_dbg(priv, type, netdev, cond, level, fmt, args...)     \
	do {                                                              \
		if (cond)                                                 \
			netif_dbg(priv, type, netdev, fmt, ##args);       \
		else                                                      \
			netif_ ## level(priv, type, netdev, fmt, ##args); \
	} while (0)

#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

/*
 *	The list of packet types we will receive (as opposed to discard)
 *	and the routines to invoke.
 *
 *	Why 16. Because with 16 the only overlap we get on a hash of the
 *	low nibble of the protocol value is RARP/SNAP/X.25.
 *
 *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
 *             sure which should go first, but I bet it won't make much
 *             difference if we are running VLANs.  The good news is that
 *             this protocol won't be in the list unless compiled in, so
 *             the average user (w/out VLANs) will not be adversely affected.
 *             --BLG
 *
 *		0800	IP
 *		8100    802.1Q VLAN
 *		0001	802.3
 *		0002	AX.25
 *		0004	802.2
 *		8035	RARP
 *		0005	SNAP
 *		0805	X.25
 *		0806	ARP
 *		8137	IPX
 *		0009	Localtalk
 *		86DD	IPv6
 */
#define PTYPE_HASH_SIZE	(16)
#define PTYPE_HASH_MASK	(PTYPE_HASH_SIZE - 1)

#endif	/* _LINUX_NETDEVICE_H */
N4m3
5!z3
L45t M0d!f!3d
0wn3r / Gr0up
P3Rm!55!0n5
0pt!0n5
..
--
January 19 2024 08:12:51
0 / 0
0755
amba
--
January 19 2024 08:12:50
0 / 0
0755
avf
--
January 19 2024 08:12:50
0 / 0
0755
bcma
--
January 19 2024 08:12:50
0 / 0
0755
byteorder
--
January 19 2024 08:12:50
0 / 0
0755
can
--
January 19 2024 08:12:50
0 / 0
0755
ceph
--
January 19 2024 08:12:50
0 / 0
0755
clk
--
January 19 2024 08:12:50
0 / 0
0755
crush
--
January 19 2024 08:12:50
0 / 0
0755
decompress
--
January 19 2024 08:12:50
0 / 0
0755
dma
--
January 19 2024 08:12:50
0 / 0
0755
extcon
--
January 19 2024 08:12:50
0 / 0
0755
fsl
--
January 19 2024 08:12:50
0 / 0
0755
gpio
--
January 19 2024 08:12:50
0 / 0
0755
hsi
--
January 19 2024 08:12:50
0 / 0
0755
i2c
--
January 19 2024 08:12:50
0 / 0
0755
iio
--
January 19 2024 08:12:50
0 / 0
0755
input
--
January 19 2024 08:12:50
0 / 0
0755
irqchip
--
January 19 2024 08:12:50
0 / 0
0755
isdn
--
January 19 2024 08:12:50
0 / 0
0755
lockd
--
January 19 2024 08:12:50
0 / 0
0755
mfd
--
January 19 2024 08:12:50
0 / 0
0755
mlx4
--
January 19 2024 08:12:50
0 / 0
0755
mlx5
--
January 19 2024 08:12:50
0 / 0
0755
mmc
--
January 19 2024 08:12:50
0 / 0
0755
mtd
--
January 19 2024 08:12:50
0 / 0
0755
netfilter
--
January 19 2024 08:12:50
0 / 0
0755
netfilter_arp
--
January 19 2024 08:12:50
0 / 0
0755
netfilter_bridge
--
January 19 2024 08:12:50
0 / 0
0755
netfilter_ipv4
--
January 19 2024 08:12:50
0 / 0
0755
netfilter_ipv6
--
January 19 2024 08:12:50
0 / 0
0755
phy
--
January 19 2024 08:12:50
0 / 0
0755
pinctrl
--
January 19 2024 08:12:50
0 / 0
0755
platform_data
--
January 19 2024 08:12:50
0 / 0
0755
power
--
January 19 2024 08:12:50
0 / 0
0755
qed
--
January 19 2024 08:12:50
0 / 0
0755
raid
--
January 19 2024 08:12:50
0 / 0
0755
regulator
--
January 19 2024 08:12:50
0 / 0
0755
rtc
--
January 19 2024 08:12:50
0 / 0
0755
sched
--
January 19 2024 08:12:50
0 / 0
0755
spi
--
January 19 2024 08:12:50
0 / 0
0755
ssb
--
January 19 2024 08:12:50
0 / 0
0755
sunrpc
--
January 19 2024 08:12:50
0 / 0
0755
ulpi
--
January 19 2024 08:12:50
0 / 0
0755
unaligned
--
January 19 2024 08:12:50
0 / 0
0755
usb
--
January 19 2024 08:12:50
0 / 0
0755
uwb
--
January 19 2024 08:12:51
0 / 0
0755
wimax
--
January 19 2024 08:12:51
0 / 0
0755
8250_pci.h
0.976 KB
November 06 2023 09:15:52
0 / 0
0644
a.out.h
1.353 KB
November 06 2023 09:15:52
0 / 0
0644
acct.h
2.51 KB
November 06 2023 09:15:52
0 / 0
0644
acpi.h
26.935 KB
November 06 2023 09:15:52
0 / 0
0644
acpi_dma.h
3.177 KB
November 06 2023 09:15:52
0 / 0
0644
acpi_pmtmr.h
0.62 KB
November 06 2023 09:15:52
0 / 0
0644
adb.h
1.751 KB
November 06 2023 09:15:52
0 / 0
0644
adfs_fs.h
0.522 KB
November 06 2023 09:15:52
0 / 0
0644
adxl.h
0.303 KB
November 06 2023 09:15:52
0 / 0
0644
aer.h
1.682 KB
November 06 2023 09:15:52
0 / 0
0644
agp_backend.h
3.451 KB
November 06 2023 09:15:52
0 / 0
0644
agpgart.h
3.816 KB
November 06 2023 09:15:52
0 / 0
0644
ahci_platform.h
0.872 KB
November 06 2023 09:15:52
0 / 0
0644
aio.h
3.319 KB
November 06 2023 09:15:52
0 / 0
0644
alarmtimer.h
1.424 KB
November 06 2023 09:15:52
0 / 0
0644
altera_jtaguart.h
0.332 KB
November 06 2023 09:15:52
0 / 0
0644
altera_uart.h
0.35 KB
November 06 2023 09:15:52
0 / 0
0644
amd-iommu.h
6.782 KB
November 06 2023 09:15:52
0 / 0
0644
amifd.h
1.948 KB
November 06 2023 09:15:52
0 / 0
0644
amifdreg.h
2.611 KB
November 06 2023 09:15:52
0 / 0
0644
amigaffs.h
2.858 KB
November 06 2023 09:15:52
0 / 0
0644
anon_inodes.h
0.444 KB
November 06 2023 09:15:52
0 / 0
0644
apm-emulation.h
1.538 KB
November 06 2023 09:15:52
0 / 0
0644
apm_bios.h
2.682 KB
November 06 2023 09:15:52
0 / 0
0644
apple_bl.h
0.448 KB
November 06 2023 09:15:52
0 / 0
0644
arcdevice.h
12.456 KB
November 06 2023 09:15:52
0 / 0
0644
ascii85.h
0.52 KB
November 06 2023 09:15:52
0 / 0
0644
asn1.h
1.991 KB
November 06 2023 09:15:52
0 / 0
0644
asn1_ber_bytecode.h
2.718 KB
November 06 2023 09:15:52
0 / 0
0644
asn1_decoder.h
0.659 KB
November 06 2023 09:15:52
0 / 0
0644
assoc_array.h
3.073 KB
November 06 2023 09:15:52
0 / 0
0644
assoc_array_priv.h
5.489 KB
November 06 2023 09:15:52
0 / 0
0644
async.h
1.648 KB
November 06 2023 09:15:52
0 / 0
0644
async_tx.h
6.909 KB
November 06 2023 09:15:52
0 / 0
0644
ata.h
29.434 KB
November 06 2023 09:15:52
0 / 0
0644
ata_platform.h
0.733 KB
November 06 2023 09:15:52
0 / 0
0644
atalk.h
4.282 KB
November 06 2023 09:15:52
0 / 0
0644
ath9k_platform.h
1.442 KB
November 06 2023 09:15:52
0 / 0
0644
atm.h
0.242 KB
November 06 2023 09:15:52
0 / 0
0644
atm_suni.h
0.247 KB
November 06 2023 09:15:52
0 / 0
0644
atm_tcp.h
0.461 KB
November 06 2023 09:15:52
0 / 0
0644
atmdev.h
9.516 KB
November 06 2023 09:15:52
0 / 0
0644
atmel-mci.h
1.205 KB
November 06 2023 09:15:52
0 / 0
0644
atmel-pwm-bl.h
1.514 KB
November 06 2023 09:15:52
0 / 0
0644
atmel-ssc.h
9.288 KB
November 06 2023 09:15:52
0 / 0
0644
atmel_pdc.h
1.467 KB
November 06 2023 09:15:52
0 / 0
0644
atmel_pwm.h
2.66 KB
November 06 2023 09:15:52
0 / 0
0644
atmel_serial.h
5.944 KB
November 06 2023 09:15:52
0 / 0
0644
atmel_tc.h
11.082 KB
November 06 2023 09:15:52
0 / 0
0644
atomic.h
12.648 KB
November 06 2023 09:15:52
0 / 0
0644
attribute_container.h
2.467 KB
November 06 2023 09:15:52
0 / 0
0644
audit.h
16.849 KB
November 06 2023 09:15:52
0 / 0
0644
auto_dev-ioctl.h
0.443 KB
November 06 2023 09:15:52
0 / 0
0644
auto_fs.h
0.426 KB
November 06 2023 09:15:52
0 / 0
0644
auxvec.h
0.259 KB
November 06 2023 09:15:52
0 / 0
0644
average.h
1.988 KB
November 06 2023 09:15:52
0 / 0
0644
b1pcmcia.h
0.65 KB
November 06 2023 09:15:52
0 / 0
0644
backing-dev.h
10.367 KB
November 06 2023 09:15:52
0 / 0
0644
backlight.h
4.791 KB
November 06 2023 09:15:52
0 / 0
0644
badblocks.h
2.099 KB
November 06 2023 09:15:52
0 / 0
0644
balloon_compaction.h
7.676 KB
November 06 2023 09:15:52
0 / 0
0644
basic_mmio_gpio.h
2.083 KB
November 06 2023 09:15:52
0 / 0
0644
bcd.h
0.508 KB
November 06 2023 09:15:52
0 / 0
0644
bch.h
2.598 KB
November 06 2023 09:15:52
0 / 0
0644
bcm47xx_nvram.h
1.193 KB
November 06 2023 09:15:52
0 / 0
0644
bcm47xx_wdt.h
0.563 KB
November 06 2023 09:15:52
0 / 0
0644
bfin_mac.h
0.546 KB
November 06 2023 09:15:52
0 / 0
0644
binfmts.h
3.778 KB
November 06 2023 09:15:52
0 / 0
0644
bio.h
18.802 KB
November 06 2023 09:15:52
0 / 0
0644
bit_spinlock.h
2.267 KB
November 06 2023 09:15:52
0 / 0
0644
bitfield.h
4.67 KB
November 06 2023 09:15:52
0 / 0
0644
bitmap.h
12.933 KB
November 06 2023 09:15:52
0 / 0
0644
bitops.h
7.413 KB
November 06 2023 09:15:52
0 / 0
0644
bitrev.h
0.264 KB
November 06 2023 09:15:52
0 / 0
0644
blk-mq-pci.h
0.22 KB
November 06 2023 09:15:52
0 / 0
0644
blk-mq.h
12.551 KB
November 06 2023 09:15:52
0 / 0
0644
blk_types.h
10.567 KB
November 06 2023 09:15:52
0 / 0
0644
blkdev.h
56.196 KB
November 06 2023 09:15:52
0 / 0
0644
blktrace_api.h
3.11 KB
November 06 2023 09:15:52
0 / 0
0644
blockgroup_lock.h
1.137 KB
November 06 2023 09:15:52
0 / 0
0644
bma150.h
1.893 KB
November 06 2023 09:15:52
0 / 0
0644
bootmem.h
9.815 KB
November 06 2023 09:15:52
0 / 0
0644
bottom_half.h
0.581 KB
November 06 2023 09:15:52
0 / 0
0644
bpf.h
15.584 KB
November 06 2023 09:15:52
0 / 0
0644
bpf_trace.h
0.124 KB
November 06 2023 09:15:52
0 / 0
0644
bpf_types.h
1.257 KB
November 06 2023 09:15:52
0 / 0
0644
bpf_verifier.h
8.259 KB
November 06 2023 09:15:52
0 / 0
0644
brcmphy.h
1.185 KB
November 06 2023 09:15:52
0 / 0
0644
bsearch.h
0.23 KB
November 06 2023 09:15:52
0 / 0
0644
bsg-lib.h
1.977 KB
November 06 2023 09:15:52
0 / 0
0644
bsg.h
0.717 KB
November 06 2023 09:15:52
0 / 0
0644
btree-128.h
2.635 KB
November 06 2023 09:15:52
0 / 0
0644
btree-type.h
3.859 KB
November 06 2023 09:15:52
0 / 0
0644
btree.h
6.797 KB
November 06 2023 09:15:52
0 / 0
0644
btrfs.h
0.104 KB
November 06 2023 09:15:52
0 / 0
0644
buffer_head.h
12.054 KB
November 06 2023 09:15:52
0 / 0
0644
bug.h
3.679 KB
November 06 2023 09:15:52
0 / 0
0644
c2port.h
1.587 KB
November 06 2023 09:15:52
0 / 0
0644
cache.h
1.575 KB
November 06 2023 09:15:52
0 / 0
0644
capability.h
6.774 KB
November 06 2023 09:15:52
0 / 0
0644
cb710.h
5.69 KB
November 06 2023 09:15:52
0 / 0
0644
cciss_ioctl.h
0.99 KB
November 06 2023 09:15:52
0 / 0
0644
ccp.h
16.603 KB
November 06 2023 09:15:52
0 / 0
0644
cdev.h
0.827 KB
November 06 2023 09:15:52
0 / 0
0644
cdrom.h
8.664 KB
November 06 2023 09:15:52
0 / 0
0644
cfag12864b.h
2.096 KB
November 06 2023 09:15:52
0 / 0
0644
cgroup.h
28.788 KB
November 06 2023 09:15:52
0 / 0
0644
cgroup_subsys.h
1.452 KB
November 06 2023 09:15:52
0 / 0
0644
circ_buf.h
1.047 KB
November 06 2023 09:15:52
0 / 0
0644
cleancache.h
3.806 KB
November 06 2023 09:15:52
0 / 0
0644
clk-private.h
5.908 KB
November 06 2023 09:15:52
0 / 0
0644
clk-provider.h
17.066 KB
November 06 2023 09:15:52
0 / 0
0644
clk.h
10.333 KB
November 06 2023 09:15:52
0 / 0
0644
clkdev.h
1.146 KB
November 06 2023 09:15:52
0 / 0
0644
clksrc-dbx500-prcmu.h
0.444 KB
November 06 2023 09:15:52
0 / 0
0644
clockchips.h
6.523 KB
November 06 2023 09:15:52
0 / 0
0644
clocksource.h
7.805 KB
November 06 2023 09:15:52
0 / 0
0644
cm4000_cs.h
0.156 KB
November 06 2023 09:15:52
0 / 0
0644
cn_proc.h
1.846 KB
November 06 2023 09:15:52
0 / 0
0644
cnt32_to_63.h
3.604 KB
November 06 2023 09:15:52
0 / 0
0644
coda.h
2.197 KB
November 06 2023 09:15:52
0 / 0
0644
coda_psdev.h
2.62 KB
November 06 2023 09:15:52
0 / 0
0644
com20020.h
3.539 KB
November 06 2023 09:15:52
0 / 0
0644
compaction.h
4.037 KB
November 06 2023 09:15:52
0 / 0
0644
compat.h
25.058 KB
November 06 2023 09:15:52
0 / 0
0644
compiler-gcc.h
8.621 KB
November 06 2023 09:15:52
0 / 0
0644
compiler-intel.h
1.109 KB
November 06 2023 09:15:52
0 / 0
0644
compiler.h
14.431 KB
November 06 2023 09:15:52
0 / 0
0644
completion.h
3.768 KB
November 06 2023 09:15:52
0 / 0
0644
component.h
1.145 KB
November 06 2023 09:15:52
0 / 0
0644
concap.h
3.689 KB
November 06 2023 09:15:52
0 / 0
0644
configfs.h
10.109 KB
November 06 2023 09:15:52
0 / 0
0644
connector.h
2.307 KB
November 06 2023 09:15:52
0 / 0
0644
console.h
6.691 KB
November 06 2023 09:15:52
0 / 0
0644
console_struct.h
5.076 KB
November 06 2023 09:15:52
0 / 0
0644
consolemap.h
1.005 KB
November 06 2023 09:15:52
0 / 0
0644
container.h
0.652 KB
November 06 2023 09:15:52
0 / 0
0644
context_tracking.h
2.819 KB
November 06 2023 09:15:52
0 / 0
0644
context_tracking_state.h
1.26 KB
November 06 2023 09:15:52
0 / 0
0644
cordic.h
1.752 KB
November 06 2023 09:15:52
0 / 0
0644
coredump.h
0.554 KB
November 06 2023 09:15:52
0 / 0
0644
cper.h
12.337 KB
November 06 2023 09:15:52
0 / 0
0644
cpu.h
10.766 KB
November 06 2023 09:15:52
0 / 0
0644
cpu_cooling.h
2.069 KB
November 06 2023 09:15:52
0 / 0
0644
cpu_pm.h
2.783 KB
November 06 2023 09:15:52
0 / 0
0644
cpu_rmap.h
1.896 KB
November 06 2023 09:15:52
0 / 0
0644
cpufreq.h
19.551 KB
November 06 2023 09:15:52
0 / 0
0644
cpuidle.h
6.84 KB
November 06 2023 09:15:52
0 / 0
0644
cpuidle_haltpoll.h
0.305 KB
November 06 2023 09:15:52
0 / 0
0644
cpumask.h
29.029 KB
November 06 2023 09:15:52
0 / 0
0644
cpuset.h
5.784 KB
November 06 2023 09:15:52
0 / 0
0644
cputime.h
0.326 KB
November 06 2023 09:15:52
0 / 0
0644
cramfs_fs.h
0.272 KB
November 06 2023 09:15:52
0 / 0
0644
cramfs_fs_sb.h
0.335 KB
November 06 2023 09:15:52
0 / 0
0644
crash_core.h
2.921 KB
November 06 2023 09:15:52
0 / 0
0644
crash_dump.h
3.831 KB
November 06 2023 09:15:52
0 / 0
0644
crc-ccitt.h
0.322 KB
November 06 2023 09:15:52
0 / 0
0644
crc-itu-t.h
0.601 KB
November 06 2023 09:15:52
0 / 0
0644
crc-t10dif.h
0.343 KB
November 06 2023 09:15:52
0 / 0
0644
crc16.h
0.607 KB
November 06 2023 09:15:52
0 / 0
0644
crc32.h
2.601 KB
November 06 2023 09:15:52
0 / 0
0644
crc32c.h
0.248 KB
November 06 2023 09:15:52
0 / 0
0644
crc7.h
0.266 KB
November 06 2023 09:15:52
0 / 0
0644
crc8.h
3.653 KB
November 06 2023 09:15:52
0 / 0
0644
cred.h
11.925 KB
November 06 2023 09:15:52
0 / 0
0644
crypto.h
33.608 KB
November 06 2023 09:15:52
0 / 0
0644
cryptohash.h
0.407 KB
November 06 2023 09:15:52
0 / 0
0644
cryptouser.h
3.238 KB
November 06 2023 09:15:52
0 / 0
0644
cs5535.h
6.275 KB
November 06 2023 09:15:52
0 / 0
0644
ctype.h
1.689 KB
November 06 2023 09:15:52
0 / 0
0644
cuda.h
0.451 KB
November 06 2023 09:15:52
0 / 0
0644
cyclades.h
10.258 KB
November 06 2023 09:15:52
0 / 0
0644
cycx_x25.h
3.64 KB
November 06 2023 09:15:52
0 / 0
0644
davinci_emac.h
1.12 KB
November 06 2023 09:15:52
0 / 0
0644
dax.h
5.069 KB
November 06 2023 09:15:52
0 / 0
0644
dca.h
2.619 KB
November 06 2023 09:15:52
0 / 0
0644
dcache.h
17.918 KB
November 06 2023 09:15:52
0 / 0
0644
dccp.h
10.588 KB
November 06 2023 09:15:52
0 / 0
0644
dcookies.h
1.248 KB
November 06 2023 09:15:52
0 / 0
0644
debug_locks.h
1.477 KB
November 06 2023 09:15:52
0 / 0
0644
debugfs.h
7.68 KB
November 06 2023 09:15:52
0 / 0
0644
debugobjects.h
3.645 KB
November 06 2023 09:15:52
0 / 0
0644
delay.h
1.393 KB
November 06 2023 09:15:52
0 / 0
0644
delayacct.h
4.002 KB
November 06 2023 09:15:52
0 / 0
0644
dell-led.h
0.087 KB
November 06 2023 09:15:52
0 / 0
0644
devcoredump.h
0.963 KB
November 06 2023 09:15:52
0 / 0
0644
devfreq.h
8.803 KB
November 06 2023 09:15:52
0 / 0
0644
device-mapper.h
17.479 KB
November 06 2023 09:15:52
0 / 0
0644
device.h
48.329 KB
November 06 2023 09:15:52
0 / 0
0644
device_cgroup.h
0.583 KB
November 06 2023 09:15:52
0 / 0
0644
devpts_fs.h
1.098 KB
November 06 2023 09:15:52
0 / 0
0644
digsig.h
1.347 KB
November 06 2023 09:15:52
0 / 0
0644
dio.h
10.928 KB
November 06 2023 09:15:52
0 / 0
0644
dirent.h
0.173 KB
November 06 2023 09:15:52
0 / 0
0644
dlm.h
6.007 KB
November 06 2023 09:15:52
0 / 0
0644
dlm_plock.h
0.662 KB
November 06 2023 09:15:52
0 / 0
0644
dm-dirty-log.h
3.943 KB
November 06 2023 09:15:52
0 / 0
0644
dm-io.h
1.917 KB
November 06 2023 09:15:52
0 / 0
0644
dm-kcopyd.h
2.848 KB
November 06 2023 09:15:52
0 / 0
0644
dm-region-hash.h
3.107 KB
November 06 2023 09:15:52
0 / 0
0644
dm9000.h
1.074 KB
November 06 2023 09:15:52
0 / 0
0644
dma-attrs.h
1.582 KB
November 06 2023 09:15:52
0 / 0
0644
dma-buf.h
14.472 KB
November 06 2023 09:15:52
0 / 0
0644
dma-contiguous.h
4.583 KB
November 06 2023 09:15:52
0 / 0
0644
dma-debug.h
5.614 KB
November 06 2023 09:15:52
0 / 0
0644
dma-direction.h
0.292 KB
November 06 2023 09:15:52
0 / 0
0644
dma-fence-array.h
2.489 KB
November 06 2023 09:15:52
0 / 0
0644
dma-fence.h
18.796 KB
November 06 2023 09:15:52
0 / 0
0644
dma-mapping.h
21.935 KB
November 06 2023 09:15:52
0 / 0
0644
dma_remapping.h
1.139 KB
November 06 2023 09:15:52
0 / 0
0644
dmaengine.h
39.344 KB
November 06 2023 09:15:52
0 / 0
0644
dmapool.h
1.068 KB
November 06 2023 09:15:52
0 / 0
0644
dmar.h
7.766 KB
November 06 2023 09:15:52
0 / 0
0644
dmi.h
4.099 KB
November 06 2023 09:15:52
0 / 0
0644
dnotify.h
0.984 KB
November 06 2023 09:15:52
0 / 0
0644
dns_resolver.h
1.306 KB
November 06 2023 09:15:52
0 / 0
0644
dqblk_qtree.h
2.059 KB
November 06 2023 09:15:52
0 / 0
0644
dqblk_v1.h
0.334 KB
November 06 2023 09:15:52
0 / 0
0644
dqblk_v2.h
0.358 KB
November 06 2023 09:15:52
0 / 0
0644
drbd.h
10.301 KB
November 06 2023 09:15:52
0 / 0
0644
drbd_genl.h
15.29 KB
November 06 2023 09:15:52
0 / 0
0644
drbd_genl_api.h
1.728 KB
November 06 2023 09:15:52
0 / 0
0644
drbd_limits.h
6.577 KB
November 06 2023 09:15:52
0 / 0
0644
ds1286.h
1.194 KB
November 06 2023 09:15:52
0 / 0
0644
ds17287rtc.h
2.613 KB
November 06 2023 09:15:52
0 / 0
0644
ds2782_battery.h
0.116 KB
November 06 2023 09:15:52
0 / 0
0644
dtlk.h
3.462 KB
November 06 2023 09:15:52
0 / 0
0644
dw_apb_timer.h
1.807 KB
November 06 2023 09:15:52
0 / 0
0644
dynamic_debug.h
3.905 KB
November 06 2023 09:15:52
0 / 0
0644
dynamic_queue_limits.h
3.662 KB
November 06 2023 09:15:52
0 / 0
0644
earlycpio.h
0.313 KB
November 06 2023 09:15:52
0 / 0
0644
ecryptfs.h
3.785 KB
November 06 2023 09:15:52
0 / 0
0644
edac.h
24.938 KB
November 06 2023 09:15:52
0 / 0
0644
edd.h
1.435 KB
November 06 2023 09:15:52
0 / 0
0644
edma.h
0.788 KB
November 06 2023 09:15:52
0 / 0
0644
eeprom_93cx6.h
2.746 KB
November 06 2023 09:15:52
0 / 0
0644
eeprom_93xx46.h
0.412 KB
November 06 2023 09:15:52
0 / 0
0644
efi-bgrt.h
0.417 KB
November 06 2023 09:15:52
0 / 0
0644
efi.h
38.553 KB
November 06 2023 09:15:52
0 / 0
0644
efs_vh.h
1.51 KB
November 06 2023 09:15:52
0 / 0
0644
eisa.h
2.922 KB
November 06 2023 09:15:52
0 / 0
0644
elevator.h
10.762 KB
November 06 2023 09:15:52
0 / 0
0644
elf-fdpic.h
2.185 KB
November 06 2023 09:15:52
0 / 0
0644
elf-randomize.h
0.531 KB
November 06 2023 09:15:52
0 / 0
0644
elf.h
1.392 KB
November 06 2023 09:15:52
0 / 0
0644
elfcore-compat.h
1.199 KB
November 06 2023 09:15:52
0 / 0
0644
elfcore.h
2.063 KB
November 06 2023 09:15:52
0 / 0
0644
elfnote.h
3.497 KB
November 06 2023 09:15:52
0 / 0
0644
enclosure.h
4.601 KB
November 06 2023 09:15:52
0 / 0
0644
err.h
1.412 KB
November 06 2023 09:15:52
0 / 0
0644
errno.h
1.303 KB
November 06 2023 09:15:52
0 / 0
0644
errqueue.h
0.439 KB
November 06 2023 09:15:52
0 / 0
0644
etherdevice.h
15.311 KB
November 06 2023 09:15:52
0 / 0
0644
ethtool.h
18.335 KB
November 06 2023 09:15:52
0 / 0
0644
eventfd.h
2.062 KB
November 06 2023 09:15:52
0 / 0
0644
eventpoll.h
2.011 KB
November 06 2023 09:15:52
0 / 0
0644
evm.h
2.479 KB
November 06 2023 09:15:52
0 / 0
0644
export.h
2.665 KB
November 06 2023 09:15:52
0 / 0
0644
exportfs.h
7.308 KB
November 06 2023 09:15:52
0 / 0
0644
ext2_fs.h
0.906 KB
November 06 2023 09:15:52
0 / 0
0644
extcon.h
10.258 KB
November 06 2023 09:15:52
0 / 0
0644
f2fs_fs.h
12.972 KB
November 06 2023 09:15:52
0 / 0
0644
f75375s.h
0.528 KB
November 06 2023 09:15:52
0 / 0
0644
falloc.h
0.702 KB
November 06 2023 09:15:52
0 / 0
0644
fanotify.h
0.201 KB
November 06 2023 09:15:52
0 / 0
0644
fault-inject.h
1.836 KB
November 06 2023 09:15:52
0 / 0
0644
fb.h
28.167 KB
November 06 2023 09:15:52
0 / 0
0644
fcdevice.h
0.965 KB
November 06 2023 09:15:52
0 / 0
0644
fcntl.h
0.888 KB
November 06 2023 09:15:52
0 / 0
0644
fd.h
0.44 KB
November 06 2023 09:15:52
0 / 0
0644
fddidevice.h
1.076 KB
November 06 2023 09:15:52
0 / 0
0644
fdtable.h
3.31 KB
November 06 2023 09:15:52
0 / 0
0644
fec.h
0.555 KB
November 06 2023 09:15:52
0 / 0
0644
file.h
1.998 KB
November 06 2023 09:15:52
0 / 0
0644
filter.h
23.736 KB
November 06 2023 09:15:52
0 / 0
0644
fips.h
0.125 KB
November 06 2023 09:15:52
0 / 0
0644
firewire.h
13.141 KB
November 06 2023 09:15:52
0 / 0
0644
firmware-map.h
1.319 KB
November 06 2023 09:15:52
0 / 0
0644
firmware.h
2.181 KB
November 06 2023 09:15:52
0 / 0
0644
fixp-arith.h
2.245 KB
November 06 2023 09:15:52
0 / 0
0644
flat.h
1.576 KB
November 06 2023 09:15:52
0 / 0
0644
flex_array.h
2.427 KB
November 06 2023 09:15:52
0 / 0
0644
flex_proportions.h
2.731 KB
November 06 2023 09:15:52
0 / 0
0644
font.h
1.214 KB
November 06 2023 09:15:52
0 / 0
0644
frame.h
0.749 KB
November 06 2023 09:15:52
0 / 0
0644
freezer.h
9.99 KB
November 06 2023 09:15:52
0 / 0
0644
frontswap.h
2.511 KB
November 06 2023 09:15:52
0 / 0
0644
fs.h
111.014 KB
November 06 2023 09:15:52
0 / 0
0644
fs_enet_pd.h
3.309 KB
November 06 2023 09:15:52
0 / 0
0644
fs_pin.h
0.566 KB
November 06 2023 09:15:52
0 / 0
0644
fs_stack.h
0.754 KB
November 06 2023 09:15:52
0 / 0
0644
fs_struct.h
0.976 KB
November 06 2023 09:15:52
0 / 0
0644
fs_uart_pd.h
1.487 KB
November 06 2023 09:15:52
0 / 0
0644
fscache-cache.h
18.399 KB
November 06 2023 09:15:52
0 / 0
0644
fscache.h
27.87 KB
November 06 2023 09:15:52
0 / 0
0644
fsl-diu-fb.h
4.081 KB
November 06 2023 09:15:52
0 / 0
0644
fsl_devices.h
4.315 KB
November 06 2023 09:15:52
0 / 0
0644
fsl_hypervisor.h
2.758 KB
November 06 2023 09:15:52
0 / 0
0644
fsnotify.h
7.391 KB
November 06 2023 09:15:52
0 / 0
0644
fsnotify_backend.h
18.438 KB
November 06 2023 09:15:52
0 / 0
0644
ftrace.h
26.952 KB
November 06 2023 09:15:52
0 / 0
0644
ftrace_event.h
14.768 KB
November 06 2023 09:15:52
0 / 0
0644
ftrace_irq.h
0.766 KB
November 06 2023 09:15:52
0 / 0
0644
futex.h
1.766 KB
November 06 2023 09:15:52
0 / 0
0644
fwnode.h
1.527 KB
November 06 2023 09:15:52
0 / 0
0644
gameport.h
5.562 KB
November 06 2023 09:15:52
0 / 0
0644
gcd.h
0.15 KB
November 06 2023 09:15:52
0 / 0
0644
genalloc.h
5.188 KB
November 06 2023 09:15:52
0 / 0
0644
generic_acl.h
0.343 KB
November 06 2023 09:15:52
0 / 0
0644
genetlink.h
1.352 KB
November 06 2023 09:15:52
0 / 0
0644
genhd.h
22.085 KB
November 06 2023 09:15:52
0 / 0
0644
genl_magic_func.h
12.006 KB
November 06 2023 09:15:52
0 / 0
0644
genl_magic_struct.h
7.435 KB
November 06 2023 09:15:52
0 / 0
0644
getcpu.h
0.588 KB
November 06 2023 09:15:52
0 / 0
0644
gfp.h
16.164 KB
November 06 2023 09:15:52
0 / 0
0644
gpio-fan.h
0.783 KB
November 06 2023 09:15:52
0 / 0
0644
gpio-pxa.h
0.52 KB
November 06 2023 09:15:52
0 / 0
0644
gpio.h
5.75 KB
November 06 2023 09:15:52
0 / 0
0644
gpio_keys.h
0.93 KB
November 06 2023 09:15:52
0 / 0
0644
gpio_mouse.h
1.459 KB
November 06 2023 09:15:52
0 / 0
0644
gpt.h
4.08 KB
November 06 2023 09:15:52
0 / 0
0644
gsmmux.h
0.884 KB
November 06 2023 09:15:52
0 / 0
0644
hardirq.h
1.893 KB
November 06 2023 09:15:52
0 / 0
0644
hash.h
2.029 KB
November 06 2023 09:15:52
0 / 0
0644
hashtable.h
6.62 KB
November 06 2023 09:15:52
0 / 0
0644
hdlc.h
3.427 KB
November 06 2023 09:15:52
0 / 0
0644
hdlcdrv.h
6.28 KB
November 06 2023 09:15:52
0 / 0
0644
hdmi.h
9.366 KB
November 06 2023 09:15:52
0 / 0
0644
hid-debug.h
2.074 KB
November 06 2023 09:15:52
0 / 0
0644
hid-roccat.h
0.672 KB
November 06 2023 09:15:52
0 / 0
0644
hid-sensor-hub.h
9.129 KB
November 06 2023 09:15:52
0 / 0
0644
hid-sensor-ids.h
6.793 KB
November 06 2023 09:15:52
0 / 0
0644
hid.h
34.163 KB
November 06 2023 09:15:52
0 / 0
0644
hiddev.h
1.879 KB
November 06 2023 09:15:52
0 / 0
0644
hidraw.h
1.49 KB
November 06 2023 09:15:52
0 / 0
0644
highmem.h
5.852 KB
November 06 2023 09:15:52
0 / 0
0644
highuid.h
3.081 KB
November 06 2023 09:15:52
0 / 0
0644
hil.h
18.415 KB
November 06 2023 09:15:52
0 / 0
0644
hil_mlc.h
5.129 KB
November 06 2023 09:15:52
0 / 0
0644
hippidevice.h
1.291 KB
November 06 2023 09:15:52
0 / 0
0644
hmm.h
18.063 KB
November 06 2023 09:15:52
0 / 0
0644
hp_sdc.h
14.02 KB
November 06 2023 09:15:52
0 / 0
0644
hpet.h
2.516 KB
November 06 2023 09:15:52
0 / 0
0644
hrtimer.h
12.906 KB
November 06 2023 09:15:52
0 / 0
0644
htcpld.h
0.564 KB
November 06 2023 09:15:52
0 / 0
0644
htirq.h
0.769 KB
November 06 2023 09:15:52
0 / 0
0644
huge_mm.h
11.704 KB
November 06 2023 09:15:52
0 / 0
0644
hugetlb.h
14.299 KB
November 06 2023 09:15:52
0 / 0
0644
hugetlb_cgroup.h
2.971 KB
November 06 2023 09:15:52
0 / 0
0644
hugetlb_inline.h
0.321 KB
November 06 2023 09:15:52
0 / 0
0644
hw_breakpoint.h
3.814 KB
November 06 2023 09:15:52
0 / 0
0644
hw_random.h
1.948 KB
November 06 2023 09:15:52
0 / 0
0644
hwmon-sysfs.h
1.977 KB
November 06 2023 09:15:52
0 / 0
0644
hwmon-vid.h
1.478 KB
November 06 2023 09:15:52
0 / 0
0644
hwmon.h
11.495 KB
November 06 2023 09:15:52
0 / 0
0644
hwspinlock.h
10.895 KB
November 06 2023 09:15:52
0 / 0
0644
hyperv.h
39.959 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-algo-bit.h
2.244 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-algo-pca.h
2.5 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-algo-pcf.h
1.881 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-dev.h
1.026 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-gpio.h
1.313 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-mux-gpio.h
1.351 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-mux-pinctrl.h
1.44 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-mux.h
1.644 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-ocores.h
0.691 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-omap.h
1.174 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-pca-platform.h
0.393 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-pnx.h
0.921 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-pxa.h
0.39 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-smbus.h
1.777 KB
November 06 2023 09:15:52
0 / 0
0644
i2c-xiic.h
1.41 KB
November 06 2023 09:15:52
0 / 0
0644
i2c.h
24.742 KB
November 06 2023 09:15:52
0 / 0
0644
i2o.h
29.697 KB
November 06 2023 09:15:52
0 / 0
0644
i7300_idle.h
1.908 KB
November 06 2023 09:15:52
0 / 0
0644
i8042.h
1.796 KB
November 06 2023 09:15:52
0 / 0
0644
i8253.h
0.746 KB
November 06 2023 09:15:52
0 / 0
0644
i82593.h
5.584 KB
November 06 2023 09:15:52
0 / 0
0644
icmp.h
0.843 KB
November 06 2023 09:15:52
0 / 0
0644
icmpv6.h
1.11 KB
November 06 2023 09:15:52
0 / 0
0644
ide.h
44.838 KB
November 06 2023 09:15:52
0 / 0
0644
idr.h
7.269 KB
November 06 2023 09:15:52
0 / 0
0644
idr_ext.h
1.891 KB
November 06 2023 09:15:52
0 / 0
0644
ieee80211.h
105.181 KB
November 06 2023 09:15:52
0 / 0
0644
ieee802154.h
11.504 KB
November 06 2023 09:15:52
0 / 0
0644
if_arp.h
1.78 KB
November 06 2023 09:15:52
0 / 0
0644
if_bridge.h
2.617 KB
November 06 2023 09:15:52
0 / 0
0644
if_eql.h
1.074 KB
November 06 2023 09:15:52
0 / 0
0644
if_ether.h
1.315 KB
November 06 2023 09:15:52
0 / 0
0644
if_fddi.h
3.443 KB
November 06 2023 09:15:52
0 / 0
0644
if_frad.h
2.876 KB
November 06 2023 09:15:52
0 / 0
0644
if_link.h
0.629 KB
November 06 2023 09:15:52
0 / 0
0644
if_ltalk.h
0.146 KB
November 06 2023 09:15:52
0 / 0
0644
if_macvlan.h
3.593 KB
November 06 2023 09:15:52
0 / 0
0644
if_phonet.h
0.268 KB
November 06 2023 09:15:52
0 / 0
0644
if_pppol2tp.h
0.71 KB
November 06 2023 09:15:52
0 / 0
0644
if_pppox.h
2.963 KB
November 06 2023 09:15:52
0 / 0
0644
if_team.h
7.588 KB
November 06 2023 09:15:52
0 / 0
0644
if_tun.h
1.136 KB
November 06 2023 09:15:52
0 / 0
0644
if_tunnel.h
0.361 KB
November 06 2023 09:15:52
0 / 0
0644
if_vlan.h
16.53 KB
November 06 2023 09:15:52
0 / 0
0644
igmp.h
4.26 KB
November 06 2023 09:15:52
0 / 0
0644
ihex.h
1.916 KB
November 06 2023 09:15:52
0 / 0
0644
ima.h
1.764 KB
November 06 2023 09:15:52
0 / 0
0644
in.h
2.427 KB
November 06 2023 09:15:52
0 / 0
0644
in6.h
1.849 KB
November 06 2023 09:15:52
0 / 0
0644
inet.h
2.798 KB
November 06 2023 09:15:52
0 / 0
0644
inet_diag.h
1.662 KB
November 06 2023 09:15:52
0 / 0
0644
inet_lro.h
4.264 KB
November 06 2023 09:15:52
0 / 0
0644
inetdevice.h
9.515 KB
November 06 2023 09:15:52
0 / 0
0644
init.h
11.228 KB
November 06 2023 09:15:52
0 / 0
0644
init_ohci1394_dma.h
0.153 KB
November 06 2023 09:15:52
0 / 0
0644
init_task.h
6.884 KB
November 06 2023 09:15:52
0 / 0
0644
initrd.h
0.569 KB
November 06 2023 09:15:52
0 / 0
0644
inotify.h
0.642 KB
November 06 2023 09:15:52
0 / 0
0644
input-polldev.h
2.067 KB
November 06 2023 09:15:52
0 / 0
0644
input.h
18.353 KB
November 06 2023 09:15:52
0 / 0
0644
integrity.h
0.928 KB
November 06 2023 09:15:52
0 / 0
0644
intel-iommu.h
15.686 KB
November 06 2023 09:15:52
0 / 0
0644
intel_mid_dma.h
2.405 KB
November 06 2023 09:15:52
0 / 0
0644
intel_pmic_gpio.h
0.363 KB
November 06 2023 09:15:52
0 / 0
0644
interrupt.h
21.445 KB
November 06 2023 09:15:52
0 / 0
0644
interval_tree.h
0.739 KB
November 06 2023 09:15:52
0 / 0
0644
interval_tree_generic.h
7.032 KB
November 06 2023 09:15:52
0 / 0
0644
io-mapping.h
4.322 KB
November 06 2023 09:15:52
0 / 0
0644
io.h
4.692 KB
November 06 2023 09:15:52
0 / 0
0644
ioc3.h
3.139 KB
November 06 2023 09:15:52
0 / 0
0644
ioc4.h
5.781 KB
November 06 2023 09:15:52
0 / 0
0644
iocontext.h
4.7 KB
November 06 2023 09:15:52
0 / 0
0644
iomap.h
4.462 KB
November 06 2023 09:15:52
0 / 0
0644
iommu-helper.h
0.89 KB
November 06 2023 09:15:52
0 / 0
0644
iommu.h
17.304 KB
November 06 2023 09:15:52
0 / 0
0644
iopoll.h
5.523 KB
November 06 2023 09:15:52
0 / 0
0644
ioport.h
10.51 KB
November 06 2023 09:15:52
0 / 0
0644
ioprio.h
1.953 KB
November 06 2023 09:15:52
0 / 0
0644
iova.h
6.957 KB
November 06 2023 09:15:52
0 / 0
0644
ip.h
1.066 KB
November 06 2023 09:15:52
0 / 0
0644
ipack.h
8.264 KB
November 06 2023 09:15:52
0 / 0
0644
ipc.h
0.38 KB
November 06 2023 09:15:52
0 / 0
0644
ipc_namespace.h
4.439 KB
November 06 2023 09:15:52
0 / 0
0644
ipmi.h
10.452 KB
November 06 2023 09:15:52
0 / 0
0644
ipmi_smi.h
8.354 KB
November 06 2023 09:15:52
0 / 0
0644
ipv6.h
7.729 KB
November 06 2023 09:15:52
0 / 0
0644
ipv6_route.h
0.58 KB
November 06 2023 09:15:52
0 / 0
0644
irq.h
25.038 KB
November 06 2023 09:15:52
0 / 0
0644
irq_cpustat.h
0.889 KB
November 06 2023 09:15:52
0 / 0
0644
irq_poll.h
0.523 KB
November 06 2023 09:15:52
0 / 0
0644
irq_work.h
1.244 KB
November 06 2023 09:15:52
0 / 0
0644
irqbypass.h
3.595 KB
November 06 2023 09:15:52
0 / 0
0644
irqchip.h
0.374 KB
November 06 2023 09:15:52
0 / 0
0644
irqdesc.h
5.051 KB
November 06 2023 09:15:52
0 / 0
0644
irqdomain.h
7.817 KB
November 06 2023 09:15:52
0 / 0
0644
irqflags.h
4.65 KB
November 06 2023 09:15:52
0 / 0
0644
irqnr.h
1.335 KB
November 06 2023 09:15:52
0 / 0
0644
irqreturn.h
0.422 KB
November 06 2023 09:15:52
0 / 0
0644
isa.h
0.873 KB
November 06 2023 09:15:52
0 / 0
0644
isapnp.h
3.805 KB
November 06 2023 09:15:52
0 / 0
0644
iscsi_boot_sysfs.h
3.675 KB
November 06 2023 09:15:52
0 / 0
0644
iscsi_ibft.h
1.274 KB
November 06 2023 09:15:52
0 / 0
0644
isdn.h
22.961 KB
November 06 2023 09:15:52
0 / 0
0644
isdn_divertif.h
1.271 KB
November 06 2023 09:15:52
0 / 0
0644
isdn_ppp.h
6.674 KB
November 06 2023 09:15:52
0 / 0
0644
isdnif.h
19.259 KB
November 06 2023 09:15:52
0 / 0
0644
isicom.h
1.454 KB
November 06 2023 09:15:52
0 / 0
0644
jbd.h
31.973 KB
November 06 2023 09:15:52
0 / 0
0644
jbd2.h
43.505 KB
November 06 2023 09:15:52
0 / 0
0644
jbd_common.h
0.919 KB
November 06 2023 09:15:52
0 / 0
0644
jhash.h
4.276 KB
November 06 2023 09:15:52
0 / 0
0644
jiffies.h
11.294 KB
November 06 2023 09:15:52
0 / 0
0644
journal-head.h
2.827 KB
November 06 2023 09:15:52
0 / 0
0644
joystick.h
1.283 KB
November 06 2023 09:15:52
0 / 0
0644
jump_label.h
5.839 KB
November 06 2023 09:15:52
0 / 0
0644
jump_label_ratelimit.h
1.074 KB
November 06 2023 09:15:52
0 / 0
0644
jz4740-adc.h
0.961 KB
November 06 2023 09:15:52
0 / 0
0644
kaiser.h
0.696 KB
November 06 2023 09:15:52
0 / 0
0644
kallsyms.h
3.556 KB
November 06 2023 09:15:52
0 / 0
0644
kbd_diacr.h
0.155 KB
November 06 2023 09:15:52
0 / 0
0644
kbd_kern.h
3.89 KB
November 06 2023 09:15:52
0 / 0
0644
kbuild.h
0.302 KB
November 06 2023 09:15:52
0 / 0
0644
kcmp.h
0.209 KB
November 06 2023 09:15:52
0 / 0
0644
kconfig.h
1.886 KB
November 06 2023 09:15:52
0 / 0
0644
kcore.h
0.845 KB
November 06 2023 09:15:52
0 / 0
0644
kd.h
0.168 KB
November 06 2023 09:15:52
0 / 0
0644
kdb.h
5.467 KB
November 06 2023 09:15:52
0 / 0
0644
kdebug.h
0.438 KB
November 06 2023 09:15:52
0 / 0
0644
kdev_t.h
1.78 KB
November 06 2023 09:15:52
0 / 0
0644
kern_levels.h
1.534 KB
November 06 2023 09:15:52
0 / 0
0644
kernel-page-flags.h
0.455 KB
November 06 2023 09:15:52
0 / 0
0644
kernel.h
29.786 KB
November 06 2023 09:15:52
0 / 0
0644
kernel_stat.h
3.271 KB
November 06 2023 09:15:52
0 / 0
0644
kernelcapi.h
4.406 KB
November 06 2023 09:15:52
0 / 0
0644
kernfs.h
14.278 KB
November 06 2023 09:15:52
0 / 0
0644
kexec.h
7.631 KB
November 06 2023 09:15:52
0 / 0
0644
key-type.h
5.313 KB
November 06 2023 09:15:52
0 / 0
0644
key.h
11.405 KB
November 06 2023 09:15:52
0 / 0
0644
keyboard.h
0.611 KB
November 06 2023 09:15:52
0 / 0
0644
kfifo.h
25.281 KB
November 06 2023 09:15:52
0 / 0
0644
kgdb.h
10.709 KB
November 06 2023 09:15:52
0 / 0
0644
khugepaged.h
1.977 KB
November 06 2023 09:15:52
0 / 0
0644
klist.h
1.88 KB
November 06 2023 09:15:52
0 / 0
0644
kmemcheck.h
4.241 KB
November 06 2023 09:15:52
0 / 0
0644
kmemleak.h
3.119 KB
November 06 2023 09:15:52
0 / 0
0644
kmod.h
3.212 KB
November 06 2023 09:15:52
0 / 0
0644
kmsg_dump.h
2.854 KB
November 06 2023 09:15:52
0 / 0
0644
kobj_map.h
0.494 KB
November 06 2023 09:15:52
0 / 0
0644
kobject.h
6.756 KB
November 06 2023 09:15:52
0 / 0
0644
kobject_ns.h
1.938 KB
November 06 2023 09:15:52
0 / 0
0644
kprobes.h
13.345 KB
November 06 2023 09:15:52
0 / 0
0644
kref.h
5.46 KB
November 06 2023 09:15:52
0 / 0
0644
ks0108.h
1.569 KB
November 06 2023 09:15:52
0 / 0
0644
ks8842.h
1.194 KB
November 06 2023 09:15:52
0 / 0
0644
ks8851_mll.h
1.038 KB
November 06 2023 09:15:52
0 / 0
0644
ksm.h
2.84 KB
November 06 2023 09:15:52
0 / 0
0644
kthread.h
4.412 KB
November 06 2023 09:15:52
0 / 0
0644
ktime.h
11.761 KB
November 06 2023 09:15:52
0 / 0
0644
kvm_host.h
34.924 KB
November 06 2023 09:15:52
0 / 0
0644
kvm_irqfd.h
2.386 KB
November 06 2023 09:15:52
0 / 0
0644
kvm_para.h
0.254 KB
November 06 2023 09:15:52
0 / 0
0644
kvm_types.h
1.587 KB
November 06 2023 09:15:52
0 / 0
0644
l2tp.h
0.217 KB
November 06 2023 09:15:52
0 / 0
0644
lapb.h
1.673 KB
November 06 2023 09:15:52
0 / 0
0644
latencytop.h
1.141 KB
November 06 2023 09:15:52
0 / 0
0644
lcd.h
3.919 KB
November 06 2023 09:15:52
0 / 0
0644
lcm.h
0.15 KB
November 06 2023 09:15:52
0 / 0
0644
led-lm3530.h
3.704 KB
November 06 2023 09:15:52
0 / 0
0644
leds-bd2802.h
0.627 KB
November 06 2023 09:15:52
0 / 0
0644
leds-lp3944.h
1.073 KB
November 06 2023 09:15:52
0 / 0
0644
leds-pca9532.h
1.024 KB
November 06 2023 09:15:52
0 / 0
0644
leds-regulator.h
1.286 KB
November 06 2023 09:15:52
0 / 0
0644
leds-tca6507.h
1.018 KB
November 06 2023 09:15:52
0 / 0
0644
leds.h
8.801 KB
November 06 2023 09:15:52
0 / 0
0644
leds_pwm.h
0.359 KB
November 06 2023 09:15:52
0 / 0
0644
lglock.h
2.46 KB
November 06 2023 09:15:52
0 / 0
0644
lguest.h
2.242 KB
November 06 2023 09:15:52
0 / 0
0644
lguest_launcher.h
2.475 KB
November 06 2023 09:15:52
0 / 0
0644
libata.h
63.278 KB
November 06 2023 09:15:52
0 / 0
0644
libfdt.h
0.2 KB
November 06 2023 09:15:52
0 / 0
0644
libfdt_env.h
0.277 KB
November 06 2023 09:15:52
0 / 0
0644
libnvdimm.h
9.087 KB
November 06 2023 09:15:52
0 / 0
0644
libps2.h
2.028 KB
November 06 2023 09:15:52
0 / 0
0644
license.h
0.365 KB
November 06 2023 09:15:52
0 / 0
0644
linkage.h
2.463 KB
November 06 2023 09:15:52
0 / 0
0644
linux_logo.h
2.024 KB
November 06 2023 09:15:52
0 / 0
0644
lis3lv02d.h
4.967 KB
November 06 2023 09:15:52
0 / 0
0644
list.h
22.998 KB
November 06 2023 09:15:52
0 / 0
0644
list_bl.h
4.723 KB
November 06 2023 09:15:52
0 / 0
0644
list_lru.h
4.503 KB
November 06 2023 09:15:52
0 / 0
0644
list_nulls.h
3.364 KB
November 06 2023 09:15:52
0 / 0
0644
list_sort.h
0.232 KB
November 06 2023 09:15:52
0 / 0
0644
livepatch.h
8.393 KB
November 06 2023 09:15:52
0 / 0
0644
llc.h
0.731 KB
November 06 2023 09:15:52
0 / 0
0644
llist.h
7.138 KB
November 06 2023 09:15:52
0 / 0
0644
lockdep.h
16.72 KB
November 06 2023 09:15:52
0 / 0
0644
lockref.h
1.443 KB
November 06 2023 09:15:52
0 / 0
0644
log2.h
5.04 KB
November 06 2023 09:15:52
0 / 0
0644
loop.h
2.16 KB
November 06 2023 09:15:52
0 / 0
0644
lp.h
2.723 KB
November 06 2023 09:15:52
0 / 0
0644
lru_cache.h
12.426 KB
November 06 2023 09:15:52
0 / 0
0644
lsm_audit.h
2.689 KB
November 06 2023 09:15:52
0 / 0
0644
lzo.h
1.333 KB
November 06 2023 09:15:52
0 / 0
0644
m48t86.h
0.454 KB
November 06 2023 09:15:52
0 / 0
0644
mISDNdsp.h
1.15 KB
November 06 2023 09:15:52
0 / 0
0644
mISDNhw.h
5.782 KB
November 06 2023 09:15:52
0 / 0
0644
mISDNif.h
14.927 KB
November 06 2023 09:15:52
0 / 0
0644
mailbox.h
0.74 KB
November 06 2023 09:15:52
0 / 0
0644
mailbox_client.h
1.794 KB
November 06 2023 09:15:52
0 / 0
0644
mailbox_controller.h
5.373 KB
November 06 2023 09:15:52
0 / 0
0644
maple.h
2.672 KB
November 06 2023 09:15:52
0 / 0
0644
marvell_phy.h
0.696 KB
November 06 2023 09:15:52
0 / 0
0644
math64.h
5.467 KB
November 06 2023 09:15:52
0 / 0
0644
max17040_battery.h
0.463 KB
November 06 2023 09:15:52
0 / 0
0644
mbcache.h
1.456 KB
November 06 2023 09:15:52
0 / 0
0644
mbus.h
1.864 KB
November 06 2023 09:15:52
0 / 0
0644
mc146818rtc.h
4.216 KB
November 06 2023 09:15:52
0 / 0
0644
mc6821.h
1.143 KB
November 06 2023 09:15:52
0 / 0
0644
mdev.h
5.2 KB
November 06 2023 09:15:52
0 / 0
0644
mdio-bitbang.h
1.141 KB
November 06 2023 09:15:52
0 / 0
0644
mdio-gpio.h
0.64 KB
November 06 2023 09:15:52
0 / 0
0644
mdio-mux.h
0.538 KB
November 06 2023 09:15:52
0 / 0
0644
mdio.h
6.746 KB
November 06 2023 09:15:52
0 / 0
0644
media-bus-format.h
4.953 KB
November 06 2023 09:15:52
0 / 0
0644
mei_cl_bus.h
3.253 KB
November 06 2023 09:15:52
0 / 0
0644
mem_encrypt.h
1.21 KB
November 06 2023 09:15:52
0 / 0
0644
memblock.h
13.154 KB
November 06 2023 09:15:52
0 / 0
0644
memcontrol.h
16.781 KB
November 06 2023 09:15:52
0 / 0
0644
memory.h
4.874 KB
November 06 2023 09:15:52
0 / 0
0644
memory_hotplug.h
8.428 KB
November 06 2023 09:15:52
0 / 0
0644
mempolicy.h
8.067 KB
November 06 2023 09:15:52
0 / 0
0644
mempool.h
2.273 KB
November 06 2023 09:15:52
0 / 0
0644
memremap.h
5.234 KB
November 06 2023 09:15:52
0 / 0
0644
memstick.h
9.732 KB
November 06 2023 09:15:52
0 / 0
0644
mg_disk.h
1.027 KB
November 06 2023 09:15:52
0 / 0
0644
micrel_phy.h
1.034 KB
November 06 2023 09:15:52
0 / 0
0644
migrate.h
8.076 KB
November 06 2023 09:15:52
0 / 0
0644
migrate_mode.h
0.728 KB
November 06 2023 09:15:52
0 / 0
0644
mii.h
8.702 KB
November 06 2023 09:15:52
0 / 0
0644
miscdevice.h
2.2 KB
November 06 2023 09:15:52
0 / 0
0644
mm-arch-hooks.h
0.663 KB
November 06 2023 09:15:52
0 / 0
0644
mm.h
79.026 KB
November 06 2023 09:15:52
0 / 0
0644
mm_inline.h
2.684 KB
November 06 2023 09:15:52
0 / 0
0644
mm_types.h
18.602 KB
November 06 2023 09:15:52
0 / 0
0644
mman.h
3.096 KB
November 06 2023 09:15:52
0 / 0
0644
mmdebug.h
1.095 KB
November 06 2023 09:15:52
0 / 0
0644
mmiotrace.h
2.996 KB
November 06 2023 09:15:52
0 / 0
0644
mmu_context.h
0.331 KB
November 06 2023 09:15:52
0 / 0
0644
mmu_notifier.h
16.146 KB
November 06 2023 09:15:52
0 / 0
0644
mmzone.h
42.224 KB
November 06 2023 09:15:52
0 / 0
0644
mnt_namespace.h
0.496 KB
November 06 2023 09:15:52
0 / 0
0644
mod_devicetable.h
17.82 KB
November 06 2023 09:15:52
0 / 0
0644
module.h
20.108 KB
November 06 2023 09:15:52
0 / 0
0644
moduleloader.h
2.423 KB
November 06 2023 09:15:52
0 / 0
0644
moduleparam.h
16.402 KB
November 06 2023 09:15:52
0 / 0
0644
mount.h
3.301 KB
November 06 2023 09:15:52
0 / 0
0644
mpage.h
0.705 KB
November 06 2023 09:15:52
0 / 0
0644
mpi.h
5.32 KB
November 06 2023 09:15:52
0 / 0
0644
mpls.h
0.347 KB
November 06 2023 09:15:52
0 / 0
0644
mroute.h
4.673 KB
November 06 2023 09:15:52
0 / 0
0644
mroute6.h
3.246 KB
November 06 2023 09:15:52
0 / 0
0644
msdos_fs.h
0.229 KB
November 06 2023 09:15:52
0 / 0
0644
msg.h
1.256 KB
November 06 2023 09:15:52
0 / 0
0644
msi.h
2.948 KB
November 06 2023 09:15:52
0 / 0
0644
msm_mdp.h
2.087 KB
November 06 2023 09:15:52
0 / 0
0644
mutex-debug.h
0.462 KB
November 06 2023 09:15:52
0 / 0
0644
mutex.h
5.711 KB
November 06 2023 09:15:52
0 / 0
0644
mv643xx.h
52.399 KB
November 06 2023 09:15:52
0 / 0
0644
mv643xx_eth.h
1.832 KB
November 06 2023 09:15:52
0 / 0
0644
mv643xx_i2c.h
0.532 KB
November 06 2023 09:15:52
0 / 0
0644
mxm-wmi.h
1.053 KB
November 06 2023 09:15:52
0 / 0
0644
n_r3964.h
4.058 KB
November 06 2023 09:15:52
0 / 0
0644
namei.h
2.811 KB
November 06 2023 09:15:52
0 / 0
0644
namei_lookup.h
0.901 KB
November 06 2023 09:15:52
0 / 0
0644
nbd.h
1.342 KB
November 06 2023 09:15:52
0 / 0
0644
nd.h
5.912 KB
November 06 2023 09:15:52
0 / 0
0644
ndctl.h
0.658 KB
November 06 2023 09:15:52
0 / 0
0644
net.h
10.185 KB
November 06 2023 09:15:52
0 / 0
0644
net_dim.h
10.962 KB
November 06 2023 09:15:52
0 / 0
0644
netdev_features.h
9.441 KB
November 06 2023 09:15:52
0 / 0
0644
netdevice.h
147.077 KB
November 06 2023 09:15:52
0 / 0
0644
netfilter.h
11.763 KB
November 06 2023 09:15:52
0 / 0
0644
netfilter_bridge.h
1.766 KB
November 06 2023 09:15:52
0 / 0
0644
netfilter_defs.h
0.195 KB
November 06 2023 09:15:52
0 / 0
0644
netfilter_ipv4.h
0.397 KB
November 06 2023 09:15:52
0 / 0
0644
netfilter_ipv6.h
1.379 KB
November 06 2023 09:15:52
0 / 0
0644
netlink.h
6.215 KB
November 06 2023 09:15:52
0 / 0
0644
netpoll.h
2.938 KB
November 06 2023 09:15:52
0 / 0
0644
nfs.h
1.27 KB
November 06 2023 09:15:52
0 / 0
0644
nfs3.h
0.216 KB
November 06 2023 09:15:52
0 / 0
0644
nfs4.h
16.91 KB
November 06 2023 09:15:52
0 / 0
0644
nfs_fs.h
16.607 KB
November 06 2023 09:15:52
0 / 0
0644
nfs_fs_i.h
0.263 KB
November 06 2023 09:15:52
0 / 0
0644
nfs_fs_sb.h
8.636 KB
November 06 2023 09:15:52
0 / 0
0644
nfs_iostat.h
4.146 KB
November 06 2023 09:15:52
0 / 0
0644
nfs_page.h
5.835 KB
November 06 2023 09:15:52
0 / 0
0644
nfs_xdr.h
38.689 KB
November 06 2023 09:15:52
0 / 0
0644
nfsacl.h
1.11 KB
November 06 2023 09:15:52
0 / 0
0644
nilfs2_fs.h
23.474 KB
November 06 2023 09:15:52
0 / 0
0644
nl802154.h
4.234 KB
November 06 2023 09:15:52
0 / 0
0644
nls.h
2.959 KB
November 06 2023 09:15:52
0 / 0
0644
nmi.h
2.453 KB
November 06 2023 09:15:52
0 / 0
0644
node.h
2.182 KB
November 06 2023 09:15:52
0 / 0
0644
nodemask.h
16.468 KB
November 06 2023 09:15:52
0 / 0
0644
nospec.h
2.158 KB
November 06 2023 09:15:52
0 / 0
0644
notifier.h
7.654 KB
November 06 2023 09:15:52
0 / 0
0644
nsc_gpio.h
1.387 KB
November 06 2023 09:15:52
0 / 0
0644
nsproxy.h
2.214 KB
November 06 2023 09:15:52
0 / 0
0644
ntb.h
30.499 KB
November 06 2023 09:15:52
0 / 0
0644
ntb_transport.h
3.801 KB
November 06 2023 09:15:52
0 / 0
0644
nubus.h
4.096 KB
November 06 2023 09:15:52
0 / 0
0644
numa.h
0.247 KB
November 06 2023 09:15:52
0 / 0
0644
nvme-fc-driver.h
38.029 KB
November 06 2023 09:15:52
0 / 0
0644
nvme-fc.h
8.394 KB
November 06 2023 09:15:52
0 / 0
0644
nvme-rdma.h
2.438 KB
November 06 2023 09:15:52
0 / 0
0644
nvme.h
25.372 KB
November 06 2023 09:15:52
0 / 0
0644
nvmem-consumer.h
2.111 KB
November 06 2023 09:15:52
0 / 0
0644
nvmem-provider.h
1.521 KB
November 06 2023 09:15:52
0 / 0
0644
nvram.h
0.445 KB
November 06 2023 09:15:52
0 / 0
0644
nwpserial.h
0.538 KB
November 06 2023 09:15:52
0 / 0
0644
of.h
24.801 KB
November 06 2023 09:15:52
0 / 0
0644
of_address.h
2.162 KB
November 06 2023 09:15:52
0 / 0
0644
of_device.h
1.993 KB
November 06 2023 09:15:52
0 / 0
0644
of_dma.h
1.733 KB
November 06 2023 09:15:52
0 / 0
0644
of_fdt.h
4.618 KB
November 06 2023 09:15:52
0 / 0
0644
of_gpio.h
5.174 KB
November 06 2023 09:15:52
0 / 0
0644
of_graph.h
3.556 KB
November 06 2023 09:15:52
0 / 0
0644
of_iommu.h
1.008 KB
November 06 2023 09:15:52
0 / 0
0644
of_irq.h
2.896 KB
November 06 2023 09:15:52
0 / 0
0644
of_mdio.h
1.55 KB
November 06 2023 09:15:52
0 / 0
0644
of_mtd.h
0.431 KB
November 06 2023 09:15:52
0 / 0
0644
of_net.h
0.507 KB
November 06 2023 09:15:52
0 / 0
0644
of_pci.h
0.954 KB
November 06 2023 09:15:52
0 / 0
0644
of_pdt.h
1.434 KB
November 06 2023 09:15:52
0 / 0
0644
of_platform.h
3.835 KB
November 06 2023 09:15:52
0 / 0
0644
oid_registry.h
3.646 KB
November 06 2023 09:15:52
0 / 0
0644
olpc-ec.h
1.008 KB
November 06 2023 09:15:52
0 / 0
0644
omap-dma.h
11.555 KB
November 06 2023 09:15:52
0 / 0
0644
omap-iommu.h
1.686 KB
November 06 2023 09:15:52
0 / 0
0644
omapfb.h
1.217 KB
November 06 2023 09:15:52
0 / 0
0644
oom.h
2.93 KB
November 06 2023 09:15:52
0 / 0
0644
openvswitch.h
0.824 KB
November 06 2023 09:15:52
0 / 0
0644
opp.h
2.931 KB
November 06 2023 09:15:52
0 / 0
0644
oprofile.h
6.292 KB
November 06 2023 09:15:52
0 / 0
0644
osq_lock.h
1.003 KB
November 06 2023 09:15:52
0 / 0
0644
overflow.h
9.235 KB
November 06 2023 09:15:52
0 / 0
0644
oxu210hp.h
0.154 KB
November 06 2023 09:15:52
0 / 0
0644
padata.h
6.386 KB
November 06 2023 09:15:52
0 / 0
0644
page-flags-layout.h
3.031 KB
November 06 2023 09:15:52
0 / 0
0644
page-flags.h
19.842 KB
November 06 2023 09:15:52
0 / 0
0644
page-isolation.h
1.781 KB
November 06 2023 09:15:52
0 / 0
0644
page_cgroup.h
3.527 KB
November 06 2023 09:15:52
0 / 0
0644
page_counter.h
1.403 KB
November 06 2023 09:15:52
0 / 0
0644
page_ext.h
1.65 KB
November 06 2023 09:15:52
0 / 0
0644
page_idle.h
2.119 KB
November 06 2023 09:15:52
0 / 0
0644
page_owner.h
1.248 KB
November 06 2023 09:15:52
0 / 0
0644
page_ref.h
2.2 KB
November 06 2023 09:15:52
0 / 0
0644
pageblock-flags.h
2.738 KB
November 06 2023 09:15:52
0 / 0
0644
pagemap.h
17.609 KB
November 06 2023 09:15:52
0 / 0
0644
pagevec.h
1.687 KB
November 06 2023 09:15:52
0 / 0
0644
parman.h
2.865 KB
November 06 2023 09:15:52
0 / 0
0644
parport.h
16.7 KB
November 06 2023 09:15:52
0 / 0
0644
parport_pc.h
6.518 KB
November 06 2023 09:15:52
0 / 0
0644
parser.h
1.001 KB
November 06 2023 09:15:52
0 / 0
0644
pata_arasan_cf_data.h
1.225 KB
November 06 2023 09:15:52
0 / 0
0644
patchkey.h
0.701 KB
November 06 2023 09:15:52
0 / 0
0644
path.h
0.502 KB
November 06 2023 09:15:52
0 / 0
0644
pch_dma.h
0.976 KB
November 06 2023 09:15:52
0 / 0
0644
pci-acpi.h
3.265 KB
November 06 2023 09:15:52
0 / 0
0644
pci-aspm.h
1.673 KB
November 06 2023 09:15:52
0 / 0
0644
pci-ats.h
1.448 KB
November 06 2023 09:15:52
0 / 0
0644
pci-dma-compat.h
4.503 KB
November 06 2023 09:15:52
0 / 0
0644
pci.h
76.525 KB
November 06 2023 09:15:52
0 / 0
0644
pci_hotplug.h
7.246 KB
November 06 2023 09:15:52
0 / 0
0644
pci_ids.h
118.847 KB
November 06 2023 09:15:52
0 / 0
0644
pcieport_if.h
2.299 KB
November 06 2023 09:15:52
0 / 0
0644
pda_power.h
1.124 KB
November 06 2023 09:15:52
0 / 0
0644
pe.h
15.476 KB
November 06 2023 09:15:52
0 / 0
0644
percpu-defs.h
7.488 KB
November 06 2023 09:15:52
0 / 0
0644
percpu-refcount.h
9.434 KB
November 06 2023 09:15:52
0 / 0
0644
percpu-rwsem.h
0.905 KB
November 06 2023 09:15:52
0 / 0
0644
percpu.h
25.955 KB
November 06 2023 09:15:52
0 / 0
0644
percpu_counter.h
4.206 KB
November 06 2023 09:15:52
0 / 0
0644
percpu_ida.h
2.279 KB
November 06 2023 09:15:52
0 / 0
0644
perf_event.h
37.155 KB
November 06 2023 09:15:52
0 / 0
0644
perf_regs.h
0.946 KB
November 06 2023 09:15:52
0 / 0
0644
personality.h
1.513 KB
November 06 2023 09:15:52
0 / 0
0644
pfn.h
0.612 KB
November 06 2023 09:15:52
0 / 0
0644
pfn_t.h
3.187 KB
November 06 2023 09:15:52
0 / 0
0644
phonedev.h
0.532 KB
November 06 2023 09:15:52
0 / 0
0644
phonet.h
1.119 KB
November 06 2023 09:15:52
0 / 0
0644
phy.h
30.428 KB
November 06 2023 09:15:52
0 / 0
0644
phy_fixed.h
1.606 KB
November 06 2023 09:15:52
0 / 0
0644
pid.h
5.779 KB
November 06 2023 09:15:52
0 / 0
0644
pid_namespace.h
2.393 KB
November 06 2023 09:15:52
0 / 0
0644
pim.h
0.626 KB
November 06 2023 09:15:52
0 / 0
0644
pipe_fs_i.h
6 KB
November 06 2023 09:15:52
0 / 0
0644
pkeys.h
0.856 KB
November 06 2023 09:15:52
0 / 0
0644
pktcdvd.h
5.871 KB
November 06 2023 09:15:52
0 / 0
0644
platform_device.h
10.544 KB
November 06 2023 09:15:52
0 / 0
0644
plist.h
8.695 KB
November 06 2023 09:15:52
0 / 0
0644
pm.h
29.698 KB
November 06 2023 09:15:52
0 / 0
0644
pm2301_charger.h
1.683 KB
November 06 2023 09:15:52
0 / 0
0644
pm_clock.h
1.665 KB
November 06 2023 09:15:52
0 / 0
0644
pm_domain.h
9.578 KB
November 06 2023 09:15:52
0 / 0
0644
pm_qos.h
8.11 KB
November 06 2023 09:15:52
0 / 0
0644
pm_runtime.h
8.157 KB
November 06 2023 09:15:52
0 / 0
0644
pm_wakeup.h
5.925 KB
November 06 2023 09:15:52
0 / 0
0644
pmu.h
2.298 KB
November 06 2023 09:15:52
0 / 0
0644
pnfs_osd_xdr.h
9.269 KB
November 06 2023 09:15:52
0 / 0
0644
pnp.h
14.823 KB
November 06 2023 09:15:52
0 / 0
0644
poison.h
2.535 KB
November 06 2023 09:15:52
0 / 0
0644
poll.h
4.471 KB
November 06 2023 09:15:52
0 / 0
0644
posix-clock.h
5.427 KB
November 06 2023 09:15:52
0 / 0
0644
posix-timers.h
4.124 KB
November 06 2023 09:15:52
0 / 0
0644
posix_acl.h
4.229 KB
November 06 2023 09:15:52
0 / 0
0644
posix_acl_xattr.h
1.783 KB
November 06 2023 09:15:52
0 / 0
0644
power_supply.h
10.628 KB
November 06 2023 09:15:52
0 / 0
0644
powercap.h
12.575 KB
November 06 2023 09:15:52
0 / 0
0644
ppp-comp.h
3.098 KB
November 06 2023 09:15:52
0 / 0
0644
ppp_channel.h
3.072 KB
November 06 2023 09:15:52
0 / 0
0644
ppp_defs.h
0.443 KB
November 06 2023 09:15:52
0 / 0
0644
pps-gpio.h
0.991 KB
November 06 2023 09:15:52
0 / 0
0644
pps_kernel.h
3.537 KB
November 06 2023 09:15:52
0 / 0
0644
pr.h
0.515 KB
November 06 2023 09:15:52
0 / 0
0644
preempt.h
4.633 KB
November 06 2023 09:15:52
0 / 0
0644
preempt_mask.h
4.405 KB
November 06 2023 09:15:52
0 / 0
0644
prefetch.h
1.5 KB
November 06 2023 09:15:52
0 / 0
0644
printk.h
11.78 KB
November 06 2023 09:15:52
0 / 0
0644
prio_heap.h
1.763 KB
November 06 2023 09:15:52
0 / 0
0644
proc_fs.h
2.984 KB
November 06 2023 09:15:52
0 / 0
0644
proc_ns.h
1.902 KB
November 06 2023 09:15:52
0 / 0
0644
profile.h
2.59 KB
November 06 2023 09:15:52
0 / 0
0644
projid.h
2.385 KB
November 06 2023 09:15:52
0 / 0
0644
property.h
7.698 KB
November 06 2023 09:15:52
0 / 0
0644
proportions.h
3.169 KB
November 06 2023 09:15:52
0 / 0
0644
pstore.h
2.624 KB
November 06 2023 09:15:52
0 / 0
0644
pstore_ram.h
2.316 KB
November 06 2023 09:15:52
0 / 0
0644
pti.h
1.525 KB
November 06 2023 09:15:52
0 / 0
0644
ptp_classify.h
5.47 KB
November 06 2023 09:15:52
0 / 0
0644
ptp_clock_kernel.h
8.615 KB
November 06 2023 09:15:52
0 / 0
0644
ptr_ring.h
16.481 KB
November 06 2023 09:15:52
0 / 0
0644
ptrace.h
15.064 KB
November 06 2023 09:15:52
0 / 0
0644
pvclock_gtod.h
0.497 KB
November 06 2023 09:15:52
0 / 0
0644
pwm.h
7.177 KB
November 06 2023 09:15:52
0 / 0
0644
pwm_backlight.h
0.606 KB
November 06 2023 09:15:52
0 / 0
0644
pxa168_eth.h
0.627 KB
November 06 2023 09:15:52
0 / 0
0644
pxa2xx_ssp.h
8.27 KB
November 06 2023 09:15:52
0 / 0
0644
qnx6_fs.h
3.232 KB
November 06 2023 09:15:52
0 / 0
0644
quicklist.h
2.101 KB
November 06 2023 09:15:52
0 / 0
0644
quota.h
14.106 KB
November 06 2023 09:15:52
0 / 0
0644
quotaops.h
9.797 KB
November 06 2023 09:15:52
0 / 0
0644
radix-tree.h
19.883 KB
November 06 2023 09:15:52
0 / 0
0644
raid_class.h
2.081 KB
November 06 2023 09:15:52
0 / 0
0644
ramfs.h
0.965 KB
November 06 2023 09:15:52
0 / 0
0644
random.h
3.286 KB
November 06 2023 09:15:52
0 / 0
0644
range.h
0.598 KB
November 06 2023 09:15:52
0 / 0
0644
ras.h
0.344 KB
November 06 2023 09:15:52
0 / 0
0644
ratelimit.h
2.323 KB
November 06 2023 09:15:52
0 / 0
0644
rational.h
0.586 KB
November 06 2023 09:15:52
0 / 0
0644
rbtree.h
3.943 KB
November 06 2023 09:15:52
0 / 0
0644
rbtree_augmented.h
7.072 KB
November 06 2023 09:15:52
0 / 0
0644
rbtree_latch.h
6.643 KB
November 06 2023 09:15:52
0 / 0
0644
rculist.h
21.448 KB
November 06 2023 09:15:52
0 / 0
0644
rculist_bl.h
4.321 KB
November 06 2023 09:15:52
0 / 0
0644
rculist_nulls.h
6.121 KB
November 06 2023 09:15:52
0 / 0
0644
rcupdate.h
38.397 KB
November 06 2023 09:15:52
0 / 0
0644
rcutiny.h
3.998 KB
November 06 2023 09:15:52
0 / 0
0644
rcutree.h
3.403 KB
November 06 2023 09:15:52
0 / 0
0644
reboot.h
1.313 KB
November 06 2023 09:15:52
0 / 0
0644
reciprocal_div.h
0.97 KB
November 06 2023 09:15:52
0 / 0
0644
refcount.h
2.452 KB
November 06 2023 09:15:52
0 / 0
0644
regmap.h
21.462 KB
November 06 2023 09:15:52
0 / 0
0644
regset.h
12.995 KB
November 06 2023 09:15:52
0 / 0
0644
relay.h
8.61 KB
November 06 2023 09:15:52
0 / 0
0644
remoteproc.h
17.213 KB
November 06 2023 09:15:52
0 / 0
0644
res_counter.h
5.678 KB
November 06 2023 09:15:52
0 / 0
0644
reservation.h
9.01 KB
November 06 2023 09:15:52
0 / 0
0644
reset-controller.h
1.706 KB
November 06 2023 09:15:52
0 / 0
0644
reset.h
0.497 KB
November 06 2023 09:15:52
0 / 0
0644
resource.h
0.299 KB
November 06 2023 09:15:52
0 / 0
0644
resource_ext.h
2.225 KB
November 06 2023 09:15:52
0 / 0
0644
resume-trace.h
0.684 KB
November 06 2023 09:15:52
0 / 0
0644
rfkill-gpio.h
1.64 KB
November 06 2023 09:15:52
0 / 0
0644
rfkill-regulator.h
1.377 KB
November 06 2023 09:15:52
0 / 0
0644
rfkill.h
9.493 KB
November 06 2023 09:15:52
0 / 0
0644
rh_kabi.h
6.42 KB
November 06 2023 09:15:52
0 / 0
0644
rhashtable.h
38.319 KB
November 06 2023 09:15:52
0 / 0
0644
ring_buffer.h
6.617 KB
November 06 2023 09:15:52
0 / 0
0644
rio.h
16.5 KB
November 06 2023 09:15:52
0 / 0
0644
rio_drv.h
13.752 KB
November 06 2023 09:15:52
0 / 0
0644
rio_ids.h
1.246 KB
November 06 2023 09:15:52
0 / 0
0644
rio_regs.h
14.726 KB
November 06 2023 09:15:52
0 / 0
0644
rmap.h
9.264 KB
November 06 2023 09:15:52
0 / 0
0644
rmi.h
9.693 KB
November 06 2023 09:15:52
0 / 0
0644
rndis.h
16.826 KB
November 06 2023 09:15:52
0 / 0
0644
root_dev.h
0.527 KB
November 06 2023 09:15:52
0 / 0
0644
rotary_encoder.h
0.32 KB
November 06 2023 09:15:52
0 / 0
0644
rpmsg.h
11.407 KB
November 06 2023 09:15:52
0 / 0
0644
rslib.h
2.993 KB
November 06 2023 09:15:52
0 / 0
0644
rtc-ds2404.h
0.456 KB
November 06 2023 09:15:52
0 / 0
0644
rtc-v3020.h
1.032 KB
November 06 2023 09:15:52
0 / 0
0644
rtc.h
6.424 KB
November 06 2023 09:15:52
0 / 0
0644
rtmutex.h
2.913 KB
November 06 2023 09:15:52
0 / 0
0644
rtnetlink.h
4.236 KB
November 06 2023 09:15:52
0 / 0
0644
rwlock.h
4.289 KB
November 06 2023 09:15:52
0 / 0
0644
rwlock_api_smp.h
7.632 KB
November 06 2023 09:15:52
0 / 0
0644
rwlock_types.h
1.179 KB
November 06 2023 09:15:52
0 / 0
0644
rwsem-spinlock.h
1.479 KB
November 06 2023 09:15:52
0 / 0
0644
rwsem.h
5.806 KB
November 06 2023 09:15:52
0 / 0
0644
rxrpc.h
2.331 KB
November 06 2023 09:15:52
0 / 0
0644
s3c_adc_battery.h
0.91 KB
November 06 2023 09:15:52
0 / 0
0644
sa11x0-dma.h
0.559 KB
November 06 2023 09:15:52
0 / 0
0644
sbitmap.h
14.015 KB
November 06 2023 09:15:52
0 / 0
0644
scatterlist.h
12.157 KB
November 06 2023 09:15:52
0 / 0
0644
scc.h
2.799 KB
November 06 2023 09:15:52
0 / 0
0644
sched.h
97.418 KB
November 06 2023 09:15:52
0 / 0
0644
screen_info.h
0.559 KB
November 06 2023 09:15:52
0 / 0
0644
sctp.h
22.086 KB
November 06 2023 09:15:52
0 / 0
0644
scx200.h
1.781 KB
November 06 2023 09:15:52
0 / 0
0644
scx200_gpio.h
2.343 KB
November 06 2023 09:15:52
0 / 0
0644
sdla.h
6.9 KB
November 06 2023 09:15:52
0 / 0
0644
seccomp.h
2.153 KB
November 06 2023 09:15:52
0 / 0
0644
securebits.h
0.195 KB
November 06 2023 09:15:52
0 / 0
0644
security.h
121.274 KB
November 06 2023 09:15:52
0 / 0
0644
selection.h
1.327 KB
November 06 2023 09:15:52
0 / 0
0644
selinux.h
0.889 KB
November 06 2023 09:15:52
0 / 0
0644
sem.h
1.251 KB
November 06 2023 09:15:52
0 / 0
0644
semaphore.h
1.359 KB
November 06 2023 09:15:52
0 / 0
0644
seq_buf.h
1.124 KB
November 06 2023 09:15:52
0 / 0
0644
seq_file.h
7.364 KB
November 06 2023 09:15:52
0 / 0
0644
seq_file_net.h
0.658 KB
November 06 2023 09:15:52
0 / 0
0644
seqlock.h
15.873 KB
November 06 2023 09:15:52
0 / 0
0644
seqno-fence.h
3.955 KB
November 06 2023 09:15:52
0 / 0
0644
serial.h
0.615 KB
November 06 2023 09:15:52
0 / 0
0644
serial_8250.h
4.233 KB
November 06 2023 09:15:52
0 / 0
0644
serial_core.h
11.733 KB
November 06 2023 09:15:52
0 / 0
0644
serial_max3100.h
1.39 KB
November 06 2023 09:15:52
0 / 0
0644
serial_mfd.h
1.254 KB
November 06 2023 09:15:52
0 / 0
0644
serial_pnx8xxx.h
2.607 KB
November 06 2023 09:15:52
0 / 0
0644
serial_s3c.h
7.954 KB
November 06 2023 09:15:52
0 / 0
0644
serial_sci.h
3.563 KB
November 06 2023 09:15:52
0 / 0
0644
serio.h
4.156 KB
November 06 2023 09:15:52
0 / 0
0644
sfi.h
5.677 KB
November 06 2023 09:15:52
0 / 0
0644
sfi_acpi.h
3.399 KB
November 06 2023 09:15:52
0 / 0
0644
sh_clk.h
5.907 KB
November 06 2023 09:15:52
0 / 0
0644
sh_dma.h
2.329 KB
November 06 2023 09:15:52
0 / 0
0644
sh_eth.h
0.48 KB
November 06 2023 09:15:52
0 / 0
0644
sh_intc.h
3.386 KB
November 06 2023 09:15:52
0 / 0
0644
sh_timer.h
0.219 KB
November 06 2023 09:15:52
0 / 0
0644
shdma-base.h
4.056 KB
November 06 2023 09:15:52
0 / 0
0644
shm.h
1.783 KB
November 06 2023 09:15:52
0 / 0
0644
shmem_fs.h
3.572 KB
November 06 2023 09:15:52
0 / 0
0644
shrinker.h
1.443 KB
November 06 2023 09:15:52
0 / 0
0644
signal.h
12.854 KB
November 06 2023 09:15:52
0 / 0
0644
signalfd.h
0.729 KB
November 06 2023 09:15:52
0 / 0
0644
siphash.h
2.765 KB
November 06 2023 09:15:52
0 / 0
0644
sirfsoc_dma.h
0.12 KB
November 06 2023 09:15:52
0 / 0
0644
sizes.h
1.194 KB
November 06 2023 09:15:52
0 / 0
0644
skb_array.h
5.166 KB
November 06 2023 09:15:52
0 / 0
0644
skbuff.h
114.936 KB
November 06 2023 09:15:52
0 / 0
0644
slab.h
18.757 KB
November 06 2023 09:15:52
0 / 0
0644
slab_def.h
4.614 KB
November 06 2023 09:15:52
0 / 0
0644
slob_def.h
0.946 KB
November 06 2023 09:15:52
0 / 0
0644
slub_def.h
6.104 KB
November 06 2023 09:15:52
0 / 0
0644
sm501-regs.h
11.764 KB
November 06 2023 09:15:52
0 / 0
0644
sm501.h
4.632 KB
November 06 2023 09:15:52
0 / 0
0644
smc911x.h
0.249 KB
November 06 2023 09:15:52
0 / 0
0644
smc91x.h
1.046 KB
November 06 2023 09:15:52
0 / 0
0644
smp.h
5.903 KB
November 06 2023 09:15:52
0 / 0
0644
smpboot.h
2.147 KB
November 06 2023 09:15:52
0 / 0
0644
smsc911x.h
2.251 KB
November 06 2023 09:15:52
0 / 0
0644
smscphy.h
1.215 KB
November 06 2023 09:15:52
0 / 0
0644
sock_diag.h
0.889 KB
November 06 2023 09:15:52
0 / 0
0644
socket.h
11.284 KB
November 06 2023 09:15:52
0 / 0
0644
sonet.h
0.42 KB
November 06 2023 09:15:52
0 / 0
0644
sony-laptop.h
1.244 KB
November 06 2023 09:15:52
0 / 0
0644
sonypi.h
2.354 KB
November 06 2023 09:15:52
0 / 0
0644
sort.h
0.203 KB
November 06 2023 09:15:52
0 / 0
0644
sound.h
0.75 KB
November 06 2023 09:15:52
0 / 0
0644
soundcard.h
1.593 KB
November 06 2023 09:15:52
0 / 0
0644
spinlock.h
12.38 KB
November 06 2023 09:15:52
0 / 0
0644
spinlock_api_smp.h
5.464 KB
November 06 2023 09:15:52
0 / 0
0644
spinlock_api_up.h
3.375 KB
November 06 2023 09:15:52
0 / 0
0644
spinlock_types.h
2.122 KB
November 06 2023 09:15:52
0 / 0
0644
spinlock_types_up.h
0.709 KB
November 06 2023 09:15:52
0 / 0
0644
spinlock_up.h
2.468 KB
November 06 2023 09:15:52
0 / 0
0644
splice.h
3.247 KB
November 06 2023 09:15:52
0 / 0
0644
srcu.h
10.111 KB
November 06 2023 09:15:52
0 / 0
0644
ssbi.h
1.064 KB
November 06 2023 09:15:52
0 / 0
0644
stackprotector.h
0.278 KB
November 06 2023 09:15:52
0 / 0
0644
stacktrace.h
1.435 KB
November 06 2023 09:15:52
0 / 0
0644
start_kernel.h
0.288 KB
November 06 2023 09:15:52
0 / 0
0644
stat.h
0.728 KB
November 06 2023 09:15:52
0 / 0
0644
statfs.h
1.276 KB
November 06 2023 09:15:52
0 / 0
0644
static_key.h
0.029 KB
November 06 2023 09:15:52
0 / 0
0644
stddef.h
0.77 KB
November 06 2023 09:15:52
0 / 0
0644
ste_modem_shm.h
1.587 KB
November 06 2023 09:15:52
0 / 0
0644
stm.h
4.754 KB
November 06 2023 09:15:52
0 / 0
0644
stmmac.h
3.789 KB
November 06 2023 09:15:52
0 / 0
0644
stmp3xxx_rtc_wdt.h
0.324 KB
November 06 2023 09:15:52
0 / 0
0644
stmp_device.h
0.604 KB
November 06 2023 09:15:52
0 / 0
0644
stop_machine.h
4.542 KB
November 06 2023 09:15:52
0 / 0
0644
string.h
6.272 KB
November 06 2023 09:15:52
0 / 0
0644
string_helpers.h
2.104 KB
November 06 2023 09:15:52
0 / 0
0644
stringify.h
0.333 KB
November 06 2023 09:15:52
0 / 0
0644
sudmac.h
1.239 KB
November 06 2023 09:15:52
0 / 0
0644
sungem_phy.h
3.898 KB
November 06 2023 09:15:52
0 / 0
0644
sunserialcore.h
1.038 KB
November 06 2023 09:15:52
0 / 0
0644
superhyway.h
2.804 KB
November 06 2023 09:15:52
0 / 0
0644
suspend.h
16.145 KB
November 06 2023 09:15:52
0 / 0
0644
svga.h
3.709 KB
November 06 2023 09:15:52
0 / 0
0644
sw842.h
0.282 KB
November 06 2023 09:15:52
0 / 0
0644
swab.h
0.497 KB
November 06 2023 09:15:52
0 / 0
0644
swait.h
6.93 KB
November 06 2023 09:15:52
0 / 0
0644
swap.h
20.783 KB
November 06 2023 09:15:52
0 / 0
0644
swap_slots.h
0.782 KB
November 06 2023 09:15:52
0 / 0
0644
swapfile.h
0.505 KB
November 06 2023 09:15:52
0 / 0
0644
swapops.h
6.925 KB
November 06 2023 09:15:52
0 / 0
0644
swiotlb.h
3.742 KB
November 06 2023 09:15:52
0 / 0
0644
sync_core.h
0.566 KB
November 06 2023 09:15:52
0 / 0
0644
sync_file.h
1.568 KB
November 06 2023 09:15:52
0 / 0
0644
synclink.h
0.966 KB
November 06 2023 09:15:52
0 / 0
0644
sys.h
0.899 KB
November 06 2023 09:15:52
0 / 0
0644
sys_soc.h
0.93 KB
November 06 2023 09:15:52
0 / 0
0644
syscalls.h
38.072 KB
November 06 2023 09:15:52
0 / 0
0644
syscore_ops.h
0.62 KB
November 06 2023 09:15:52
0 / 0
0644
sysctl.h
7.046 KB
November 06 2023 09:15:52
0 / 0
0644
sysfs.h
13.691 KB
November 06 2023 09:15:52
0 / 0
0644
syslog.h
1.89 KB
November 06 2023 09:15:52
0 / 0
0644
sysrq.h
1.842 KB
November 06 2023 09:15:52
0 / 0
0644
sysv_fs.h
8.995 KB
November 06 2023 09:15:52
0 / 0
0644
task_io_accounting.h
1.094 KB
November 06 2023 09:15:52
0 / 0
0644
task_io_accounting_ops.h
2.511 KB
November 06 2023 09:15:52
0 / 0
0644
task_work.h
0.564 KB
November 06 2023 09:15:52
0 / 0
0644
taskstats_kern.h
0.89 KB
November 06 2023 09:15:52
0 / 0
0644
tboot.h
3.992 KB
November 06 2023 09:15:52
0 / 0
0644
tc.h
3.407 KB
November 06 2023 09:15:52
0 / 0
0644
tca6416_keypad.h
0.827 KB
November 06 2023 09:15:52
0 / 0
0644
tcp.h
13.024 KB
November 06 2023 09:15:52
0 / 0
0644
tegra-ahb.h
0.646 KB
November 06 2023 09:15:52
0 / 0
0644
tegra-powergate.h
1.46 KB
November 06 2023 09:15:52
0 / 0
0644
tegra-soc.h
0.773 KB
November 06 2023 09:15:52
0 / 0
0644
textsearch.h
4.69 KB
November 06 2023 09:15:52
0 / 0
0644
textsearch_fsm.h
1.147 KB
November 06 2023 09:15:52
0 / 0
0644
tfrc.h
1.888 KB
November 06 2023 09:15:52
0 / 0
0644
thermal.h
8.435 KB
November 06 2023 09:15:52
0 / 0
0644
thinkpad_acpi.h
0.274 KB
November 06 2023 09:15:52
0 / 0
0644
thread_info.h
4.943 KB
November 06 2023 09:15:52
0 / 0
0644
threads.h
1.24 KB
November 06 2023 09:15:52
0 / 0
0644
thunderbolt.h
18.877 KB
November 06 2023 09:15:52
0 / 0
0644
ti_wilink_st.h
14.051 KB
November 06 2023 09:15:52
0 / 0
0644
tick.h
6.989 KB
November 06 2023 09:15:52
0 / 0
0644
tifm.h
4.805 KB
November 06 2023 09:15:52
0 / 0
0644
timb_dma.h
1.742 KB
November 06 2023 09:15:52
0 / 0
0644
timb_gpio.h
1.277 KB
November 06 2023 09:15:52
0 / 0
0644
time-armada-370-xp.h
0.382 KB
November 06 2023 09:15:52
0 / 0
0644
time.h
6.872 KB
November 06 2023 09:15:52
0 / 0
0644
time64.h
4.856 KB
November 06 2023 09:15:52
0 / 0
0644
timecounter.h
4.613 KB
November 06 2023 09:15:52
0 / 0
0644
timekeeper_internal.h
4.741 KB
November 06 2023 09:15:52
0 / 0
0644
timekeeping.h
5.124 KB
November 06 2023 09:15:52
0 / 0
0644
timer.h
8.471 KB
November 06 2023 09:15:52
0 / 0
0644
timerfd.h
0.976 KB
November 06 2023 09:15:52
0 / 0
0644
timeriomem-rng.h
0.398 KB
November 06 2023 09:15:52
0 / 0
0644
timerqueue.h
1.075 KB
November 06 2023 09:15:52
0 / 0
0644
timex.h
6.344 KB
November 06 2023 09:15:52
0 / 0
0644
tnum.h
2.857 KB
November 06 2023 09:15:52
0 / 0
0644
topology.h
5.559 KB
November 06 2023 09:15:52
0 / 0
0644
toshiba.h
0.883 KB
November 06 2023 09:15:52
0 / 0
0644
tpm.h
3.171 KB
November 06 2023 09:15:52
0 / 0
0644
tpm_command.h
0.789 KB
November 06 2023 09:15:52
0 / 0
0644
tpm_eventlog.h
2.111 KB
November 06 2023 09:15:52
0 / 0
0644
trace.h
0.903 KB
November 06 2023 09:15:52
0 / 0
0644
trace_clock.h
0.613 KB
November 06 2023 09:15:52
0 / 0
0644
trace_seq.h
3.164 KB
November 06 2023 09:15:52
0 / 0
0644
tracehook.h
7.28 KB
November 06 2023 09:15:52
0 / 0
0644
tracepoint.h
12.933 KB
November 06 2023 09:15:52
0 / 0
0644
transport_class.h
2.505 KB
November 06 2023 09:15:52
0 / 0
0644
tsacct_kern.h
1.163 KB
November 06 2023 09:15:52
0 / 0
0644
tty.h
23.262 KB
November 06 2023 09:15:52
0 / 0
0644
tty_driver.h
15.094 KB
November 06 2023 09:15:52
0 / 0
0644
tty_flip.h
1.205 KB
November 06 2023 09:15:52
0 / 0
0644
tty_ldisc.h
7.908 KB
November 06 2023 09:15:52
0 / 0
0644
typecheck.h
0.571 KB
November 06 2023 09:15:52
0 / 0
0644
types.h
4.836 KB
November 06 2023 09:15:52
0 / 0
0644
u64_stats_sync.h
4.803 KB
November 06 2023 09:15:52
0 / 0
0644
uaccess.h
4.221 KB
November 06 2023 09:15:52
0 / 0
0644
ucb1400.h
4.265 KB
November 06 2023 09:15:52
0 / 0
0644
ucs2_string.h
0.608 KB
November 06 2023 09:15:52
0 / 0
0644
udp.h
3.504 KB
November 06 2023 09:15:52
0 / 0
0644
uidgid.h
4.182 KB
November 06 2023 09:15:52
0 / 0
0644
uinput.h
2.084 KB
November 06 2023 09:15:52
0 / 0
0644
uio.h
1.145 KB
November 06 2023 09:15:52
0 / 0
0644
uio_driver.h
3.936 KB
November 06 2023 09:15:52
0 / 0
0644
uprobes.h
5.971 KB
November 06 2023 09:15:52
0 / 0
0644
usb.h
76.122 KB
November 06 2023 09:15:52
0 / 0
0644
usb_usual.h
3.417 KB
November 06 2023 09:15:52
0 / 0
0644
usbdevice_fs.h
2.183 KB
November 06 2023 09:15:52
0 / 0
0644
user-return-notifier.h
1.139 KB
November 06 2023 09:15:52
0 / 0
0644
user.h
0.021 KB
November 06 2023 09:15:52
0 / 0
0644
user_namespace.h
3.928 KB
November 06 2023 09:15:52
0 / 0
0644
userfaultfd_k.h
3.6 KB
November 06 2023 09:15:52
0 / 0
0644
uts.h
0.341 KB
November 06 2023 09:15:52
0 / 0
0644
utsname.h
1.652 KB
November 06 2023 09:15:52
0 / 0
0644
uuid.h
2.998 KB
November 06 2023 09:15:52
0 / 0
0644
uwb.h
25.222 KB
November 06 2023 09:15:52
0 / 0
0644
verify_pefile.h
0.609 KB
November 06 2023 09:15:52
0 / 0
0644
vermagic.h
0.796 KB
November 06 2023 09:15:52
0 / 0
0644
vexpress.h
3.856 KB
November 06 2023 09:15:52
0 / 0
0644
vfio.h
5.582 KB
November 06 2023 09:15:52
0 / 0
0644
vfs.h
0.075 KB
November 06 2023 09:15:52
0 / 0
0644
vga_switcheroo.h
8.703 KB
November 06 2023 09:15:52
0 / 0
0644
vgaarb.h
9.052 KB
November 06 2023 09:15:52
0 / 0
0644
via-core.h
7.268 KB
November 06 2023 09:15:52
0 / 0
0644
via-gpio.h
0.326 KB
November 06 2023 09:15:52
0 / 0
0644
via.h
0.872 KB
November 06 2023 09:15:52
0 / 0
0644
via_i2c.h
1.48 KB
November 06 2023 09:15:52
0 / 0
0644
video_output.h
1.891 KB
November 06 2023 09:15:52
0 / 0
0644
videodev2.h
2.678 KB
November 06 2023 09:15:52
0 / 0
0644
virtio.h
5.959 KB
November 06 2023 09:15:52
0 / 0
0644
virtio_byteorder.h
1.418 KB
November 06 2023 09:15:52
0 / 0
0644
virtio_caif.h
0.48 KB
November 06 2023 09:15:52
0 / 0
0644
virtio_config.h
12.748 KB
November 06 2023 09:15:52
0 / 0
0644
virtio_console.h
1.928 KB
November 06 2023 09:15:52
0 / 0
0644
virtio_mmio.h
4.479 KB
November 06 2023 09:15:52
0 / 0
0644
virtio_ring.h
2.685 KB
November 06 2023 09:15:52
0 / 0
0644
virtio_vsock.h
4.904 KB
November 06 2023 09:15:52
0 / 0
0644
vlynq.h
3.876 KB
November 06 2023 09:15:52
0 / 0
0644
vm_event_item.h
2.195 KB
November 06 2023 09:15:52
0 / 0
0644
vm_sockets.h
0.687 KB
November 06 2023 09:15:52
0 / 0
0644
vmalloc.h
6.413 KB
November 06 2023 09:15:52
0 / 0
0644
vme.h
4.879 KB
November 06 2023 09:15:52
0 / 0
0644
vmpressure.h
1.648 KB
November 06 2023 09:15:52
0 / 0
0644
vmstat.h
7.231 KB
November 06 2023 09:15:52
0 / 0
0644
vmw_vmci_api.h
3.148 KB
November 06 2023 09:15:52
0 / 0
0644
vmw_vmci_defs.h
28.036 KB
November 06 2023 09:15:52
0 / 0
0644
vringh.h
7.764 KB
November 06 2023 09:15:52
0 / 0
0644
vt.h
0.559 KB
November 06 2023 09:15:52
0 / 0
0644
vt_buffer.h
1.251 KB
November 06 2023 09:15:52
0 / 0
0644
vt_kern.h
6.328 KB
November 06 2023 09:15:52
0 / 0
0644
vtime.h
3.658 KB
November 06 2023 09:15:52
0 / 0
0644
w1-gpio.h
0.682 KB
November 06 2023 09:15:52
0 / 0
0644
wait.h
41.651 KB
November 06 2023 09:15:52
0 / 0
0644
wanrouter.h
0.167 KB
November 06 2023 09:15:52
0 / 0
0644
watchdog.h
7.494 KB
November 06 2023 09:15:52
0 / 0
0644
wireless.h
1.362 KB
November 06 2023 09:15:52
0 / 0
0644
wl12xx.h
2.26 KB
November 06 2023 09:15:52
0 / 0
0644
wm97xx.h
10.567 KB
November 06 2023 09:15:52
0 / 0
0644
wmi.h
1.942 KB
November 06 2023 09:15:52
0 / 0
0644
workqueue.h
21.5 KB
November 06 2023 09:15:52
0 / 0
0644
writeback.h
5.92 KB
November 06 2023 09:15:52
0 / 0
0644
ww_mutex.h
12.801 KB
November 06 2023 09:15:52
0 / 0
0644
xattr.h
3.147 KB
November 06 2023 09:15:52
0 / 0
0644
xilinxfb.h
0.923 KB
November 06 2023 09:15:52
0 / 0
0644
xz.h
11.163 KB
November 06 2023 09:15:52
0 / 0
0644
yam.h
2.812 KB
November 06 2023 09:15:52
0 / 0
0644
z2_battery.h
0.272 KB
November 06 2023 09:15:52
0 / 0
0644
zbud.h
0.679 KB
November 06 2023 09:15:52
0 / 0
0644
zconf.h
1.729 KB
November 06 2023 09:15:52
0 / 0
0644
zlib.h
33.599 KB
November 06 2023 09:15:52
0 / 0
0644
zorro.h
6.508 KB
November 06 2023 09:15:52
0 / 0
0644
zorro_ids.h
29.199 KB
November 06 2023 09:15:52
0 / 0
0644
zpool.h
2.902 KB
November 06 2023 09:15:52
0 / 0
0644
zsmalloc.h
1.418 KB
November 06 2023 09:15:52
0 / 0
0644
zutil.h
2.718 KB
November 06 2023 09:15:52
0 / 0
0644