blob: b3d00fa4b3149b614365dd215a611ed638fdb924 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Definitions for the Interfaces handler.
7 *
8 * Version: @(#)dev.h 1.0.10 08/12/93
9 *
Jesper Juhl02c30a82005-05-05 16:16:16 -070010 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Corey Minyard <wf-rch!minyard@relay.EU.net>
13 * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
Alan Cox113aa832008-10-13 19:01:08 -070014 * Alan Cox, <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 * Bjorn Ekwall. <bj0rn@blox.se>
16 * Pekka Riikonen <priikone@poseidon.pspt.fi>
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version
21 * 2 of the License, or (at your option) any later version.
22 *
23 * Moved to /usr/include/linux for NET3
24 */
25#ifndef _LINUX_NETDEVICE_H
26#define _LINUX_NETDEVICE_H
27
Jean Pihete8db0be2011-08-25 15:35:03 +020028#include <linux/pm_qos.h>
Al Virod7fe0f22006-12-03 23:15:30 -050029#include <linux/timer.h>
Paul Gortmaker187f1882011-11-23 20:12:59 -050030#include <linux/bug.h>
Stephen Hemmingerbea33482007-10-03 16:41:36 -070031#include <linux/delay.h>
Arun Sharma600634972011-07-26 16:09:06 -070032#include <linux/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <asm/cache.h>
34#include <asm/byteorder.h>
35
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/percpu.h>
David S. Miller4d5b78c2009-05-06 16:52:51 -070037#include <linux/rculist.h>
Chris Leechdb217332006-06-17 21:24:58 -070038#include <linux/dmaengine.h>
Stephen Hemmingerbea33482007-10-03 16:41:36 -070039#include <linux/workqueue.h>
Tom Herbert114cf582011-11-28 16:33:09 +000040#include <linux/dynamic_queue_limits.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Patrick McHardyb1b67dd2009-04-20 04:49:28 +000042#include <linux/ethtool.h>
Daniel Lezcanoa050c332007-09-12 14:57:09 +020043#include <net/net_namespace.h>
Lennert Buytenhekcf85d082008-10-07 13:45:02 +000044#include <net/dsa.h>
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -080045#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -080046#include <net/dcbnl.h>
47#endif
Neil Horman5bc14212011-11-22 05:10:51 +000048#include <net/netprio_cgroup.h>
Daniel Lezcanoa050c332007-09-12 14:57:09 +020049
Michał Mirosława59e2ec2011-11-15 15:29:55 +000050#include <linux/netdev_features.h>
John Fastabend77162022012-04-15 06:43:56 +000051#include <linux/neighbour.h>
David Howells607ca462012-10-13 10:46:48 +010052#include <uapi/linux/netdevice.h>
Michał Mirosława59e2ec2011-11-15 15:29:55 +000053
Jeff Moyer115c1d62005-06-22 22:05:31 -070054struct netpoll_info;
Paul Gortmaker313162d2012-01-30 11:46:54 -050055struct device;
Richard Cochranc1f19b52010-07-17 08:49:36 +000056struct phy_device;
Johannes Berg704232c2007-04-23 12:20:05 -070057/* 802.11 specific */
58struct wireless_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 /* source back-compat hooks */
60#define SET_ETHTOOL_OPS(netdev,ops) \
61 ( (netdev)->ethtool_ops = (ops) )
62
Stanislaw Gruszkad07d7502013-01-10 23:19:10 +000063extern void netdev_set_default_ethtool_ops(struct net_device *dev,
64 const struct ethtool_ops *ops);
65
Stefan Assmannc1f79422010-07-22 02:50:21 +000066/* hardware address assignment types */
67#define NET_ADDR_PERM 0 /* address is permanent (default) */
68#define NET_ADDR_RANDOM 1 /* address is generated randomly */
69#define NET_ADDR_STOLEN 2 /* address is stolen from other device */
Jiri Pirkofbdeca22013-01-01 03:30:16 +000070#define NET_ADDR_SET 3 /* address is set using
71 * dev_set_mac_address() */
Stefan Assmannc1f79422010-07-22 02:50:21 +000072
Jarek Poplawski9a1654b2009-11-15 07:20:12 +000073/* Backlog congestion levels */
74#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
75#define NET_RX_DROP 1 /* packet dropped */
76
Patrick McHardy572a9d72009-11-10 06:14:14 +000077/*
78 * Transmit return codes: transmit return codes originate from three different
79 * namespaces:
80 *
81 * - qdisc return codes
82 * - driver transmit return codes
83 * - errno values
84 *
85 * Drivers are allowed to return any one of those in their hard_start_xmit()
86 * function. Real network devices commonly used with qdiscs should only return
87 * the driver transmit return codes though - when qdiscs are used, the actual
88 * transmission happens asynchronously, so the value is not propagated to
89 * higher layers. Virtual network devices transmit synchronously, in this case
90 * the driver transmit return codes are consumed by dev_queue_xmit(), all
91 * others are propagated to higher layers.
92 */
93
94/* qdisc ->enqueue() return codes. */
95#define NET_XMIT_SUCCESS 0x00
Jarek Poplawski9a1654b2009-11-15 07:20:12 +000096#define NET_XMIT_DROP 0x01 /* skb dropped */
97#define NET_XMIT_CN 0x02 /* congestion notification */
98#define NET_XMIT_POLICED 0x03 /* skb is shot by police */
99#define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200101/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
102 * indicates that the device will soon be dropping packets, or already drops
103 * some packets of the same priority; prompting us to send less aggressively. */
Patrick McHardy572a9d72009-11-10 06:14:14 +0000104#define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
106
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000107/* Driver transmit return codes */
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000108#define NETDEV_TX_MASK 0xf0
Patrick McHardy572a9d72009-11-10 06:14:14 +0000109
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000110enum netdev_tx {
Patrick McHardy572a9d72009-11-10 06:14:14 +0000111 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000112 NETDEV_TX_OK = 0x00, /* driver took care of packet */
113 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
114 NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000115};
116typedef enum netdev_tx netdev_tx_t;
117
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000118/*
119 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
120 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
121 */
122static inline bool dev_xmit_complete(int rc)
123{
124 /*
125 * Positive cases with an skb consumed by a driver:
126 * - successful transmission (rc == NETDEV_TX_OK)
127 * - error while transmitting (rc < 0)
128 * - error while queueing to a different device (rc & NET_XMIT_MASK)
129 */
130 if (likely(rc < NET_XMIT_MASK))
131 return true;
132
133 return false;
134}
135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136/*
137 * Compute the worst case header length according to the protocols
138 * used.
139 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800140
Ben Hutchingsd11ead72011-11-25 14:40:26 +0000141#if defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
David S. Miller8388e3d2008-05-12 20:17:33 -0700142# if defined(CONFIG_MAC80211_MESH)
143# define LL_MAX_HEADER 128
144# else
145# define LL_MAX_HEADER 96
146# endif
Ben Hutchingsd11ead72011-11-25 14:40:26 +0000147#elif IS_ENABLED(CONFIG_TR)
David S. Miller8388e3d2008-05-12 20:17:33 -0700148# define LL_MAX_HEADER 48
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#else
David S. Miller8388e3d2008-05-12 20:17:33 -0700150# define LL_MAX_HEADER 32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#endif
152
Ben Hutchingsd11ead72011-11-25 14:40:26 +0000153#if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
154 !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155#define MAX_HEADER LL_MAX_HEADER
156#else
157#define MAX_HEADER (LL_MAX_HEADER + 48)
158#endif
159
160/*
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000161 * Old network device statistics. Fields are native words
162 * (unsigned long) so they can be read and written atomically.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800164
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800165struct net_device_stats {
Ben Hutchings3cfde792010-07-09 09:11:52 +0000166 unsigned long rx_packets;
167 unsigned long tx_packets;
168 unsigned long rx_bytes;
169 unsigned long tx_bytes;
170 unsigned long rx_errors;
171 unsigned long tx_errors;
172 unsigned long rx_dropped;
173 unsigned long tx_dropped;
174 unsigned long multicast;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 unsigned long collisions;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 unsigned long rx_length_errors;
Ben Hutchings3cfde792010-07-09 09:11:52 +0000177 unsigned long rx_over_errors;
178 unsigned long rx_crc_errors;
179 unsigned long rx_frame_errors;
180 unsigned long rx_fifo_errors;
181 unsigned long rx_missed_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 unsigned long tx_aborted_errors;
183 unsigned long tx_carrier_errors;
184 unsigned long tx_fifo_errors;
185 unsigned long tx_heartbeat_errors;
186 unsigned long tx_window_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 unsigned long rx_compressed;
188 unsigned long tx_compressed;
189};
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
192#include <linux/cache.h>
193#include <linux/skbuff.h>
194
Eric Dumazetadc93002011-11-17 03:13:26 +0000195#ifdef CONFIG_RPS
Ingo Molnarc5905af2012-02-24 08:31:31 +0100196#include <linux/static_key.h>
197extern struct static_key rps_needed;
Eric Dumazetadc93002011-11-17 03:13:26 +0000198#endif
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200struct neighbour;
201struct neigh_parms;
202struct sk_buff;
203
Jiri Pirkof001fde2009-05-05 02:48:28 +0000204struct netdev_hw_addr {
205 struct list_head list;
206 unsigned char addr[MAX_ADDR_LEN];
207 unsigned char type;
Jiri Pirkoccffad252009-05-22 23:22:17 +0000208#define NETDEV_HW_ADDR_T_LAN 1
209#define NETDEV_HW_ADDR_T_SAN 2
210#define NETDEV_HW_ADDR_T_SLAVE 3
211#define NETDEV_HW_ADDR_T_UNICAST 4
Jiri Pirko22bedad32010-04-01 21:22:57 +0000212#define NETDEV_HW_ADDR_T_MULTICAST 5
Jiri Pirkoccffad252009-05-22 23:22:17 +0000213 bool synced;
Jiri Pirko22bedad32010-04-01 21:22:57 +0000214 bool global_use;
Eric Dumazet8f8f1032010-09-19 11:24:02 -0700215 int refcount;
Jiri Pirkof001fde2009-05-05 02:48:28 +0000216 struct rcu_head rcu_head;
217};
218
Jiri Pirko31278e72009-06-17 01:12:19 +0000219struct netdev_hw_addr_list {
220 struct list_head list;
221 int count;
222};
223
Jiri Pirko22bedad32010-04-01 21:22:57 +0000224#define netdev_hw_addr_list_count(l) ((l)->count)
225#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
226#define netdev_hw_addr_list_for_each(ha, l) \
227 list_for_each_entry(ha, &(l)->list, list)
228
229#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
230#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
Jiri Pirko32e7bfc2010-01-25 13:36:10 -0800231#define netdev_for_each_uc_addr(ha, dev) \
Jiri Pirko22bedad32010-04-01 21:22:57 +0000232 netdev_hw_addr_list_for_each(ha, &(dev)->uc)
Jiri Pirko32e7bfc2010-01-25 13:36:10 -0800233
Jiri Pirko22bedad32010-04-01 21:22:57 +0000234#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
235#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
Pavel Roskin18e225f2010-04-07 16:40:09 -0700236#define netdev_for_each_mc_addr(ha, dev) \
Jiri Pirko22bedad32010-04-01 21:22:57 +0000237 netdev_hw_addr_list_for_each(ha, &(dev)->mc)
Jiri Pirko6683ece2010-02-04 10:22:25 -0800238
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800239struct hh_cache {
David S. Millerf6b72b62011-07-14 07:53:20 -0700240 u16 hh_len;
David S. Miller5c25f682011-07-13 00:51:10 -0700241 u16 __pad;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800242 seqlock_t hh_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 /* cached hardware header; allow for machine alignment needs. */
245#define HH_DATA_MOD 16
246#define HH_DATA_OFF(__len) \
Jiri Benc5ba0eac2005-06-02 16:48:05 -0700247 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248#define HH_DATA_ALIGN(__len) \
249 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
250 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
251};
252
253/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
254 * Alternative is:
255 * dev->hard_header_len ? (dev->hard_header_len +
256 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
257 *
258 * We could use other alignment values, but we must maintain the
259 * relationship HH alignment <= LL alignment.
260 */
261#define LL_RESERVED_SPACE(dev) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700262 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700264 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700266struct header_ops {
267 int (*create) (struct sk_buff *skb, struct net_device *dev,
268 unsigned short type, const void *daddr,
Eric Dumazet95c96172012-04-15 05:58:06 +0000269 const void *saddr, unsigned int len);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700270 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
271 int (*rebuild)(struct sk_buff *skb);
David S. Millere69dd332011-07-12 23:28:12 -0700272 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700273 void (*cache_update)(struct hh_cache *hh,
274 const struct net_device *dev,
275 const unsigned char *haddr);
276};
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278/* These flag bits are private to the generic network queueing
279 * layer, they may not be explicitly referenced by any other
280 * code.
281 */
282
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800283enum netdev_state_t {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 __LINK_STATE_START,
285 __LINK_STATE_PRESENT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 __LINK_STATE_NOCARRIER,
Stefan Rompfb00055a2006-03-20 17:09:11 -0800287 __LINK_STATE_LINKWATCH_PENDING,
288 __LINK_STATE_DORMANT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289};
290
291
292/*
293 * This structure holds at boot time configured netdevice settings. They
Graf Yangfe2918b2009-02-05 21:26:19 -0800294 * are then used in the device probing.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 */
296struct netdev_boot_setup {
297 char name[IFNAMSIZ];
298 struct ifmap map;
299};
300#define NETDEV_BOOT_SETUP_MAX 8
301
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -0300302extern int __init netdev_boot_setup(char *str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304/*
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700305 * Structure for NAPI scheduling similar to tasklet but with weighting
306 */
307struct napi_struct {
308 /* The poll_list must only be managed by the entity which
309 * changes the state of the NAPI_STATE_SCHED bit. This means
310 * whoever atomically sets that bit can add this napi_struct
311 * to the per-cpu poll_list, and whoever clears that bit
312 * can remove from the list right before clearing the bit.
313 */
314 struct list_head poll_list;
315
316 unsigned long state;
317 int weight;
Eric Dumazet404f7c92012-09-26 07:07:47 +0000318 unsigned int gro_count;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700319 int (*poll)(struct napi_struct *, int);
320#ifdef CONFIG_NETPOLL
321 spinlock_t poll_lock;
322 int poll_owner;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700323#endif
Herbert Xu5d38a072009-01-04 16:13:40 -0800324 struct net_device *dev;
Herbert Xud565b0a2008-12-15 23:38:52 -0800325 struct sk_buff *gro_list;
Herbert Xu5d38a072009-01-04 16:13:40 -0800326 struct sk_buff *skb;
Eric Dumazet404f7c92012-09-26 07:07:47 +0000327 struct list_head dev_list;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700328};
329
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800330enum {
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700331 NAPI_STATE_SCHED, /* Poll is scheduled */
David S. Millera0a46192008-01-07 20:35:07 -0800332 NAPI_STATE_DISABLE, /* Disable pending */
Neil Horman7b363e42008-12-09 23:22:26 -0800333 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700334};
335
Ben Hutchings5b252f02009-10-29 07:17:09 +0000336enum gro_result {
Herbert Xud1c76af2009-03-16 10:50:02 -0700337 GRO_MERGED,
338 GRO_MERGED_FREE,
339 GRO_HELD,
340 GRO_NORMAL,
341 GRO_DROP,
342};
Ben Hutchings5b252f02009-10-29 07:17:09 +0000343typedef enum gro_result gro_result_t;
Herbert Xud1c76af2009-03-16 10:50:02 -0700344
Jiri Pirko8a4eb572011-03-12 03:14:39 +0000345/*
346 * enum rx_handler_result - Possible return values for rx_handlers.
347 * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
348 * further.
349 * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
350 * case skb->dev was changed by rx_handler.
351 * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
352 * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called.
353 *
354 * rx_handlers are functions called from inside __netif_receive_skb(), to do
355 * special processing of the skb, prior to delivery to protocol handlers.
356 *
357 * Currently, a net_device can only have a single rx_handler registered. Trying
358 * to register a second rx_handler will return -EBUSY.
359 *
360 * To register a rx_handler on a net_device, use netdev_rx_handler_register().
361 * To unregister a rx_handler on a net_device, use
362 * netdev_rx_handler_unregister().
363 *
364 * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
365 * do with the skb.
366 *
367 * If the rx_handler consumed to skb in some way, it should return
368 * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
369 * the skb to be delivered in some other ways.
370 *
371 * If the rx_handler changed skb->dev, to divert the skb to another
372 * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
373 * new device will be called if it exists.
374 *
375 * If the rx_handler consider the skb should be ignored, it should return
376 * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
Adam Buchbinderd93cf062012-09-19 21:47:58 -0400377 * are registered on exact device (ptype->dev == skb->dev).
Jiri Pirko8a4eb572011-03-12 03:14:39 +0000378 *
379 * If the rx_handler didn't changed skb->dev, but want the skb to be normally
380 * delivered, it should return RX_HANDLER_PASS.
381 *
382 * A device without a registered rx_handler will behave as if rx_handler
383 * returned RX_HANDLER_PASS.
384 */
385
386enum rx_handler_result {
387 RX_HANDLER_CONSUMED,
388 RX_HANDLER_ANOTHER,
389 RX_HANDLER_EXACT,
390 RX_HANDLER_PASS,
391};
392typedef enum rx_handler_result rx_handler_result_t;
393typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
Jiri Pirkoab95bfe2010-06-01 21:52:08 +0000394
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800395extern void __napi_schedule(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700396
David S. Miller4d295152012-03-07 21:02:35 -0500397static inline bool napi_disable_pending(struct napi_struct *n)
David S. Millera0a46192008-01-07 20:35:07 -0800398{
399 return test_bit(NAPI_STATE_DISABLE, &n->state);
400}
401
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700402/**
403 * napi_schedule_prep - check if napi can be scheduled
404 * @n: napi context
405 *
406 * Test if NAPI routine is already running, and if not mark
407 * it as running. This is used as a condition variable
David S. Millera0a46192008-01-07 20:35:07 -0800408 * insure only one NAPI poll instance runs. We also make
409 * sure there is no pending NAPI disable.
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700410 */
David S. Miller4d295152012-03-07 21:02:35 -0500411static inline bool napi_schedule_prep(struct napi_struct *n)
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700412{
David S. Millera0a46192008-01-07 20:35:07 -0800413 return !napi_disable_pending(n) &&
414 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700415}
416
417/**
418 * napi_schedule - schedule NAPI poll
419 * @n: napi context
420 *
421 * Schedule NAPI poll routine to be called if it is not already
422 * running.
423 */
424static inline void napi_schedule(struct napi_struct *n)
425{
426 if (napi_schedule_prep(n))
427 __napi_schedule(n);
428}
429
Roland Dreierbfe13f52007-10-09 15:47:37 -0700430/* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
David S. Miller4d295152012-03-07 21:02:35 -0500431static inline bool napi_reschedule(struct napi_struct *napi)
Roland Dreierbfe13f52007-10-09 15:47:37 -0700432{
433 if (napi_schedule_prep(napi)) {
434 __napi_schedule(napi);
David S. Miller4d295152012-03-07 21:02:35 -0500435 return true;
Roland Dreierbfe13f52007-10-09 15:47:37 -0700436 }
David S. Miller4d295152012-03-07 21:02:35 -0500437 return false;
Roland Dreierbfe13f52007-10-09 15:47:37 -0700438}
439
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700440/**
441 * napi_complete - NAPI processing complete
442 * @n: napi context
443 *
444 * Mark NAPI processing as complete.
445 */
Herbert Xud565b0a2008-12-15 23:38:52 -0800446extern void __napi_complete(struct napi_struct *n);
447extern void napi_complete(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700448
449/**
450 * napi_disable - prevent NAPI from scheduling
451 * @n: napi context
452 *
453 * Stop NAPI from being scheduled on this context.
454 * Waits till any outstanding processing completes.
455 */
456static inline void napi_disable(struct napi_struct *n)
457{
David S. Millera0a46192008-01-07 20:35:07 -0800458 set_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700459 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
Benjamin Herrenschmidt43cc7382007-10-26 04:23:22 -0700460 msleep(1);
David S. Millera0a46192008-01-07 20:35:07 -0800461 clear_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700462}
463
464/**
465 * napi_enable - enable NAPI scheduling
466 * @n: napi context
467 *
468 * Resume NAPI from being scheduled on this context.
469 * Must be paired with napi_disable.
470 */
471static inline void napi_enable(struct napi_struct *n)
472{
473 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
474 smp_mb__before_clear_bit();
475 clear_bit(NAPI_STATE_SCHED, &n->state);
476}
477
Stephen Hemmingerc264c3d2007-10-17 13:26:41 -0700478#ifdef CONFIG_SMP
479/**
480 * napi_synchronize - wait until NAPI is not running
481 * @n: napi context
482 *
483 * Wait until NAPI is done being scheduled on this context.
484 * Waits till any outstanding processing completes but
485 * does not disable future activations.
486 */
487static inline void napi_synchronize(const struct napi_struct *n)
488{
489 while (test_bit(NAPI_STATE_SCHED, &n->state))
490 msleep(1);
491}
492#else
493# define napi_synchronize(n) barrier()
494#endif
495
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800496enum netdev_queue_state_t {
Tom Herbert734664982011-11-28 16:32:44 +0000497 __QUEUE_STATE_DRV_XOFF,
498 __QUEUE_STATE_STACK_XOFF,
David S. Millerc3f26a22008-07-31 16:58:50 -0700499 __QUEUE_STATE_FROZEN,
Tom Herbert734664982011-11-28 16:32:44 +0000500#define QUEUE_STATE_ANY_XOFF ((1 << __QUEUE_STATE_DRV_XOFF) | \
501 (1 << __QUEUE_STATE_STACK_XOFF))
502#define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
503 (1 << __QUEUE_STATE_FROZEN))
David S. Miller79d16382008-07-08 23:14:46 -0700504};
Tom Herbert734664982011-11-28 16:32:44 +0000505/*
506 * __QUEUE_STATE_DRV_XOFF is used by drivers to stop the transmit queue. The
507 * netif_tx_* functions below are used to manipulate this flag. The
508 * __QUEUE_STATE_STACK_XOFF flag is used by the stack to stop the transmit
509 * queue independently. The netif_xmit_*stopped functions below are called
510 * to check if the queue has been stopped by the driver or stack (either
511 * of the XOFF bits are set in the state). Drivers should not need to call
512 * netif_xmit*stopped functions, they should only be using netif_tx_*.
513 */
David S. Miller79d16382008-07-08 23:14:46 -0700514
David S. Millerbb949fb2008-07-08 16:55:56 -0700515struct netdev_queue {
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700516/*
517 * read mostly part
518 */
David S. Millerbb949fb2008-07-08 16:55:56 -0700519 struct net_device *dev;
David S. Millerb0e1e642008-07-08 17:42:10 -0700520 struct Qdisc *qdisc;
521 struct Qdisc *qdisc_sleeping;
david decotignyccf5ff62011-11-16 12:15:10 +0000522#ifdef CONFIG_SYSFS
Tom Herbert1d24eb42010-11-21 13:17:27 +0000523 struct kobject kobj;
524#endif
Eric Dumazetf2cd2d32010-11-29 08:14:37 +0000525#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
526 int numa_node;
527#endif
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700528/*
529 * write mostly part
530 */
531 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
532 int xmit_lock_owner;
Eric Dumazet9d214932009-05-17 20:55:16 -0700533 /*
534 * please use this field instead of dev->trans_start
535 */
536 unsigned long trans_start;
david decotignyccf5ff62011-11-16 12:15:10 +0000537
538 /*
539 * Number of TX timeouts for this queue
540 * (/sys/class/net/DEV/Q/trans_timeout)
541 */
542 unsigned long trans_timeout;
Tom Herbert114cf582011-11-28 16:33:09 +0000543
544 unsigned long state;
545
546#ifdef CONFIG_BQL
547 struct dql dql;
548#endif
David S. Millere8a04642008-07-17 00:34:19 -0700549} ____cacheline_aligned_in_smp;
David S. Millerbb949fb2008-07-08 16:55:56 -0700550
Eric Dumazetf2cd2d32010-11-29 08:14:37 +0000551static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
552{
553#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
554 return q->numa_node;
555#else
Changli Gaob236da62010-12-14 03:09:15 +0000556 return NUMA_NO_NODE;
Eric Dumazetf2cd2d32010-11-29 08:14:37 +0000557#endif
558}
559
560static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
561{
562#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
563 q->numa_node = node;
564#endif
565}
566
Eric Dumazetdf334542010-03-24 19:13:54 +0000567#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000568/*
569 * This structure holds an RPS map which can be of variable length. The
570 * map is an array of CPUs.
571 */
572struct rps_map {
573 unsigned int len;
574 struct rcu_head rcu;
575 u16 cpus[0];
576};
Eric Dumazet60b778c2011-12-24 06:56:49 +0000577#define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + ((_num) * sizeof(u16)))
Tom Herbert0a9627f2010-03-16 08:03:29 +0000578
Tom Herbertfec5e652010-04-16 16:01:27 -0700579/*
Ben Hutchingsc4454772011-01-19 11:03:53 +0000580 * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
581 * tail pointer for that CPU's input queue at the time of last enqueue, and
582 * a hardware filter index.
Tom Herbertfec5e652010-04-16 16:01:27 -0700583 */
584struct rps_dev_flow {
585 u16 cpu;
Ben Hutchingsc4454772011-01-19 11:03:53 +0000586 u16 filter;
Tom Herbertfec5e652010-04-16 16:01:27 -0700587 unsigned int last_qtail;
588};
Ben Hutchingsc4454772011-01-19 11:03:53 +0000589#define RPS_NO_FILTER 0xffff
Tom Herbertfec5e652010-04-16 16:01:27 -0700590
591/*
592 * The rps_dev_flow_table structure contains a table of flow mappings.
593 */
594struct rps_dev_flow_table {
595 unsigned int mask;
596 struct rcu_head rcu;
597 struct work_struct free_work;
598 struct rps_dev_flow flows[0];
599};
600#define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
Eric Dumazet60b778c2011-12-24 06:56:49 +0000601 ((_num) * sizeof(struct rps_dev_flow)))
Tom Herbertfec5e652010-04-16 16:01:27 -0700602
603/*
604 * The rps_sock_flow_table contains mappings of flows to the last CPU
605 * on which they were processed by the application (set in recvmsg).
606 */
607struct rps_sock_flow_table {
608 unsigned int mask;
609 u16 ents[0];
610};
611#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
Eric Dumazet60b778c2011-12-24 06:56:49 +0000612 ((_num) * sizeof(u16)))
Tom Herbertfec5e652010-04-16 16:01:27 -0700613
614#define RPS_NO_CPU 0xffff
615
616static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
617 u32 hash)
618{
619 if (table && hash) {
620 unsigned int cpu, index = hash & table->mask;
621
622 /* We only give a hint, preemption can change cpu under us */
623 cpu = raw_smp_processor_id();
624
625 if (table->ents[index] != cpu)
626 table->ents[index] = cpu;
627 }
628}
629
630static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
631 u32 hash)
632{
633 if (table && hash)
634 table->ents[hash & table->mask] = RPS_NO_CPU;
635}
636
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000637extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
Tom Herbertfec5e652010-04-16 16:01:27 -0700638
Ben Hutchingsc4454772011-01-19 11:03:53 +0000639#ifdef CONFIG_RFS_ACCEL
640extern bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
641 u32 flow_id, u16 filter_id);
642#endif
643
Tom Herbert0a9627f2010-03-16 08:03:29 +0000644/* This structure contains an instance of an RX queue. */
645struct netdev_rx_queue {
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000646 struct rps_map __rcu *rps_map;
647 struct rps_dev_flow_table __rcu *rps_flow_table;
648 struct kobject kobj;
Tom Herbertfe822242010-11-09 10:47:38 +0000649 struct net_device *dev;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000650} ____cacheline_aligned_in_smp;
Tom Herbertfec5e652010-04-16 16:01:27 -0700651#endif /* CONFIG_RPS */
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800652
Tom Herbertbf264142010-11-26 08:36:09 +0000653#ifdef CONFIG_XPS
654/*
655 * This structure holds an XPS map which can be of variable length. The
656 * map is an array of queues.
657 */
658struct xps_map {
659 unsigned int len;
660 unsigned int alloc_len;
661 struct rcu_head rcu;
662 u16 queues[0];
663};
Eric Dumazet60b778c2011-12-24 06:56:49 +0000664#define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16)))
Tom Herbertbf264142010-11-26 08:36:09 +0000665#define XPS_MIN_MAP_ALLOC ((L1_CACHE_BYTES - sizeof(struct xps_map)) \
666 / sizeof(u16))
667
668/*
669 * This structure holds all XPS maps for device. Maps are indexed by CPU.
670 */
671struct xps_dev_maps {
672 struct rcu_head rcu;
Eric Dumazeta4177862010-11-28 21:43:02 +0000673 struct xps_map __rcu *cpu_map[0];
Tom Herbertbf264142010-11-26 08:36:09 +0000674};
675#define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) + \
676 (nr_cpu_ids * sizeof(struct xps_map *)))
677#endif /* CONFIG_XPS */
678
John Fastabend4f57c082011-01-17 08:06:04 +0000679#define TC_MAX_QUEUE 16
680#define TC_BITMASK 15
681/* HW offloaded queuing disciplines txq count and offset maps */
682struct netdev_tc_txq {
683 u16 count;
684 u16 offset;
685};
686
Neerav Parikh68bad942012-01-04 20:23:39 +0000687#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
688/*
689 * This structure is to hold information about the device
690 * configured to run FCoE protocol stack.
691 */
692struct netdev_fcoe_hbainfo {
693 char manufacturer[64];
694 char serial_number[64];
695 char hardware_version[64];
696 char driver_version[64];
697 char optionrom_version[64];
698 char firmware_version[64];
699 char model[256];
700 char model_description[256];
701};
702#endif
703
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800704/*
705 * This structure defines the management hooks for network devices.
Stephen Hemminger00829822008-11-20 20:14:53 -0800706 * The following hooks can be defined; unless noted otherwise, they are
707 * optional and can be filled with a null pointer.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800708 *
709 * int (*ndo_init)(struct net_device *dev);
710 * This function is called once when network device is registered.
711 * The network device can use this to any late stage initializaton
712 * or semantic validattion. It can fail with an error code which will
713 * be propogated back to register_netdev
714 *
715 * void (*ndo_uninit)(struct net_device *dev);
716 * This function is called when device is unregistered or when registration
717 * fails. It is not called if init fails.
718 *
719 * int (*ndo_open)(struct net_device *dev);
720 * This function is called when network device transistions to the up
721 * state.
722 *
723 * int (*ndo_stop)(struct net_device *dev);
724 * This function is called when network device transistions to the down
725 * state.
726 *
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000727 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
728 * struct net_device *dev);
Stephen Hemminger00829822008-11-20 20:14:53 -0800729 * Called when a packet needs to be transmitted.
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000730 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
731 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
Stephen Hemminger00829822008-11-20 20:14:53 -0800732 * Required can not be NULL.
733 *
734 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
735 * Called to decide which queue to when device supports multiple
736 * transmit queues.
737 *
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800738 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
739 * This function is called to allow device receiver to make
740 * changes to configuration when multicast or promiscious is enabled.
741 *
742 * void (*ndo_set_rx_mode)(struct net_device *dev);
743 * This function is called device changes address list filtering.
Jiri Pirko01789342011-08-16 06:29:00 +0000744 * If driver handles unicast address filtering, it should set
745 * IFF_UNICAST_FLT to its priv_flags.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800746 *
747 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
748 * This function is called when the Media Access Control address
Mike Rapoport37b607c2009-04-27 05:45:54 -0700749 * needs to be changed. If this interface is not defined, the
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800750 * mac address can not be changed.
751 *
752 * int (*ndo_validate_addr)(struct net_device *dev);
753 * Test if Media Access Control address is valid for the device.
754 *
755 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
756 * Called when a user request an ioctl which can't be handled by
757 * the generic interface code. If not defined ioctl's return
758 * not supported error code.
759 *
760 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
761 * Used to set network devices bus interface parameters. This interface
762 * is retained for legacy reason, new devices should use the bus
763 * interface (PCI) for low level management.
764 *
765 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
766 * Called when a user wants to change the Maximum Transfer Unit
767 * of a device. If not defined, any request to change MTU will
768 * will return an error.
769 *
Stephen Hemminger00829822008-11-20 20:14:53 -0800770 * void (*ndo_tx_timeout)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800771 * Callback uses when the transmitter has not made any progress
772 * for dev->watchdog ticks.
773 *
Ben Hutchings3cfde792010-07-09 09:11:52 +0000774 * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
Eric Dumazet28172732010-07-07 14:58:56 -0700775 * struct rtnl_link_stats64 *storage);
Wolfram Sangd308e382009-10-07 13:53:11 -0700776 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800777 * Called when a user wants to get the network device usage
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000778 * statistics. Drivers must do one of the following:
Ben Hutchings3cfde792010-07-09 09:11:52 +0000779 * 1. Define @ndo_get_stats64 to fill in a zero-initialised
780 * rtnl_link_stats64 structure passed by the caller.
Ben Hutchings82695d92010-06-15 15:08:48 -0700781 * 2. Define @ndo_get_stats to update a net_device_stats structure
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000782 * (which should normally be dev->stats) and return a pointer to
783 * it. The structure may be changed asynchronously only if each
784 * field is written atomically.
785 * 3. Update dev->stats asynchronously and atomically, and define
786 * neither operation.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800787 *
Jiri Pirko8e586132011-12-08 19:52:37 -0500788 * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800789 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
790 * this function is called when a VLAN id is registered.
791 *
Jiri Pirko8e586132011-12-08 19:52:37 -0500792 * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800793 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
794 * this function is called when a VLAN id is unregistered.
795 *
796 * void (*ndo_poll_controller)(struct net_device *dev);
Williams, Mitch A95c26df2010-02-10 01:43:46 +0000797 *
798 * SR-IOV management functions.
799 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
800 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
801 * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate);
Greg Rose5f8444a2011-10-08 03:05:24 +0000802 * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);
Williams, Mitch A95c26df2010-02-10 01:43:46 +0000803 * int (*ndo_get_vf_config)(struct net_device *dev,
804 * int vf, struct ifla_vf_info *ivf);
Scott Feldman57b61082010-05-17 22:49:55 -0700805 * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
806 * struct nlattr *port[]);
807 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
John Fastabend4f57c082011-01-17 08:06:04 +0000808 * int (*ndo_setup_tc)(struct net_device *dev, u8 tc)
809 * Called to setup 'tc' number of traffic classes in the net device. This
810 * is always called from the stack with the rtnl lock held and netif tx
811 * queues stopped. This allows the netdevice to perform queue management
812 * safely.
Ben Hutchingsc4454772011-01-19 11:03:53 +0000813 *
Yi Zoue9bce842011-03-09 08:48:03 +0000814 * Fiber Channel over Ethernet (FCoE) offload functions.
815 * int (*ndo_fcoe_enable)(struct net_device *dev);
816 * Called when the FCoE protocol stack wants to start using LLD for FCoE
817 * so the underlying device can perform whatever needed configuration or
818 * initialization to support acceleration of FCoE traffic.
819 *
820 * int (*ndo_fcoe_disable)(struct net_device *dev);
821 * Called when the FCoE protocol stack wants to stop using LLD for FCoE
822 * so the underlying device can perform whatever needed clean-ups to
823 * stop supporting acceleration of FCoE traffic.
824 *
825 * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
826 * struct scatterlist *sgl, unsigned int sgc);
827 * Called when the FCoE Initiator wants to initialize an I/O that
828 * is a possible candidate for Direct Data Placement (DDP). The LLD can
829 * perform necessary setup and returns 1 to indicate the device is set up
830 * successfully to perform DDP on this I/O, otherwise this returns 0.
831 *
832 * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid);
833 * Called when the FCoE Initiator/Target is done with the DDPed I/O as
834 * indicated by the FC exchange id 'xid', so the underlying device can
835 * clean up and reuse resources for later DDP requests.
836 *
837 * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
838 * struct scatterlist *sgl, unsigned int sgc);
839 * Called when the FCoE Target wants to initialize an I/O that
840 * is a possible candidate for Direct Data Placement (DDP). The LLD can
841 * perform necessary setup and returns 1 to indicate the device is set up
842 * successfully to perform DDP on this I/O, otherwise this returns 0.
843 *
Neerav Parikh68bad942012-01-04 20:23:39 +0000844 * int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
845 * struct netdev_fcoe_hbainfo *hbainfo);
846 * Called when the FCoE Protocol stack wants information on the underlying
847 * device. This information is utilized by the FCoE protocol stack to
848 * register attributes with Fiber Channel management service as per the
849 * FC-GS Fabric Device Management Information(FDMI) specification.
850 *
Yi Zoue9bce842011-03-09 08:48:03 +0000851 * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
852 * Called when the underlying device wants to override default World Wide
853 * Name (WWN) generation mechanism in FCoE protocol stack to pass its own
854 * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
855 * protocol stack to use.
856 *
Ben Hutchingsc4454772011-01-19 11:03:53 +0000857 * RFS acceleration.
858 * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
859 * u16 rxq_index, u32 flow_id);
860 * Set hardware filter for RFS. rxq_index is the target queue index;
861 * flow_id is a flow ID to be passed to rps_may_expire_flow() later.
862 * Return the filter ID on success, or a negative error code.
Jiri Pirkofbaec0e2011-02-13 10:15:37 +0000863 *
Jiri Pirko8b98a702013-01-03 22:49:02 +0000864 * Slave management functions (for bridge, bonding, etc).
Jiri Pirkofbaec0e2011-02-13 10:15:37 +0000865 * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
866 * Called to make another netdev an underling.
867 *
868 * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
869 * Called to release previously enslaved netdev.
Michał Mirosław5455c692011-02-15 16:59:17 +0000870 *
871 * Feature/offload setting functions.
Michał Mirosławc8f44af2011-11-15 15:29:55 +0000872 * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
873 * netdev_features_t features);
Michał Mirosław5455c692011-02-15 16:59:17 +0000874 * Adjusts the requested feature flags according to device-specific
875 * constraints, and returns the resulting flags. Must not modify
876 * the device state.
877 *
Michał Mirosławc8f44af2011-11-15 15:29:55 +0000878 * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features);
Michał Mirosław5455c692011-02-15 16:59:17 +0000879 * Called to update device configuration to new features. Passed
880 * feature set might be less than what was returned by ndo_fix_features()).
881 * Must return >0 or -errno if it changed dev->features itself.
882 *
stephen hemmingeredc7d572012-10-01 12:32:33 +0000883 * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[],
884 * struct net_device *dev,
stephen hemminger6b6e2722012-09-17 10:03:26 +0000885 * const unsigned char *addr, u16 flags)
John Fastabend77162022012-04-15 06:43:56 +0000886 * Adds an FDB entry to dev for addr.
Vlad Yasevich1690be62013-02-13 12:00:18 +0000887 * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
888 * struct net_device *dev,
stephen hemminger6b6e2722012-09-17 10:03:26 +0000889 * const unsigned char *addr)
John Fastabend77162022012-04-15 06:43:56 +0000890 * Deletes the FDB entry from dev coresponding to addr.
891 * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
892 * struct net_device *dev, int idx)
893 * Used to add FDB entries to dump requests. Implementers should add
894 * entries to skb and update idx with the number of entries.
John Fastabende5a55a82012-10-24 08:12:57 +0000895 *
896 * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh)
897 * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq,
898 * struct net_device *dev)
Jiri Pirko4bf84c32012-12-27 23:49:37 +0000899 *
900 * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier);
901 * Called to change device carrier. Soft-devices (like dummy, team, etc)
902 * which do not represent real hardware may define this to allow their
903 * userspace components to manage their virtual carrier state. Devices
904 * that determine carrier state from physical hardware properties (eg
905 * network cables) or protocol-dependent mechanisms (eg
906 * USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800907 */
908struct net_device_ops {
909 int (*ndo_init)(struct net_device *dev);
910 void (*ndo_uninit)(struct net_device *dev);
911 int (*ndo_open)(struct net_device *dev);
912 int (*ndo_stop)(struct net_device *dev);
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000913 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,
Stephen Hemminger00829822008-11-20 20:14:53 -0800914 struct net_device *dev);
915 u16 (*ndo_select_queue)(struct net_device *dev,
916 struct sk_buff *skb);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800917 void (*ndo_change_rx_flags)(struct net_device *dev,
918 int flags);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800919 void (*ndo_set_rx_mode)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800920 int (*ndo_set_mac_address)(struct net_device *dev,
921 void *addr);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800922 int (*ndo_validate_addr)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800923 int (*ndo_do_ioctl)(struct net_device *dev,
924 struct ifreq *ifr, int cmd);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800925 int (*ndo_set_config)(struct net_device *dev,
926 struct ifmap *map);
Stephen Hemminger00829822008-11-20 20:14:53 -0800927 int (*ndo_change_mtu)(struct net_device *dev,
928 int new_mtu);
929 int (*ndo_neigh_setup)(struct net_device *dev,
930 struct neigh_parms *);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800931 void (*ndo_tx_timeout) (struct net_device *dev);
932
Eric Dumazet28172732010-07-07 14:58:56 -0700933 struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
934 struct rtnl_link_stats64 *storage);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800935 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
936
Jiri Pirko8e586132011-12-08 19:52:37 -0500937 int (*ndo_vlan_rx_add_vid)(struct net_device *dev,
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800938 unsigned short vid);
Jiri Pirko8e586132011-12-08 19:52:37 -0500939 int (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800940 unsigned short vid);
941#ifdef CONFIG_NET_POLL_CONTROLLER
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800942 void (*ndo_poll_controller)(struct net_device *dev);
Herbert Xu4247e162010-06-10 16:12:47 +0000943 int (*ndo_netpoll_setup)(struct net_device *dev,
Amerigo Wang47be03a22012-08-10 01:24:37 +0000944 struct netpoll_info *info,
945 gfp_t gfp);
WANG Cong0e34e932010-05-06 00:47:21 -0700946 void (*ndo_netpoll_cleanup)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800947#endif
Williams, Mitch A95c26df2010-02-10 01:43:46 +0000948 int (*ndo_set_vf_mac)(struct net_device *dev,
949 int queue, u8 *mac);
950 int (*ndo_set_vf_vlan)(struct net_device *dev,
951 int queue, u16 vlan, u8 qos);
952 int (*ndo_set_vf_tx_rate)(struct net_device *dev,
953 int vf, int rate);
Greg Rose5f8444a2011-10-08 03:05:24 +0000954 int (*ndo_set_vf_spoofchk)(struct net_device *dev,
955 int vf, bool setting);
Williams, Mitch A95c26df2010-02-10 01:43:46 +0000956 int (*ndo_get_vf_config)(struct net_device *dev,
957 int vf,
958 struct ifla_vf_info *ivf);
Scott Feldman57b61082010-05-17 22:49:55 -0700959 int (*ndo_set_vf_port)(struct net_device *dev,
960 int vf,
961 struct nlattr *port[]);
962 int (*ndo_get_vf_port)(struct net_device *dev,
963 int vf, struct sk_buff *skb);
John Fastabend4f57c082011-01-17 08:06:04 +0000964 int (*ndo_setup_tc)(struct net_device *dev, u8 tc);
Ben Hutchingsd11ead72011-11-25 14:40:26 +0000965#if IS_ENABLED(CONFIG_FCOE)
Yi Zoucb454392009-08-31 12:31:36 +0000966 int (*ndo_fcoe_enable)(struct net_device *dev);
967 int (*ndo_fcoe_disable)(struct net_device *dev);
Yi Zou4d288d52009-02-27 14:06:59 -0800968 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
969 u16 xid,
970 struct scatterlist *sgl,
971 unsigned int sgc);
972 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
973 u16 xid);
Yi Zou6247e082011-02-01 07:22:06 +0000974 int (*ndo_fcoe_ddp_target)(struct net_device *dev,
975 u16 xid,
976 struct scatterlist *sgl,
977 unsigned int sgc);
Neerav Parikh68bad942012-01-04 20:23:39 +0000978 int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
979 struct netdev_fcoe_hbainfo *hbainfo);
Bhanu Prakash Gollapudi3c9c36bc2011-08-26 09:45:41 +0000980#endif
981
Ben Hutchingsd11ead72011-11-25 14:40:26 +0000982#if IS_ENABLED(CONFIG_LIBFCOE)
Yi Zoudf5c7942009-10-28 18:24:35 +0000983#define NETDEV_FCOE_WWNN 0
984#define NETDEV_FCOE_WWPN 1
985 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
986 u64 *wwn, int type);
Yi Zou4d288d52009-02-27 14:06:59 -0800987#endif
Bhanu Prakash Gollapudi3c9c36bc2011-08-26 09:45:41 +0000988
Ben Hutchingsc4454772011-01-19 11:03:53 +0000989#ifdef CONFIG_RFS_ACCEL
990 int (*ndo_rx_flow_steer)(struct net_device *dev,
991 const struct sk_buff *skb,
992 u16 rxq_index,
993 u32 flow_id);
994#endif
Jiri Pirkofbaec0e2011-02-13 10:15:37 +0000995 int (*ndo_add_slave)(struct net_device *dev,
996 struct net_device *slave_dev);
997 int (*ndo_del_slave)(struct net_device *dev,
998 struct net_device *slave_dev);
Michał Mirosławc8f44af2011-11-15 15:29:55 +0000999 netdev_features_t (*ndo_fix_features)(struct net_device *dev,
1000 netdev_features_t features);
Michał Mirosław5455c692011-02-15 16:59:17 +00001001 int (*ndo_set_features)(struct net_device *dev,
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001002 netdev_features_t features);
David Millerda6a8fa2011-07-25 00:01:38 +00001003 int (*ndo_neigh_construct)(struct neighbour *n);
David S. Miller447f2192011-12-19 15:04:41 -05001004 void (*ndo_neigh_destroy)(struct neighbour *n);
John Fastabend77162022012-04-15 06:43:56 +00001005
1006 int (*ndo_fdb_add)(struct ndmsg *ndm,
stephen hemmingeredc7d572012-10-01 12:32:33 +00001007 struct nlattr *tb[],
John Fastabend77162022012-04-15 06:43:56 +00001008 struct net_device *dev,
stephen hemminger6b6e2722012-09-17 10:03:26 +00001009 const unsigned char *addr,
John Fastabend77162022012-04-15 06:43:56 +00001010 u16 flags);
1011 int (*ndo_fdb_del)(struct ndmsg *ndm,
Vlad Yasevich1690be62013-02-13 12:00:18 +00001012 struct nlattr *tb[],
John Fastabend77162022012-04-15 06:43:56 +00001013 struct net_device *dev,
stephen hemminger6b6e2722012-09-17 10:03:26 +00001014 const unsigned char *addr);
John Fastabend77162022012-04-15 06:43:56 +00001015 int (*ndo_fdb_dump)(struct sk_buff *skb,
1016 struct netlink_callback *cb,
1017 struct net_device *dev,
1018 int idx);
John Fastabende5a55a82012-10-24 08:12:57 +00001019
1020 int (*ndo_bridge_setlink)(struct net_device *dev,
1021 struct nlmsghdr *nlh);
1022 int (*ndo_bridge_getlink)(struct sk_buff *skb,
1023 u32 pid, u32 seq,
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +00001024 struct net_device *dev,
1025 u32 filter_mask);
Vlad Yasevich407af322013-02-13 12:00:12 +00001026 int (*ndo_bridge_dellink)(struct net_device *dev,
1027 struct nlmsghdr *nlh);
Jiri Pirko4bf84c32012-12-27 23:49:37 +00001028 int (*ndo_change_carrier)(struct net_device *dev,
1029 bool new_carrier);
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001030};
1031
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001032/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 * The DEVICE structure.
1034 * Actually, this whole structure is a big mistake. It mixes I/O
1035 * data with strictly "high-level" data, and it has to know about
1036 * almost every data structure used in the INET module.
1037 *
1038 * FIXME: cleanup struct net_device such that network protocol info
1039 * moves out.
1040 */
1041
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08001042struct net_device {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
1044 /*
1045 * This is the first field of the "visible" part of this structure
1046 * (i.e. as seen by users in the "Space.c" file). It is the name
Justin P. Mattock724df612010-05-26 09:22:40 -07001047 * of the interface.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 */
1049 char name[IFNAMSIZ];
Mark Grossed771342010-05-06 01:59:26 +02001050
Eric Dumazet91364612012-06-11 06:36:13 +00001051 /* device name hash chain, please keep it close to name[] */
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001052 struct hlist_node name_hlist;
Eric Dumazet91364612012-06-11 06:36:13 +00001053
Stephen Hemminger0b815a12008-09-22 21:28:11 -07001054 /* snmp alias */
1055 char *ifalias;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
1057 /*
1058 * I/O specific fields
1059 * FIXME: Merge these and struct ifmap into one
1060 */
1061 unsigned long mem_end; /* shared mem end */
1062 unsigned long mem_start; /* shared mem start */
1063 unsigned long base_addr; /* device I/O address */
1064 unsigned int irq; /* device IRQ number */
1065
1066 /*
1067 * Some hardware also needs these fields, but they are not
1068 * part of the usual set specified in Space.c.
1069 */
1070
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 unsigned long state;
1072
Pavel Emelianov7562f872007-05-03 15:13:45 -07001073 struct list_head dev_list;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001074 struct list_head napi_list;
Eric Dumazet44a08732009-10-27 07:03:04 +00001075 struct list_head unreg_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
Michał Mirosław5455c692011-02-15 16:59:17 +00001077 /* currently active device features */
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001078 netdev_features_t features;
Michał Mirosław5455c692011-02-15 16:59:17 +00001079 /* user-changeable features */
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001080 netdev_features_t hw_features;
Michał Mirosław5455c692011-02-15 16:59:17 +00001081 /* user-requested features */
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001082 netdev_features_t wanted_features;
Michał Mirosław1aac6262011-04-12 04:07:39 +00001083 /* mask of features inheritable by VLAN devices */
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001084 netdev_features_t vlan_features;
Joseph Gasparakis6a674e92012-12-07 14:14:14 +00001085 /* mask of features inherited by encapsulating devices
1086 * This field indicates what encapsulation offloads
1087 * the hardware is capable of doing, and drivers will
1088 * need to set them appropriately.
1089 */
1090 netdev_features_t hw_enc_features;
Michał Mirosław04ed3e72011-01-24 15:32:47 -08001091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 /* Interface index. Unique device identifier */
1093 int ifindex;
1094 int iflink;
1095
Rusty Russellc45d2862007-03-28 14:29:08 -07001096 struct net_device_stats stats;
Eric Dumazetcaf586e2010-09-30 21:06:55 +00001097 atomic_long_t rx_dropped; /* dropped packets by core network
1098 * Do not use this in drivers.
1099 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Johannes Bergb86e0282007-04-26 20:48:23 -07001101#ifdef CONFIG_WIRELESS_EXT
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 /* List of functions to handle Wireless Extensions (instead of ioctl).
1103 * See <net/iw_handler.h> for details. Jean II */
1104 const struct iw_handler_def * wireless_handlers;
1105 /* Instance data managed by the core of Wireless Extensions. */
1106 struct iw_public_data * wireless_data;
Johannes Bergb86e0282007-04-26 20:48:23 -07001107#endif
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001108 /* Management operations */
1109 const struct net_device_ops *netdev_ops;
Stephen Hemminger76fd8592006-09-08 11:16:13 -07001110 const struct ethtool_ops *ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001112 /* Hardware header description */
1113 const struct header_ops *header_ops;
1114
Stefan Rompfb00055a2006-03-20 17:09:11 -08001115 unsigned int flags; /* interface flags (a la BSD) */
Ben Greear3bdc0eb2012-02-11 15:39:30 +00001116 unsigned int priv_flags; /* Like 'flags' but invisible to userspace.
1117 * See if.h for definitions. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 unsigned short gflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 unsigned short padded; /* How much padding added by alloc_netdev() */
1120
Stefan Rompfb00055a2006-03-20 17:09:11 -08001121 unsigned char operstate; /* RFC2863 operstate */
1122 unsigned char link_mode; /* mapping policy to operstate */
1123
Joe Perchesbdc220d2011-05-09 17:42:46 +00001124 unsigned char if_port; /* Selectable AUI, TP,..*/
1125 unsigned char dma; /* DMA channel */
1126
David S. Millercd7b5392010-05-02 22:27:59 -07001127 unsigned int mtu; /* interface MTU value */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 unsigned short type; /* interface hardware type */
1129 unsigned short hard_header_len; /* hardware hdr length */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Johannes Bergf5184d22008-05-12 20:48:31 -07001131 /* extra head- and tailroom the hardware may need, but not in all cases
1132 * can this be guaranteed, especially tailroom. Some cases also use
1133 * LL_MAX_HEADER instead to allocate the skb.
1134 */
1135 unsigned short needed_headroom;
1136 unsigned short needed_tailroom;
1137
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 /* Interface address info. */
Jon Wetzela6f9a702005-08-20 17:15:54 -07001139 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
Stefan Assmannc1f79422010-07-22 02:50:21 +00001140 unsigned char addr_assign_type; /* hw address assignment type */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 unsigned char addr_len; /* hardware address length */
David Miller596b9b62011-07-25 00:01:25 +00001142 unsigned char neigh_priv_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 unsigned short dev_id; /* for shared network cards */
1144
Jiri Pirkoccffad252009-05-22 23:22:17 +00001145 spinlock_t addr_list_lock;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001146 struct netdev_hw_addr_list uc; /* Unicast mac addresses */
1147 struct netdev_hw_addr_list mc; /* Multicast mac addresses */
Joe Perches2d348d12011-07-25 16:17:35 -07001148 bool uc_promisc;
Wang Chen9d45abe2008-06-17 21:12:48 -07001149 unsigned int promiscuity;
1150 unsigned int allmulti;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
1153 /* Protocol specific pointers */
Jesse Gross65ac6a52010-10-20 13:56:05 +00001154
Ben Hutchingsd11ead72011-11-25 14:40:26 +00001155#if IS_ENABLED(CONFIG_VLAN_8021Q)
Jiri Pirko5b9ea6e2011-12-08 04:11:18 +00001156 struct vlan_info __rcu *vlan_info; /* VLAN info */
Jesse Gross65ac6a52010-10-20 13:56:05 +00001157#endif
Ben Hutchings34a430d2011-11-25 14:38:38 +00001158#if IS_ENABLED(CONFIG_NET_DSA)
Ben Hutchingscf50dcc2011-11-25 14:32:52 +00001159 struct dsa_switch_tree *dsa_ptr; /* dsa specific data */
Lennert Buytenhek91da11f2008-10-07 13:44:02 +00001160#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 void *atalk_ptr; /* AppleTalk link */
Eric Dumazet95ae6b22010-09-15 04:04:31 +00001162 struct in_device __rcu *ip_ptr; /* IPv4 specific data */
Eric Dumazetfc766e4c2010-10-29 03:09:24 +00001163 struct dn_dev __rcu *dn_ptr; /* DECnet specific data */
Eric Dumazet198caec2010-10-24 21:32:05 +00001164 struct inet6_dev __rcu *ip6_ptr; /* IPv6 specific data */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 void *ax25_ptr; /* AX.25 specific data */
Johannes Berg704232c2007-04-23 12:20:05 -07001166 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
1167 assign before registering */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001169/*
Eric Dumazetcd135392010-09-16 02:58:13 +00001170 * Cache lines mostly used on receive path (including eth_type_trans())
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001171 */
Eric Dumazet4dc89132010-08-31 07:40:16 +00001172 unsigned long last_rx; /* Time of last Rx
1173 * This should not be set in
1174 * drivers, unless really needed,
1175 * because network stack (bonding)
1176 * use it if/when necessary, to
1177 * avoid dirtying this cache line.
1178 */
1179
Jiri Pirko9ff162a2013-01-03 22:48:49 +00001180 struct list_head upper_dev_list; /* List of upper devices */
1181
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001182 /* Interface address info used in eth_type_trans() */
Jiri Pirkof001fde2009-05-05 02:48:28 +00001183 unsigned char *dev_addr; /* hw address, (before bcast
1184 because most packets are
1185 unicast) */
1186
Jiri Pirko31278e72009-06-17 01:12:19 +00001187 struct netdev_hw_addr_list dev_addrs; /* list of device
1188 hw addresses */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001190 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
1191
david decotignyccf5ff62011-11-16 12:15:10 +00001192#ifdef CONFIG_SYSFS
Tom Herbert0a9627f2010-03-16 08:03:29 +00001193 struct kset *queues_kset;
david decotignyccf5ff62011-11-16 12:15:10 +00001194#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +00001195
david decotignyccf5ff62011-11-16 12:15:10 +00001196#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +00001197 struct netdev_rx_queue *_rx;
1198
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001199 /* Number of RX queues allocated at register_netdev() time */
Tom Herbert0a9627f2010-03-16 08:03:29 +00001200 unsigned int num_rx_queues;
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001201
1202 /* Number of RX queues currently active in device */
1203 unsigned int real_num_rx_queues;
Ben Hutchingsc4454772011-01-19 11:03:53 +00001204
1205#ifdef CONFIG_RFS_ACCEL
1206 /* CPU reverse-mapping for RX completion interrupts, indexed
1207 * by RX queue number. Assigned by driver. This must only be
1208 * set if the ndo_rx_flow_steer operation is defined. */
1209 struct cpu_rmap *rx_cpu_rmap;
1210#endif
Eric Dumazetdf334542010-03-24 19:13:54 +00001211#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +00001212
stephen hemminger61391cd2010-11-15 06:38:12 +00001213 rx_handler_func_t __rcu *rx_handler;
1214 void __rcu *rx_handler_data;
David S. Millere8a04642008-07-17 00:34:19 -07001215
Eric Dumazet24824a02010-10-02 06:11:55 +00001216 struct netdev_queue __rcu *ingress_queue;
Eric Dumazetcd135392010-09-16 02:58:13 +00001217
1218/*
1219 * Cache lines mostly used on transmit path
1220 */
David S. Millere8a04642008-07-17 00:34:19 -07001221 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001222
1223 /* Number of TX queues allocated at alloc_netdev_mq() time */
David S. Millere8a04642008-07-17 00:34:19 -07001224 unsigned int num_tx_queues;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001225
1226 /* Number of TX queues currently active in device */
1227 unsigned int real_num_tx_queues;
1228
Patrick McHardyaf356af2009-09-04 06:41:18 +00001229 /* root qdisc from userspace point of view */
1230 struct Qdisc *qdisc;
1231
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 unsigned long tx_queue_len; /* Max frames per queue allowed */
David S. Millerc3f26a22008-07-31 16:58:50 -07001233 spinlock_t tx_global_lock;
Eric Dumazetcd135392010-09-16 02:58:13 +00001234
Tom Herbertbf264142010-11-26 08:36:09 +00001235#ifdef CONFIG_XPS
Eric Dumazeta4177862010-11-28 21:43:02 +00001236 struct xps_dev_maps __rcu *xps_maps;
Tom Herbertbf264142010-11-26 08:36:09 +00001237#endif
Tom Herbert1d24eb42010-11-21 13:17:27 +00001238
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001239 /* These may be needed for future network-power-down code. */
Eric Dumazet9d214932009-05-17 20:55:16 -07001240
1241 /*
1242 * trans_start here is expensive for high speed devices on SMP,
1243 * please use netdev_queue->trans_start instead.
1244 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001245 unsigned long trans_start; /* Time (in jiffies) of last Tx */
1246
1247 int watchdog_timeo; /* used by dev_watchdog() */
1248 struct timer_list watchdog_timer;
1249
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 /* Number of references to this device */
Eric Dumazet29b44332010-10-11 10:22:12 +00001251 int __percpu *pcpu_refcnt;
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001252
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 /* delayed register/unregister */
1254 struct list_head todo_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 /* device index hash chain */
1256 struct hlist_node index_hlist;
1257
Eric Dumazete014deb2009-11-17 05:59:21 +00001258 struct list_head link_watch_list;
Herbert Xu572a1032007-05-08 18:34:17 -07001259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 /* register/unregister state machine */
1261 enum { NETREG_UNINITIALIZED=0,
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07001262 NETREG_REGISTERED, /* completed register_netdevice */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 NETREG_UNREGISTERING, /* called unregister_netdevice */
1264 NETREG_UNREGISTERED, /* completed unregister todo */
1265 NETREG_RELEASED, /* called free_netdev */
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001266 NETREG_DUMMY, /* dummy device for NAPI poll */
Eric Dumazet449f4542011-05-19 12:24:16 +00001267 } reg_state:8;
1268
1269 bool dismantle; /* device is going do be freed */
Patrick McHardya2835762010-02-26 06:34:51 +00001270
1271 enum {
1272 RTNL_LINK_INITIALIZED,
1273 RTNL_LINK_INITIALIZING,
1274 } rtnl_link_state:16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001276 /* Called from unregister, can be used to call free_netdev */
1277 void (*destructor)(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279#ifdef CONFIG_NETPOLL
Cong Wang5fbee842013-01-22 21:29:39 +00001280 struct netpoll_info __rcu *npinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281#endif
David S. Millereae792b2008-07-15 03:03:33 -07001282
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001283#ifdef CONFIG_NET_NS
Eric W. Biederman4a1c5372007-09-12 11:56:32 +02001284 /* Network namespace this network device is inside */
1285 struct net *nd_net;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001286#endif
Eric W. Biederman4a1c5372007-09-12 11:56:32 +02001287
David S. Miller49517042008-05-12 03:29:11 -07001288 /* mid-layer private */
Eric Dumazeta7855c72010-09-23 23:51:51 +00001289 union {
1290 void *ml_priv;
1291 struct pcpu_lstats __percpu *lstats; /* loopback stats */
Eric Dumazet290b8952010-09-27 00:33:35 +00001292 struct pcpu_tstats __percpu *tstats; /* tunnel stats */
Eric Dumazet6d81f412010-09-27 20:50:33 +00001293 struct pcpu_dstats __percpu *dstats; /* dummy stats */
Eric Dumazet26811282012-12-29 16:02:43 +00001294 struct pcpu_vstats __percpu *vstats; /* veth stats */
Eric Dumazeta7855c72010-09-23 23:51:51 +00001295 };
Patrick McHardyeca9eba2008-07-05 21:26:13 -07001296 /* GARP */
Eric Dumazet3cc77ec2010-10-24 21:32:36 +00001297 struct garp_port __rcu *garp_port;
David Wardfebf0182013-02-08 17:17:06 +00001298 /* MRP */
1299 struct mrp_port __rcu *mrp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 /* class/net/name entry */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001302 struct device dev;
Eric W. Biederman0c509a62009-10-29 14:18:21 +00001303 /* space for optional device, statistics, and wireless sysfs groups */
1304 const struct attribute_group *sysfs_groups[4];
Patrick McHardy38f7b872007-06-13 12:03:51 -07001305
1306 /* rtnetlink link ops */
1307 const struct rtnl_link_ops *rtnl_link_ops;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001308
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001309 /* for setting kernel sock attribute on TCP connection setup */
1310#define GSO_MAX_SIZE 65536
1311 unsigned int gso_max_size;
Ben Hutchings30b678d2012-07-30 15:57:00 +00001312#define GSO_MAX_SEGS 65535
1313 u16 gso_max_segs;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001314
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -08001315#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -08001316 /* Data Center Bridging netlink ops */
Stephen Hemminger32953542009-10-05 06:01:03 +00001317 const struct dcbnl_rtnl_ops *dcbnl_ops;
Alexander Duyck2f90b862008-11-20 20:52:10 -08001318#endif
John Fastabend4f57c082011-01-17 08:06:04 +00001319 u8 num_tc;
1320 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
1321 u8 prio_tc_map[TC_BITMASK + 1];
Alexander Duyck2f90b862008-11-20 20:52:10 -08001322
Ben Hutchingsd11ead72011-11-25 14:40:26 +00001323#if IS_ENABLED(CONFIG_FCOE)
Yi Zou4d288d52009-02-27 14:06:59 -08001324 /* max exchange id for FCoE LRO by ddp */
1325 unsigned int fcoe_ddp_xid;
1326#endif
Neil Horman5bc14212011-11-22 05:10:51 +00001327#if IS_ENABLED(CONFIG_NETPRIO_CGROUP)
1328 struct netprio_map __rcu *priomap;
1329#endif
Richard Cochranc1f19b52010-07-17 08:49:36 +00001330 /* phy device may attach itself for hardware timestamping */
1331 struct phy_device *phydev;
Vlad Dogarucbda10f2011-01-13 23:38:30 +00001332
Eric Dumazet23d3b8b2012-09-05 01:02:56 +00001333 struct lock_class_key *qdisc_tx_busylock;
1334
Vlad Dogarucbda10f2011-01-13 23:38:30 +00001335 /* group the device belongs to */
1336 int group;
Eric Dumazet91364612012-06-11 06:36:13 +00001337
1338 struct pm_qos_request pm_qos_req;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339};
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001340#define to_net_dev(d) container_of(d, struct net_device, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342#define NETDEV_ALIGN 32
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
David S. Millere8a04642008-07-17 00:34:19 -07001344static inline
John Fastabend4f57c082011-01-17 08:06:04 +00001345int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
1346{
1347 return dev->prio_tc_map[prio & TC_BITMASK];
1348}
1349
1350static inline
1351int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
1352{
1353 if (tc >= dev->num_tc)
1354 return -EINVAL;
1355
1356 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
1357 return 0;
1358}
1359
1360static inline
1361void netdev_reset_tc(struct net_device *dev)
1362{
1363 dev->num_tc = 0;
1364 memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
1365 memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
1366}
1367
1368static inline
1369int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
1370{
1371 if (tc >= dev->num_tc)
1372 return -EINVAL;
1373
1374 dev->tc_to_txq[tc].count = count;
1375 dev->tc_to_txq[tc].offset = offset;
1376 return 0;
1377}
1378
1379static inline
1380int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
1381{
1382 if (num_tc > TC_MAX_QUEUE)
1383 return -EINVAL;
1384
1385 dev->num_tc = num_tc;
1386 return 0;
1387}
1388
1389static inline
1390int netdev_get_num_tc(struct net_device *dev)
1391{
1392 return dev->num_tc;
1393}
1394
1395static inline
David S. Millere8a04642008-07-17 00:34:19 -07001396struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
1397 unsigned int index)
1398{
1399 return &dev->_tx[index];
1400}
1401
1402static inline void netdev_for_each_tx_queue(struct net_device *dev,
1403 void (*f)(struct net_device *,
1404 struct netdev_queue *,
1405 void *),
1406 void *arg)
1407{
1408 unsigned int i;
1409
1410 for (i = 0; i < dev->num_tx_queues; i++)
1411 f(dev, &dev->_tx[i], arg);
1412}
1413
Amerigo Wang8c4c49d2012-09-17 20:16:31 +00001414extern struct netdev_queue *netdev_pick_tx(struct net_device *dev,
1415 struct sk_buff *skb);
Alexander Duyck416186f2013-01-10 08:56:51 +00001416extern u16 __netdev_pick_tx(struct net_device *dev, struct sk_buff *skb);
Amerigo Wang8c4c49d2012-09-17 20:16:31 +00001417
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001418/*
1419 * Net namespace inlines
1420 */
1421static inline
1422struct net *dev_net(const struct net_device *dev)
1423{
Eric Dumazetc2d9ba92010-06-01 06:51:19 +00001424 return read_pnet(&dev->nd_net);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001425}
1426
1427static inline
Denis V. Lunevf5aa23f2008-03-26 00:48:17 -07001428void dev_net_set(struct net_device *dev, struct net *net)
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001429{
1430#ifdef CONFIG_NET_NS
Denis V. Lunevf3005d72008-04-16 02:02:18 -07001431 release_net(dev->nd_net);
1432 dev->nd_net = hold_net(net);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001433#endif
1434}
1435
Lennert Buytenhekcf85d082008-10-07 13:45:02 +00001436static inline bool netdev_uses_dsa_tags(struct net_device *dev)
1437{
1438#ifdef CONFIG_NET_DSA_TAG_DSA
1439 if (dev->dsa_ptr != NULL)
1440 return dsa_uses_dsa_tags(dev->dsa_ptr);
1441#endif
1442
1443 return 0;
1444}
1445
Lennert Buytenhek396138f2008-10-07 13:46:07 +00001446static inline bool netdev_uses_trailer_tags(struct net_device *dev)
1447{
1448#ifdef CONFIG_NET_DSA_TAG_TRAILER
1449 if (dev->dsa_ptr != NULL)
1450 return dsa_uses_trailer_tags(dev->dsa_ptr);
1451#endif
1452
1453 return 0;
1454}
1455
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001456/**
1457 * netdev_priv - access network device private data
1458 * @dev: network device
1459 *
1460 * Get network device private data
1461 */
Patrick McHardy6472ce62007-06-13 12:03:21 -07001462static inline void *netdev_priv(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463{
Eric Dumazet1ce8e7b2009-05-27 04:42:37 +00001464 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465}
1466
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467/* Set the sysfs physical device reference for the network logical device
1468 * if set prior to registration will cause a symlink during initialization.
1469 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001470#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
Marcel Holtmann384912e2009-08-31 21:08:19 +00001472/* Set the sysfs device type for the network logical device to allow
1473 * fin grained indentification of different network device types. For
1474 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
1475 */
1476#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
1477
Stephen Hemminger3b582cc2007-11-01 02:21:47 -07001478/**
1479 * netif_napi_add - initialize a napi context
1480 * @dev: network device
1481 * @napi: napi context
1482 * @poll: polling function
1483 * @weight: default weight
1484 *
1485 * netif_napi_add() must be used to initialize a napi context prior to calling
1486 * *any* of the other napi related functions.
1487 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001488void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
1489 int (*poll)(struct napi_struct *, int), int weight);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001490
Alexander Duyckd8156532008-07-08 15:13:05 -07001491/**
1492 * netif_napi_del - remove a napi context
1493 * @napi: napi context
1494 *
1495 * netif_napi_del() removes a napi context from the network device napi list
1496 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001497void netif_napi_del(struct napi_struct *napi);
1498
1499struct napi_gro_cb {
Herbert Xu78a478d2009-05-26 18:50:21 +00001500 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
1501 void *frag0;
1502
Herbert Xu74895942009-05-26 18:50:27 +00001503 /* Length of frag0. */
1504 unsigned int frag0_len;
1505
Herbert Xu86911732009-01-29 14:19:50 +00001506 /* This indicates where we are processing relative to skb->data. */
1507 int data_offset;
1508
Herbert Xud565b0a2008-12-15 23:38:52 -08001509 /* This is non-zero if the packet cannot be merged with the new skb. */
1510 int flush;
1511
1512 /* Number of segments aggregated. */
Eric Dumazet2e71a6f2012-10-06 08:08:49 +00001513 u16 count;
1514
1515 /* This is non-zero if the packet may be of the same flow. */
1516 u8 same_flow;
Herbert Xu5d38a072009-01-04 16:13:40 -08001517
1518 /* Free the skb? */
Eric Dumazet2e71a6f2012-10-06 08:08:49 +00001519 u8 free;
Eric Dumazetd7e88832012-04-30 08:10:34 +00001520#define NAPI_GRO_FREE 1
1521#define NAPI_GRO_FREE_STOLEN_HEAD 2
Eric Dumazet2e71a6f2012-10-06 08:08:49 +00001522
1523 /* jiffies when first packet was created/queued */
1524 unsigned long age;
Eric Dumazet86347242012-10-08 21:38:50 +02001525
1526 /* Used in ipv6_gro_receive() */
1527 int proto;
Eric Dumazetc3c7c252012-12-06 13:54:59 +00001528
1529 /* used in skb_gro_receive() slow path */
1530 struct sk_buff *last;
Herbert Xud565b0a2008-12-15 23:38:52 -08001531};
1532
1533#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
Alexander Duyckd8156532008-07-08 15:13:05 -07001534
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535struct packet_type {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001536 __be16 type; /* This is really htons(ether_type). */
1537 struct net_device *dev; /* NULL is wildcarded here */
1538 int (*func) (struct sk_buff *,
1539 struct net_device *,
1540 struct packet_type *,
1541 struct net_device *);
Eric Leblondc0de08d2012-08-16 22:02:58 +00001542 bool (*id_match)(struct packet_type *ptype,
1543 struct sock *sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 void *af_packet_priv;
1545 struct list_head list;
1546};
1547
Vlad Yasevichf191a1d2012-11-15 08:49:23 +00001548struct offload_callbacks {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
1550 netdev_features_t features);
1551 int (*gso_send_check)(struct sk_buff *skb);
1552 struct sk_buff **(*gro_receive)(struct sk_buff **head,
1553 struct sk_buff *skb);
1554 int (*gro_complete)(struct sk_buff *skb);
Vlad Yasevichf191a1d2012-11-15 08:49:23 +00001555};
1556
1557struct packet_offload {
1558 __be16 type; /* This is really htons(ether_type). */
1559 struct offload_callbacks callbacks;
1560 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561};
1562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563#include <linux/notifier.h>
1564
Amerigo Wangdcfe1422011-07-25 17:13:09 -07001565/* netdevice notifier chain. Please remember to update the rtnetlink
1566 * notification exclusion list in rtnetlink_event() when adding new
1567 * types.
1568 */
1569#define NETDEV_UP 0x0001 /* For now you can't veto a device up/down */
1570#define NETDEV_DOWN 0x0002
1571#define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface
1572 detected a hardware crash and restarted
1573 - we can use this eg to kick tcp sessions
1574 once done */
1575#define NETDEV_CHANGE 0x0004 /* Notify device state change */
1576#define NETDEV_REGISTER 0x0005
1577#define NETDEV_UNREGISTER 0x0006
1578#define NETDEV_CHANGEMTU 0x0007
1579#define NETDEV_CHANGEADDR 0x0008
1580#define NETDEV_GOING_DOWN 0x0009
1581#define NETDEV_CHANGENAME 0x000A
1582#define NETDEV_FEAT_CHANGE 0x000B
1583#define NETDEV_BONDING_FAILOVER 0x000C
1584#define NETDEV_PRE_UP 0x000D
1585#define NETDEV_PRE_TYPE_CHANGE 0x000E
1586#define NETDEV_POST_TYPE_CHANGE 0x000F
1587#define NETDEV_POST_INIT 0x0010
Eric Dumazet0115e8e2012-08-22 17:19:46 +00001588#define NETDEV_UNREGISTER_FINAL 0x0011
Amerigo Wangdcfe1422011-07-25 17:13:09 -07001589#define NETDEV_RELEASE 0x0012
1590#define NETDEV_NOTIFY_PEERS 0x0013
1591#define NETDEV_JOIN 0x0014
1592
1593extern int register_netdevice_notifier(struct notifier_block *nb);
1594extern int unregister_netdevice_notifier(struct notifier_block *nb);
1595extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
1596
1597
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598extern rwlock_t dev_base_lock; /* Device list lock */
1599
Eric Dumazet30e6c9f2012-12-20 17:25:08 +00001600extern seqcount_t devnet_rename_seq; /* Device rename seq */
Brian Haleyc91f6df2012-11-26 05:21:08 +00001601
Eric W. Biederman881d9662007-09-17 11:56:21 -07001602
1603#define for_each_netdev(net, d) \
1604 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
Eric W. Biedermandcbccbd42009-11-29 22:25:26 +00001605#define for_each_netdev_reverse(net, d) \
1606 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001607#define for_each_netdev_rcu(net, d) \
1608 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
Eric W. Biederman881d9662007-09-17 11:56:21 -07001609#define for_each_netdev_safe(net, d, n) \
1610 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
1611#define for_each_netdev_continue(net, d) \
1612 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
stephen hemminger254245d2009-11-10 07:54:47 +00001613#define for_each_netdev_continue_rcu(net, d) \
1614 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001615#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
1616
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001617static inline struct net_device *next_net_device(struct net_device *dev)
1618{
1619 struct list_head *lh;
1620 struct net *net;
Pavel Emelianov7562f872007-05-03 15:13:45 -07001621
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001622 net = dev_net(dev);
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001623 lh = dev->dev_list.next;
1624 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1625}
1626
Eric Dumazetce81b762009-11-11 17:34:30 +00001627static inline struct net_device *next_net_device_rcu(struct net_device *dev)
1628{
1629 struct list_head *lh;
1630 struct net *net;
1631
1632 net = dev_net(dev);
Eric Dumazetccf43432011-01-26 18:08:02 +00001633 lh = rcu_dereference(list_next_rcu(&dev->dev_list));
Eric Dumazetce81b762009-11-11 17:34:30 +00001634 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1635}
1636
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001637static inline struct net_device *first_net_device(struct net *net)
1638{
1639 return list_empty(&net->dev_base_head) ? NULL :
1640 net_device_entry(net->dev_base_head.next);
1641}
Pavel Emelianov7562f872007-05-03 15:13:45 -07001642
Eric Dumazetccf43432011-01-26 18:08:02 +00001643static inline struct net_device *first_net_device_rcu(struct net *net)
1644{
1645 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
1646
1647 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1648}
1649
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650extern int netdev_boot_setup_check(struct net_device *dev);
1651extern unsigned long netdev_boot_base(const char *prefix, int unit);
Eric Dumazet941666c2010-12-05 01:23:53 +00001652extern struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
1653 const char *hwaddr);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001654extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
1655extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656extern void dev_add_pack(struct packet_type *pt);
1657extern void dev_remove_pack(struct packet_type *pt);
1658extern void __dev_remove_pack(struct packet_type *pt);
Vlad Yasevich62532da2012-11-15 08:49:10 +00001659extern void dev_add_offload(struct packet_offload *po);
1660extern void dev_remove_offload(struct packet_offload *po);
1661extern void __dev_remove_offload(struct packet_offload *po);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
Eric Dumazetbb69ae02010-06-07 11:42:13 +00001663extern struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags,
1664 unsigned short mask);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001665extern struct net_device *dev_get_by_name(struct net *net, const char *name);
Eric Dumazet72c95282009-10-30 07:11:27 +00001666extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001667extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668extern int dev_alloc_name(struct net_device *dev, const char *name);
1669extern int dev_open(struct net_device *dev);
1670extern int dev_close(struct net_device *dev);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001671extern void dev_disable_lro(struct net_device *dev);
Michel Machado95603e22012-06-12 10:16:35 +00001672extern int dev_loopback_xmit(struct sk_buff *newskb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673extern int dev_queue_xmit(struct sk_buff *skb);
1674extern int register_netdevice(struct net_device *dev);
Eric Dumazet44a08732009-10-27 07:03:04 +00001675extern void unregister_netdevice_queue(struct net_device *dev,
1676 struct list_head *head);
Eric Dumazet9b5e3832009-10-27 07:04:19 +00001677extern void unregister_netdevice_many(struct list_head *head);
Eric Dumazet44a08732009-10-27 07:03:04 +00001678static inline void unregister_netdevice(struct net_device *dev)
1679{
1680 unregister_netdevice_queue(dev, NULL);
1681}
1682
Eric Dumazet29b44332010-10-11 10:22:12 +00001683extern int netdev_refcnt_read(const struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684extern void free_netdev(struct net_device *dev);
1685extern void synchronize_net(void);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001686extern int init_dummy_netdev(struct net_device *dev);
David S. Miller9d40bbd2009-03-04 23:46:25 -08001687extern void netdev_resync_ops(struct net_device *dev);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001688
Eric W. Biederman881d9662007-09-17 11:56:21 -07001689extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
1690extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
Eric Dumazetfb699dfd2009-10-19 19:18:49 +00001691extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692extern int dev_restart(struct net_device *dev);
1693#ifdef CONFIG_NETPOLL_TRAP
1694extern int netpoll_trap(void);
1695#endif
Herbert Xu86911732009-01-29 14:19:50 +00001696extern int skb_gro_receive(struct sk_buff **head,
1697 struct sk_buff *skb);
1698
1699static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
1700{
1701 return NAPI_GRO_CB(skb)->data_offset;
1702}
1703
1704static inline unsigned int skb_gro_len(const struct sk_buff *skb)
1705{
1706 return skb->len - NAPI_GRO_CB(skb)->data_offset;
1707}
1708
1709static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
1710{
1711 NAPI_GRO_CB(skb)->data_offset += len;
1712}
1713
Herbert Xua5b1cf22009-05-26 18:50:28 +00001714static inline void *skb_gro_header_fast(struct sk_buff *skb,
1715 unsigned int offset)
Herbert Xu86911732009-01-29 14:19:50 +00001716{
Herbert Xu78a478d2009-05-26 18:50:21 +00001717 return NAPI_GRO_CB(skb)->frag0 + offset;
Herbert Xu86911732009-01-29 14:19:50 +00001718}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719
Herbert Xua5b1cf22009-05-26 18:50:28 +00001720static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
1721{
1722 return NAPI_GRO_CB(skb)->frag0_len < hlen;
1723}
1724
1725static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
1726 unsigned int offset)
1727{
Herbert Xu17dd7592011-07-27 06:16:28 -07001728 if (!pskb_may_pull(skb, hlen))
1729 return NULL;
1730
Herbert Xua5b1cf22009-05-26 18:50:28 +00001731 NAPI_GRO_CB(skb)->frag0 = NULL;
1732 NAPI_GRO_CB(skb)->frag0_len = 0;
Herbert Xu17dd7592011-07-27 06:16:28 -07001733 return skb->data + offset;
Herbert Xua5b1cf22009-05-26 18:50:28 +00001734}
1735
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001736static inline void *skb_gro_mac_header(struct sk_buff *skb)
1737{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001738 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001739}
1740
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001741static inline void *skb_gro_network_header(struct sk_buff *skb)
1742{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001743 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
1744 skb_network_offset(skb);
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001745}
1746
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001747static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
1748 unsigned short type,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001749 const void *daddr, const void *saddr,
Eric Dumazet95c96172012-04-15 05:58:06 +00001750 unsigned int len)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001751{
Ursula Braunf1ecfd52007-10-22 16:16:14 +02001752 if (!dev->header_ops || !dev->header_ops->create)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001753 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001754
1755 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001756}
1757
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001758static inline int dev_parse_header(const struct sk_buff *skb,
1759 unsigned char *haddr)
1760{
1761 const struct net_device *dev = skb->dev;
1762
Patrick McHardy1b833362007-10-18 05:09:28 -07001763 if (!dev->header_ops || !dev->header_ops->parse)
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001764 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001765 return dev->header_ops->parse(skb, haddr);
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001766}
1767
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
1769extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
1770static inline int unregister_gifconf(unsigned int family)
1771{
1772 return register_gifconf(family, NULL);
1773}
1774
1775/*
Eric Dumazet88751272010-04-19 05:07:33 +00001776 * Incoming packets are placed on per-cpu queues
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 */
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08001778struct softnet_data {
David S. Miller37437bb2008-07-16 02:15:04 -07001779 struct Qdisc *output_queue;
Changli Gaoa9cbd582010-04-26 23:06:24 +00001780 struct Qdisc **output_queue_tailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 struct list_head poll_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 struct sk_buff *completion_queue;
Changli Gao6e7676c2010-04-27 15:07:33 -07001783 struct sk_buff_head process_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
Changli Gaodee42872010-05-02 05:42:16 +00001785 /* stats */
David S. Millercd7b5392010-05-02 22:27:59 -07001786 unsigned int processed;
1787 unsigned int time_squeeze;
1788 unsigned int cpu_collision;
1789 unsigned int received_rps;
Changli Gaodee42872010-05-02 05:42:16 +00001790
Changli Gaofd793d82010-04-15 00:16:59 -07001791#ifdef CONFIG_RPS
Eric Dumazet88751272010-04-19 05:07:33 +00001792 struct softnet_data *rps_ipi_list;
1793
1794 /* Elements below can be accessed between CPUs for RPS */
Tom Herbert0a9627f2010-03-16 08:03:29 +00001795 struct call_single_data csd ____cacheline_aligned_in_smp;
Eric Dumazet88751272010-04-19 05:07:33 +00001796 struct softnet_data *rps_ipi_next;
1797 unsigned int cpu;
Tom Herbertfec5e652010-04-16 16:01:27 -07001798 unsigned int input_queue_head;
Tom Herbert76cc8b12010-05-20 18:37:59 +00001799 unsigned int input_queue_tail;
Tom Herbert1e94d722010-03-18 17:45:44 -07001800#endif
Eric Dumazet95c96172012-04-15 05:58:06 +00001801 unsigned int dropped;
Tom Herbert0a9627f2010-03-16 08:03:29 +00001802 struct sk_buff_head input_pkt_queue;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001803 struct napi_struct backlog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804};
1805
Tom Herbert76cc8b12010-05-20 18:37:59 +00001806static inline void input_queue_head_incr(struct softnet_data *sd)
Tom Herbertfec5e652010-04-16 16:01:27 -07001807{
1808#ifdef CONFIG_RPS
Tom Herbert76cc8b12010-05-20 18:37:59 +00001809 sd->input_queue_head++;
1810#endif
1811}
1812
1813static inline void input_queue_tail_incr_save(struct softnet_data *sd,
1814 unsigned int *qtail)
1815{
1816#ifdef CONFIG_RPS
1817 *qtail = ++sd->input_queue_tail;
Tom Herbertfec5e652010-04-16 16:01:27 -07001818#endif
1819}
1820
Tom Herbert0a9627f2010-03-16 08:03:29 +00001821DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822
David S. Miller37437bb2008-07-16 02:15:04 -07001823extern void __netif_schedule(struct Qdisc *q);
David S. Miller86d804e2008-07-08 23:11:25 -07001824
1825static inline void netif_schedule_queue(struct netdev_queue *txq)
1826{
Tom Herbert734664982011-11-28 16:32:44 +00001827 if (!(txq->state & QUEUE_STATE_ANY_XOFF))
David S. Miller37437bb2008-07-16 02:15:04 -07001828 __netif_schedule(txq->qdisc);
David S. Miller86d804e2008-07-08 23:11:25 -07001829}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001831static inline void netif_tx_schedule_all(struct net_device *dev)
1832{
1833 unsigned int i;
1834
1835 for (i = 0; i < dev->num_tx_queues; i++)
1836 netif_schedule_queue(netdev_get_tx_queue(dev, i));
1837}
1838
Dave Jonesd29f7492008-07-22 14:09:06 -07001839static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
1840{
Tom Herbert734664982011-11-28 16:32:44 +00001841 clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
Dave Jonesd29f7492008-07-22 14:09:06 -07001842}
1843
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001844/**
1845 * netif_start_queue - allow transmit
1846 * @dev: network device
1847 *
1848 * Allow upper layers to call the device hard_start_xmit routine.
1849 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850static inline void netif_start_queue(struct net_device *dev)
1851{
David S. Millere8a04642008-07-17 00:34:19 -07001852 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853}
1854
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001855static inline void netif_tx_start_all_queues(struct net_device *dev)
1856{
1857 unsigned int i;
1858
1859 for (i = 0; i < dev->num_tx_queues; i++) {
1860 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1861 netif_tx_start_queue(txq);
1862 }
1863}
1864
David S. Miller79d16382008-07-08 23:14:46 -07001865static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866{
1867#ifdef CONFIG_NETPOLL_TRAP
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001868 if (netpoll_trap()) {
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001869 netif_tx_start_queue(dev_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 return;
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001871 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872#endif
Tom Herbert734664982011-11-28 16:32:44 +00001873 if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001874 __netif_schedule(dev_queue->qdisc);
David S. Miller79d16382008-07-08 23:14:46 -07001875}
1876
Dave Jonesd29f7492008-07-22 14:09:06 -07001877/**
1878 * netif_wake_queue - restart transmit
1879 * @dev: network device
1880 *
1881 * Allow upper layers to call the device hard_start_xmit routine.
1882 * Used for flow control when transmit resources are available.
1883 */
David S. Miller79d16382008-07-08 23:14:46 -07001884static inline void netif_wake_queue(struct net_device *dev)
1885{
David S. Millere8a04642008-07-17 00:34:19 -07001886 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887}
1888
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001889static inline void netif_tx_wake_all_queues(struct net_device *dev)
1890{
1891 unsigned int i;
1892
1893 for (i = 0; i < dev->num_tx_queues; i++) {
1894 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1895 netif_tx_wake_queue(txq);
1896 }
1897}
1898
Dave Jonesd29f7492008-07-22 14:09:06 -07001899static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
1900{
Guillaume Chazarain18543a62010-11-06 06:39:32 +00001901 if (WARN_ON(!dev_queue)) {
Joe Perches256ee432011-03-01 07:06:12 +00001902 pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
Guillaume Chazarain18543a62010-11-06 06:39:32 +00001903 return;
1904 }
Tom Herbert734664982011-11-28 16:32:44 +00001905 set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
Dave Jonesd29f7492008-07-22 14:09:06 -07001906}
1907
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001908/**
1909 * netif_stop_queue - stop transmitted packets
1910 * @dev: network device
1911 *
1912 * Stop upper layers calling the device hard_start_xmit routine.
1913 * Used for flow control when transmit resources are unavailable.
1914 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915static inline void netif_stop_queue(struct net_device *dev)
1916{
David S. Millere8a04642008-07-17 00:34:19 -07001917 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918}
1919
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001920static inline void netif_tx_stop_all_queues(struct net_device *dev)
1921{
1922 unsigned int i;
1923
1924 for (i = 0; i < dev->num_tx_queues; i++) {
1925 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1926 netif_tx_stop_queue(txq);
1927 }
1928}
1929
David S. Miller4d295152012-03-07 21:02:35 -05001930static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
Dave Jonesd29f7492008-07-22 14:09:06 -07001931{
Tom Herbert734664982011-11-28 16:32:44 +00001932 return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
Dave Jonesd29f7492008-07-22 14:09:06 -07001933}
1934
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001935/**
1936 * netif_queue_stopped - test if transmit queue is flowblocked
1937 * @dev: network device
1938 *
1939 * Test if transmit queue on device is currently unable to send.
1940 */
David S. Miller4d295152012-03-07 21:02:35 -05001941static inline bool netif_queue_stopped(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942{
David S. Millere8a04642008-07-17 00:34:19 -07001943 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944}
1945
David S. Miller4d295152012-03-07 21:02:35 -05001946static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
David S. Millerc3f26a22008-07-31 16:58:50 -07001947{
Tom Herbert734664982011-11-28 16:32:44 +00001948 return dev_queue->state & QUEUE_STATE_ANY_XOFF;
1949}
1950
David S. Miller4d295152012-03-07 21:02:35 -05001951static inline bool netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
Tom Herbert734664982011-11-28 16:32:44 +00001952{
1953 return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
1954}
1955
Tom Herbertc5d67bd2011-11-28 16:32:52 +00001956static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
1957 unsigned int bytes)
1958{
Tom Herbert114cf582011-11-28 16:33:09 +00001959#ifdef CONFIG_BQL
1960 dql_queued(&dev_queue->dql, bytes);
Alexander Duyckb37c0fb2012-02-07 02:29:06 +00001961
1962 if (likely(dql_avail(&dev_queue->dql) >= 0))
1963 return;
1964
1965 set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
1966
1967 /*
1968 * The XOFF flag must be set before checking the dql_avail below,
1969 * because in netdev_tx_completed_queue we update the dql_completed
1970 * before checking the XOFF flag.
1971 */
1972 smp_mb();
1973
1974 /* check again in case another CPU has just made room avail */
1975 if (unlikely(dql_avail(&dev_queue->dql) >= 0))
1976 clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
Tom Herbert114cf582011-11-28 16:33:09 +00001977#endif
Tom Herbertc5d67bd2011-11-28 16:32:52 +00001978}
1979
1980static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
1981{
1982 netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes);
1983}
1984
1985static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
Eric Dumazet95c96172012-04-15 05:58:06 +00001986 unsigned int pkts, unsigned int bytes)
Tom Herbertc5d67bd2011-11-28 16:32:52 +00001987{
Tom Herbert114cf582011-11-28 16:33:09 +00001988#ifdef CONFIG_BQL
Alexander Duyckb37c0fb2012-02-07 02:29:06 +00001989 if (unlikely(!bytes))
1990 return;
1991
1992 dql_completed(&dev_queue->dql, bytes);
1993
1994 /*
1995 * Without the memory barrier there is a small possiblity that
1996 * netdev_tx_sent_queue will miss the update and cause the queue to
1997 * be stopped forever
1998 */
1999 smp_mb();
2000
2001 if (dql_avail(&dev_queue->dql) < 0)
2002 return;
2003
2004 if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
2005 netif_schedule_queue(dev_queue);
Tom Herbert114cf582011-11-28 16:33:09 +00002006#endif
Tom Herbertc5d67bd2011-11-28 16:32:52 +00002007}
2008
2009static inline void netdev_completed_queue(struct net_device *dev,
Eric Dumazet95c96172012-04-15 05:58:06 +00002010 unsigned int pkts, unsigned int bytes)
Tom Herbertc5d67bd2011-11-28 16:32:52 +00002011{
2012 netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes);
2013}
2014
2015static inline void netdev_tx_reset_queue(struct netdev_queue *q)
2016{
Tom Herbert114cf582011-11-28 16:33:09 +00002017#ifdef CONFIG_BQL
Alexander Duyck5c490352012-02-07 02:29:01 +00002018 clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
Tom Herbert114cf582011-11-28 16:33:09 +00002019 dql_reset(&q->dql);
2020#endif
Tom Herbertc5d67bd2011-11-28 16:32:52 +00002021}
2022
2023static inline void netdev_reset_queue(struct net_device *dev_queue)
2024{
2025 netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0));
David S. Millerc3f26a22008-07-31 16:58:50 -07002026}
2027
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002028/**
2029 * netif_running - test if up
2030 * @dev: network device
2031 *
2032 * Test if the device has been brought up.
2033 */
David S. Miller4d295152012-03-07 21:02:35 -05002034static inline bool netif_running(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035{
2036 return test_bit(__LINK_STATE_START, &dev->state);
2037}
2038
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002039/*
2040 * Routines to manage the subqueues on a device. We only need start
2041 * stop, and a check if it's stopped. All other device management is
2042 * done at the overall netdevice level.
2043 * Also test the device if we're multiqueue.
2044 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002045
2046/**
2047 * netif_start_subqueue - allow sending packets on subqueue
2048 * @dev: network device
2049 * @queue_index: sub queue index
2050 *
2051 * Start individual transmit queue of a device with multiple transmit queues.
2052 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002053static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
2054{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002055 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00002056
2057 netif_tx_start_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002058}
2059
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002060/**
2061 * netif_stop_subqueue - stop sending packets on subqueue
2062 * @dev: network device
2063 * @queue_index: sub queue index
2064 *
2065 * Stop individual transmit queue of a device with multiple transmit queues.
2066 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002067static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
2068{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002069 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002070#ifdef CONFIG_NETPOLL_TRAP
2071 if (netpoll_trap())
2072 return;
2073#endif
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00002074 netif_tx_stop_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002075}
2076
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002077/**
2078 * netif_subqueue_stopped - test status of subqueue
2079 * @dev: network device
2080 * @queue_index: sub queue index
2081 *
2082 * Check individual transmit queue of a device with multiple transmit queues.
2083 */
David S. Miller4d295152012-03-07 21:02:35 -05002084static inline bool __netif_subqueue_stopped(const struct net_device *dev,
2085 u16 queue_index)
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002086{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002087 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00002088
2089 return netif_tx_queue_stopped(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002090}
2091
David S. Miller4d295152012-03-07 21:02:35 -05002092static inline bool netif_subqueue_stopped(const struct net_device *dev,
2093 struct sk_buff *skb)
Pavel Emelyanov668f8952007-10-21 17:01:56 -07002094{
2095 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
2096}
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002097
2098/**
2099 * netif_wake_subqueue - allow sending packets on subqueue
2100 * @dev: network device
2101 * @queue_index: sub queue index
2102 *
2103 * Resume individual transmit queue of a device with multiple transmit queues.
2104 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002105static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
2106{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002107 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002108#ifdef CONFIG_NETPOLL_TRAP
2109 if (netpoll_trap())
2110 return;
2111#endif
Tom Herbert734664982011-11-28 16:32:44 +00002112 if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07002113 __netif_schedule(txq->qdisc);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002114}
2115
Alexander Duyck537c00d2013-01-10 08:57:02 +00002116#ifdef CONFIG_XPS
Alexander Duyck537c00d2013-01-10 08:57:02 +00002117extern int netif_set_xps_queue(struct net_device *dev, struct cpumask *mask,
2118 u16 index);
2119#else
2120static inline int netif_set_xps_queue(struct net_device *dev,
2121 struct cpumask *mask,
2122 u16 index)
2123{
2124 return 0;
2125}
2126#endif
2127
Vladislav Zolotarova3d22a62010-12-13 06:27:10 +00002128/*
2129 * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
2130 * as a distribution range limit for the returned value.
2131 */
2132static inline u16 skb_tx_hash(const struct net_device *dev,
2133 const struct sk_buff *skb)
2134{
2135 return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
2136}
2137
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002138/**
2139 * netif_is_multiqueue - test if device has multiple transmit queues
2140 * @dev: network device
2141 *
2142 * Check if device has multiple transmit queues
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002143 */
David S. Miller4d295152012-03-07 21:02:35 -05002144static inline bool netif_is_multiqueue(const struct net_device *dev)
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002145{
Eric Dumazeta02cec22010-09-22 20:43:57 +00002146 return dev->num_tx_queues > 1;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002147}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148
Tom Herberte6484932010-10-18 18:04:39 +00002149extern int netif_set_real_num_tx_queues(struct net_device *dev,
2150 unsigned int txq);
John Fastabendf0796d52010-07-01 13:21:57 +00002151
Ben Hutchings62fe0b42010-09-27 08:24:33 +00002152#ifdef CONFIG_RPS
2153extern int netif_set_real_num_rx_queues(struct net_device *dev,
2154 unsigned int rxq);
2155#else
2156static inline int netif_set_real_num_rx_queues(struct net_device *dev,
2157 unsigned int rxq)
2158{
2159 return 0;
2160}
2161#endif
2162
Ben Hutchings3171d022010-09-27 08:24:49 +00002163static inline int netif_copy_real_num_queues(struct net_device *to_dev,
2164 const struct net_device *from_dev)
2165{
Jiri Pirkoee6ae1a2012-07-20 02:28:46 +00002166 int err;
2167
2168 err = netif_set_real_num_tx_queues(to_dev,
2169 from_dev->real_num_tx_queues);
2170 if (err)
2171 return err;
Ben Hutchings3171d022010-09-27 08:24:49 +00002172#ifdef CONFIG_RPS
2173 return netif_set_real_num_rx_queues(to_dev,
2174 from_dev->real_num_rx_queues);
2175#else
2176 return 0;
2177#endif
2178}
2179
Yuval Mintz16917b82012-07-01 03:18:50 +00002180#define DEFAULT_MAX_NUM_RSS_QUEUES (8)
2181extern int netif_get_num_default_rss_queues(void);
2182
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183/* Use this variant when it is known for sure that it
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07002184 * is executing from hardware interrupt context or with hardware interrupts
2185 * disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002187extern void dev_kfree_skb_irq(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
2189/* Use this variant in places where it could be invoked
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07002190 * from either hardware interrupt or other context, with hardware interrupts
2191 * either disabled or enabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 */
Denis Vlasenko56079432006-03-29 15:57:29 -08002193extern void dev_kfree_skb_any(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195extern int netif_rx(struct sk_buff *skb);
2196extern int netif_rx_ni(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197extern int netif_receive_skb(struct sk_buff *skb);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07002198extern gro_result_t napi_gro_receive(struct napi_struct *napi,
Herbert Xud565b0a2008-12-15 23:38:52 -08002199 struct sk_buff *skb);
Eric Dumazet2e71a6f2012-10-06 08:08:49 +00002200extern void napi_gro_flush(struct napi_struct *napi, bool flush_old);
Herbert Xu76620aa2009-04-16 02:02:07 -07002201extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07002202extern gro_result_t napi_gro_frags(struct napi_struct *napi);
Herbert Xu76620aa2009-04-16 02:02:07 -07002203
2204static inline void napi_free_frags(struct napi_struct *napi)
2205{
2206 kfree_skb(napi->skb);
2207 napi->skb = NULL;
2208}
2209
Jiri Pirkoab95bfe2010-06-01 21:52:08 +00002210extern int netdev_rx_handler_register(struct net_device *dev,
Jiri Pirko93e2c322010-06-10 03:34:59 +00002211 rx_handler_func_t *rx_handler,
2212 void *rx_handler_data);
Jiri Pirkoab95bfe2010-06-01 21:52:08 +00002213extern void netdev_rx_handler_unregister(struct net_device *dev);
2214
David S. Miller95f050b2012-03-06 16:12:15 -05002215extern bool dev_valid_name(const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07002216extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
2217extern int dev_ethtool(struct net *net, struct ifreq *);
Eric Dumazet95c96172012-04-15 05:58:06 +00002218extern unsigned int dev_get_flags(const struct net_device *);
Patrick McHardybd380812010-02-26 06:34:53 +00002219extern int __dev_change_flags(struct net_device *, unsigned int flags);
Eric Dumazet95c96172012-04-15 05:58:06 +00002220extern int dev_change_flags(struct net_device *, unsigned int);
Patrick McHardybd380812010-02-26 06:34:53 +00002221extern void __dev_notify_flags(struct net_device *, unsigned int old_flags);
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -07002222extern int dev_change_name(struct net_device *, const char *);
Stephen Hemminger0b815a12008-09-22 21:28:11 -07002223extern int dev_set_alias(struct net_device *, const char *, size_t);
Eric W. Biedermance286d32007-09-12 13:53:49 +02002224extern int dev_change_net_namespace(struct net_device *,
2225 struct net *, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226extern int dev_set_mtu(struct net_device *, int);
Vlad Dogarucbda10f2011-01-13 23:38:30 +00002227extern void dev_set_group(struct net_device *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228extern int dev_set_mac_address(struct net_device *,
2229 struct sockaddr *);
Jiri Pirko4bf84c32012-12-27 23:49:37 +00002230extern int dev_change_carrier(struct net_device *,
2231 bool new_carrier);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07002232extern int dev_hard_start_xmit(struct sk_buff *skb,
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002233 struct net_device *dev,
2234 struct netdev_queue *txq);
Arnd Bergmann44540962009-11-26 06:07:08 +00002235extern int dev_forward_skb(struct net_device *dev,
2236 struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002238extern int netdev_budget;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239
2240/* Called by rtnetlink.c:rtnl_unlock() */
2241extern void netdev_run_todo(void);
2242
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002243/**
2244 * dev_put - release reference to device
2245 * @dev: network device
2246 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07002247 * Release reference to device to allow it to be freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002248 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249static inline void dev_put(struct net_device *dev)
2250{
Christoph Lameter933393f2011-12-22 11:58:51 -06002251 this_cpu_dec(*dev->pcpu_refcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252}
2253
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002254/**
2255 * dev_hold - get reference to device
2256 * @dev: network device
2257 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07002258 * Hold reference to device to keep it from being freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002259 */
Stephen Hemminger15333062006-03-20 22:32:28 -08002260static inline void dev_hold(struct net_device *dev)
2261{
Christoph Lameter933393f2011-12-22 11:58:51 -06002262 this_cpu_inc(*dev->pcpu_refcnt);
Stephen Hemminger15333062006-03-20 22:32:28 -08002263}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264
2265/* Carrier loss detection, dial on demand. The functions netif_carrier_on
2266 * and _off may be called from IRQ context, but it is caller
2267 * who is responsible for serialization of these calls.
Stefan Rompfb00055a2006-03-20 17:09:11 -08002268 *
2269 * The name carrier is inappropriate, these functions should really be
2270 * called netif_lowerlayer_*() because they represent the state of any
2271 * kind of lower layer not just hardware media.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 */
2273
Ben Hutchings8f4cccb2012-08-20 22:16:51 +01002274extern void linkwatch_init_dev(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275extern void linkwatch_fire_event(struct net_device *dev);
Eric Dumazete014deb2009-11-17 05:59:21 +00002276extern void linkwatch_forget_dev(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002278/**
2279 * netif_carrier_ok - test if carrier present
2280 * @dev: network device
2281 *
2282 * Check if carrier is present on device
2283 */
David S. Miller4d295152012-03-07 21:02:35 -05002284static inline bool netif_carrier_ok(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285{
2286 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
2287}
2288
Eric Dumazet9d214932009-05-17 20:55:16 -07002289extern unsigned long dev_trans_start(struct net_device *dev);
2290
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291extern void __netdev_watchdog_up(struct net_device *dev);
2292
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07002293extern void netif_carrier_on(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07002295extern void netif_carrier_off(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002297/**
2298 * netif_dormant_on - mark device as dormant.
2299 * @dev: network device
2300 *
2301 * Mark device as dormant (as per RFC2863).
2302 *
2303 * The dormant state indicates that the relevant interface is not
2304 * actually in a condition to pass packets (i.e., it is not 'up') but is
2305 * in a "pending" state, waiting for some external event. For "on-
2306 * demand" interfaces, this new state identifies the situation where the
2307 * interface is waiting for events to place it in the up state.
2308 *
2309 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08002310static inline void netif_dormant_on(struct net_device *dev)
2311{
2312 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
2313 linkwatch_fire_event(dev);
2314}
2315
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002316/**
2317 * netif_dormant_off - set device as not dormant.
2318 * @dev: network device
2319 *
2320 * Device is not in dormant state.
2321 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08002322static inline void netif_dormant_off(struct net_device *dev)
2323{
2324 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
2325 linkwatch_fire_event(dev);
2326}
2327
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002328/**
2329 * netif_dormant - test if carrier present
2330 * @dev: network device
2331 *
2332 * Check if carrier is present on device
2333 */
David S. Miller4d295152012-03-07 21:02:35 -05002334static inline bool netif_dormant(const struct net_device *dev)
Stefan Rompfb00055a2006-03-20 17:09:11 -08002335{
2336 return test_bit(__LINK_STATE_DORMANT, &dev->state);
2337}
2338
2339
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002340/**
2341 * netif_oper_up - test if device is operational
2342 * @dev: network device
2343 *
2344 * Check if carrier is operational
2345 */
David S. Miller4d295152012-03-07 21:02:35 -05002346static inline bool netif_oper_up(const struct net_device *dev)
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08002347{
Stefan Rompfb00055a2006-03-20 17:09:11 -08002348 return (dev->operstate == IF_OPER_UP ||
2349 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
2350}
2351
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002352/**
2353 * netif_device_present - is device available or removed
2354 * @dev: network device
2355 *
2356 * Check if device has not been removed from system.
2357 */
David S. Miller4d295152012-03-07 21:02:35 -05002358static inline bool netif_device_present(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359{
2360 return test_bit(__LINK_STATE_PRESENT, &dev->state);
2361}
2362
Denis Vlasenko56079432006-03-29 15:57:29 -08002363extern void netif_device_detach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364
Denis Vlasenko56079432006-03-29 15:57:29 -08002365extern void netif_device_attach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366
2367/*
2368 * Network interface message level settings
2369 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370
2371enum {
2372 NETIF_MSG_DRV = 0x0001,
2373 NETIF_MSG_PROBE = 0x0002,
2374 NETIF_MSG_LINK = 0x0004,
2375 NETIF_MSG_TIMER = 0x0008,
2376 NETIF_MSG_IFDOWN = 0x0010,
2377 NETIF_MSG_IFUP = 0x0020,
2378 NETIF_MSG_RX_ERR = 0x0040,
2379 NETIF_MSG_TX_ERR = 0x0080,
2380 NETIF_MSG_TX_QUEUED = 0x0100,
2381 NETIF_MSG_INTR = 0x0200,
2382 NETIF_MSG_TX_DONE = 0x0400,
2383 NETIF_MSG_RX_STATUS = 0x0800,
2384 NETIF_MSG_PKTDATA = 0x1000,
2385 NETIF_MSG_HW = 0x2000,
2386 NETIF_MSG_WOL = 0x4000,
2387};
2388
2389#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
2390#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
2391#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
2392#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
2393#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
2394#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
2395#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
2396#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
2397#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
2398#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
2399#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
2400#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
2401#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
2402#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
2403#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
2404
2405static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
2406{
2407 /* use default */
2408 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
2409 return default_msg_enable_bits;
2410 if (debug_value == 0) /* no output */
2411 return 0;
2412 /* set low N bits */
2413 return (1 << debug_value) - 1;
2414}
2415
David S. Millerc773e842008-07-08 23:13:53 -07002416static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
Herbert Xu932ff272006-06-09 12:20:56 -07002417{
David S. Millerc773e842008-07-08 23:13:53 -07002418 spin_lock(&txq->_xmit_lock);
2419 txq->xmit_lock_owner = cpu;
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002420}
2421
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002422static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
2423{
2424 spin_lock_bh(&txq->_xmit_lock);
2425 txq->xmit_lock_owner = smp_processor_id();
2426}
2427
David S. Miller4d295152012-03-07 21:02:35 -05002428static inline bool __netif_tx_trylock(struct netdev_queue *txq)
David S. Millerc773e842008-07-08 23:13:53 -07002429{
David S. Miller4d295152012-03-07 21:02:35 -05002430 bool ok = spin_trylock(&txq->_xmit_lock);
David S. Millerc773e842008-07-08 23:13:53 -07002431 if (likely(ok))
2432 txq->xmit_lock_owner = smp_processor_id();
2433 return ok;
Herbert Xu932ff272006-06-09 12:20:56 -07002434}
2435
David S. Millerc773e842008-07-08 23:13:53 -07002436static inline void __netif_tx_unlock(struct netdev_queue *txq)
2437{
2438 txq->xmit_lock_owner = -1;
2439 spin_unlock(&txq->_xmit_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07002440}
2441
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002442static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
2443{
2444 txq->xmit_lock_owner = -1;
2445 spin_unlock_bh(&txq->_xmit_lock);
2446}
2447
Eric Dumazet08baf562009-05-25 22:58:01 -07002448static inline void txq_trans_update(struct netdev_queue *txq)
2449{
2450 if (txq->xmit_lock_owner != -1)
2451 txq->trans_start = jiffies;
2452}
2453
David S. Millerc3f26a22008-07-31 16:58:50 -07002454/**
2455 * netif_tx_lock - grab network device transmit lock
2456 * @dev: network device
David S. Millerc3f26a22008-07-31 16:58:50 -07002457 *
2458 * Get network device transmit lock
2459 */
2460static inline void netif_tx_lock(struct net_device *dev)
2461{
2462 unsigned int i;
2463 int cpu;
2464
2465 spin_lock(&dev->tx_global_lock);
2466 cpu = smp_processor_id();
2467 for (i = 0; i < dev->num_tx_queues; i++) {
2468 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2469
2470 /* We are the only thread of execution doing a
2471 * freeze, but we have to grab the _xmit_lock in
2472 * order to synchronize with threads which are in
2473 * the ->hard_start_xmit() handler and already
2474 * checked the frozen bit.
2475 */
2476 __netif_tx_lock(txq, cpu);
2477 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
2478 __netif_tx_unlock(txq);
2479 }
2480}
2481
2482static inline void netif_tx_lock_bh(struct net_device *dev)
2483{
2484 local_bh_disable();
2485 netif_tx_lock(dev);
2486}
2487
Herbert Xu932ff272006-06-09 12:20:56 -07002488static inline void netif_tx_unlock(struct net_device *dev)
2489{
David S. Millere8a04642008-07-17 00:34:19 -07002490 unsigned int i;
David S. Millerc773e842008-07-08 23:13:53 -07002491
David S. Millere8a04642008-07-17 00:34:19 -07002492 for (i = 0; i < dev->num_tx_queues; i++) {
2493 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millere8a04642008-07-17 00:34:19 -07002494
David S. Millerc3f26a22008-07-31 16:58:50 -07002495 /* No need to grab the _xmit_lock here. If the
2496 * queue is not stopped for another reason, we
2497 * force a schedule.
2498 */
2499 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00002500 netif_schedule_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07002501 }
2502 spin_unlock(&dev->tx_global_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07002503}
2504
2505static inline void netif_tx_unlock_bh(struct net_device *dev)
2506{
David S. Millere8a04642008-07-17 00:34:19 -07002507 netif_tx_unlock(dev);
2508 local_bh_enable();
Herbert Xu932ff272006-06-09 12:20:56 -07002509}
2510
David S. Millerc773e842008-07-08 23:13:53 -07002511#define HARD_TX_LOCK(dev, txq, cpu) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002512 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07002513 __netif_tx_lock(txq, cpu); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002514 } \
2515}
2516
David S. Millerc773e842008-07-08 23:13:53 -07002517#define HARD_TX_UNLOCK(dev, txq) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002518 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07002519 __netif_tx_unlock(txq); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002520 } \
2521}
2522
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523static inline void netif_tx_disable(struct net_device *dev)
2524{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002525 unsigned int i;
David S. Millerc3f26a22008-07-31 16:58:50 -07002526 int cpu;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002527
David S. Millerc3f26a22008-07-31 16:58:50 -07002528 local_bh_disable();
2529 cpu = smp_processor_id();
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002530 for (i = 0; i < dev->num_tx_queues; i++) {
2531 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millerc3f26a22008-07-31 16:58:50 -07002532
2533 __netif_tx_lock(txq, cpu);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002534 netif_tx_stop_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07002535 __netif_tx_unlock(txq);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002536 }
David S. Millerc3f26a22008-07-31 16:58:50 -07002537 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538}
2539
David S. Millere308a5d2008-07-15 00:13:44 -07002540static inline void netif_addr_lock(struct net_device *dev)
2541{
2542 spin_lock(&dev->addr_list_lock);
2543}
2544
Jiri Pirko2429f7a2012-01-09 06:36:54 +00002545static inline void netif_addr_lock_nested(struct net_device *dev)
2546{
2547 spin_lock_nested(&dev->addr_list_lock, SINGLE_DEPTH_NESTING);
2548}
2549
David S. Millere308a5d2008-07-15 00:13:44 -07002550static inline void netif_addr_lock_bh(struct net_device *dev)
2551{
2552 spin_lock_bh(&dev->addr_list_lock);
2553}
2554
2555static inline void netif_addr_unlock(struct net_device *dev)
2556{
2557 spin_unlock(&dev->addr_list_lock);
2558}
2559
2560static inline void netif_addr_unlock_bh(struct net_device *dev)
2561{
2562 spin_unlock_bh(&dev->addr_list_lock);
2563}
2564
Jiri Pirkof001fde2009-05-05 02:48:28 +00002565/*
Jiri Pirko31278e72009-06-17 01:12:19 +00002566 * dev_addrs walker. Should be used only for read access. Call with
Jiri Pirkof001fde2009-05-05 02:48:28 +00002567 * rcu_read_lock held.
2568 */
2569#define for_each_dev_addr(dev, ha) \
Jiri Pirko31278e72009-06-17 01:12:19 +00002570 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
Jiri Pirkof001fde2009-05-05 02:48:28 +00002571
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572/* These functions live elsewhere (drivers/net/net_init.c, but related) */
2573
2574extern void ether_setup(struct net_device *dev);
2575
2576/* Support for loadable net-drivers */
Tom Herbert36909ea2011-01-09 19:36:31 +00002577extern struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002578 void (*setup)(struct net_device *),
Tom Herbert36909ea2011-01-09 19:36:31 +00002579 unsigned int txqs, unsigned int rxqs);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002580#define alloc_netdev(sizeof_priv, name, setup) \
Tom Herbert36909ea2011-01-09 19:36:31 +00002581 alloc_netdev_mqs(sizeof_priv, name, setup, 1, 1)
2582
2583#define alloc_netdev_mq(sizeof_priv, name, setup, count) \
2584 alloc_netdev_mqs(sizeof_priv, name, setup, count, count)
2585
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586extern int register_netdev(struct net_device *dev);
2587extern void unregister_netdev(struct net_device *dev);
Jiri Pirkof001fde2009-05-05 02:48:28 +00002588
Jiri Pirko22bedad32010-04-01 21:22:57 +00002589/* General hardware address lists handling functions */
2590extern int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
2591 struct netdev_hw_addr_list *from_list,
2592 int addr_len, unsigned char addr_type);
2593extern void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
2594 struct netdev_hw_addr_list *from_list,
2595 int addr_len, unsigned char addr_type);
2596extern int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
2597 struct netdev_hw_addr_list *from_list,
2598 int addr_len);
2599extern void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
2600 struct netdev_hw_addr_list *from_list,
2601 int addr_len);
2602extern void __hw_addr_flush(struct netdev_hw_addr_list *list);
2603extern void __hw_addr_init(struct netdev_hw_addr_list *list);
2604
Jiri Pirkof001fde2009-05-05 02:48:28 +00002605/* Functions used for device addresses handling */
stephen hemminger6b6e2722012-09-17 10:03:26 +00002606extern int dev_addr_add(struct net_device *dev, const unsigned char *addr,
Jiri Pirkof001fde2009-05-05 02:48:28 +00002607 unsigned char addr_type);
stephen hemminger6b6e2722012-09-17 10:03:26 +00002608extern int dev_addr_del(struct net_device *dev, const unsigned char *addr,
Jiri Pirkof001fde2009-05-05 02:48:28 +00002609 unsigned char addr_type);
2610extern int dev_addr_add_multiple(struct net_device *to_dev,
2611 struct net_device *from_dev,
2612 unsigned char addr_type);
2613extern int dev_addr_del_multiple(struct net_device *to_dev,
2614 struct net_device *from_dev,
2615 unsigned char addr_type);
Jiri Pirkoa748ee22010-04-01 21:22:09 +00002616extern void dev_addr_flush(struct net_device *dev);
2617extern int dev_addr_init(struct net_device *dev);
2618
2619/* Functions used for unicast addresses handling */
stephen hemminger6b6e2722012-09-17 10:03:26 +00002620extern int dev_uc_add(struct net_device *dev, const unsigned char *addr);
2621extern int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
2622extern int dev_uc_del(struct net_device *dev, const unsigned char *addr);
Jiri Pirkoa748ee22010-04-01 21:22:09 +00002623extern int dev_uc_sync(struct net_device *to, struct net_device *from);
2624extern void dev_uc_unsync(struct net_device *to, struct net_device *from);
2625extern void dev_uc_flush(struct net_device *dev);
2626extern void dev_uc_init(struct net_device *dev);
Jiri Pirkof001fde2009-05-05 02:48:28 +00002627
Jiri Pirko22bedad32010-04-01 21:22:57 +00002628/* Functions used for multicast addresses handling */
stephen hemminger6b6e2722012-09-17 10:03:26 +00002629extern int dev_mc_add(struct net_device *dev, const unsigned char *addr);
2630extern int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
2631extern int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
2632extern int dev_mc_del(struct net_device *dev, const unsigned char *addr);
2633extern int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
Jiri Pirko22bedad32010-04-01 21:22:57 +00002634extern int dev_mc_sync(struct net_device *to, struct net_device *from);
2635extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
2636extern void dev_mc_flush(struct net_device *dev);
2637extern void dev_mc_init(struct net_device *dev);
Herbert Xufb286bb2005-11-10 13:01:24 -08002638
2639/* Functions used for secondary unicast and multicast support */
2640extern void dev_set_rx_mode(struct net_device *dev);
2641extern void __dev_set_rx_mode(struct net_device *dev);
Herbert Xufb286bb2005-11-10 13:01:24 -08002642extern int dev_set_promiscuity(struct net_device *dev, int inc);
2643extern int dev_set_allmulti(struct net_device *dev, int inc);
2644extern void netdev_state_change(struct net_device *dev);
Amerigo Wangee89bab2012-08-09 22:14:56 +00002645extern void netdev_notify_peers(struct net_device *dev);
Herbert Xufb286bb2005-11-10 13:01:24 -08002646extern void netdev_features_change(struct net_device *dev);
2647/* Load a device via the kmod */
2648extern void dev_load(struct net *net, const char *name);
Ben Hutchingsd7753512010-07-09 09:12:41 +00002649extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
2650 struct rtnl_link_stats64 *storage);
Eric Dumazet77a1abf2012-03-05 04:50:09 +00002651extern void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
2652 const struct net_device_stats *netdev_stats);
Herbert Xufb286bb2005-11-10 13:01:24 -08002653
2654extern int netdev_max_backlog;
Eric Dumazet3b098e22010-05-15 23:57:10 -07002655extern int netdev_tstamp_prequeue;
Herbert Xufb286bb2005-11-10 13:01:24 -08002656extern int weight_p;
Eric Dumazet0a148422011-04-20 09:27:32 +00002657extern int bpf_jit_enable;
Jiri Pirko9ff162a2013-01-03 22:48:49 +00002658
2659extern bool netdev_has_upper_dev(struct net_device *dev,
2660 struct net_device *upper_dev);
2661extern bool netdev_has_any_upper_dev(struct net_device *dev);
2662extern struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
2663extern struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
2664extern int netdev_upper_dev_link(struct net_device *dev,
2665 struct net_device *upper_dev);
2666extern int netdev_master_upper_dev_link(struct net_device *dev,
2667 struct net_device *upper_dev);
2668extern void netdev_upper_dev_unlink(struct net_device *dev,
2669 struct net_device *upper_dev);
Herbert Xufb286bb2005-11-10 13:01:24 -08002670extern int skb_checksum_help(struct sk_buff *skb);
Cong Wang12b00042013-02-05 16:36:38 +00002671extern struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
2672 netdev_features_t features, bool tx_path);
Pravin B Shelar05e8ef42013-02-14 09:44:55 +00002673extern struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
2674 netdev_features_t features);
Cong Wang12b00042013-02-05 16:36:38 +00002675
2676static inline
2677struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
2678{
2679 return __skb_gso_segment(skb, features, true);
2680}
2681
Herbert Xufb286bb2005-11-10 13:01:24 -08002682#ifdef CONFIG_BUG
2683extern void netdev_rx_csum_fault(struct net_device *dev);
2684#else
2685static inline void netdev_rx_csum_fault(struct net_device *dev)
2686{
2687}
2688#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689/* rx skb timestamps */
2690extern void net_enable_timestamp(void);
2691extern void net_disable_timestamp(void);
2692
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002693#ifdef CONFIG_PROC_FS
Cong Wang900ff8c2013-02-18 19:20:33 +00002694extern int __init dev_proc_init(void);
2695#else
2696#define dev_proc_init() 0
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002697#endif
2698
Jay Vosburghb8a97872008-06-13 18:12:04 -07002699extern int netdev_class_create_file(struct class_attribute *class_attr);
2700extern void netdev_class_remove_file(struct class_attribute *class_attr);
2701
Johannes Berg04600792010-08-05 17:45:15 +02002702extern struct kobj_ns_type_operations net_ns_type_operations;
2703
David S. Miller3019de12011-06-06 16:41:33 -07002704extern const char *netdev_drivername(const struct net_device *dev);
Arjan van de Ven6579e572008-07-21 13:31:48 -07002705
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002706extern void linkwatch_run_queue(void);
2707
Michał Mirosławc8f44af2011-11-15 15:29:55 +00002708static inline netdev_features_t netdev_get_wanted_features(
2709 struct net_device *dev)
Michał Mirosław5455c692011-02-15 16:59:17 +00002710{
2711 return (dev->features & ~dev->hw_features) | dev->wanted_features;
2712}
Michał Mirosławc8f44af2011-11-15 15:29:55 +00002713netdev_features_t netdev_increment_features(netdev_features_t all,
2714 netdev_features_t one, netdev_features_t mask);
Michał Mirosław6cb6a272011-04-02 22:48:47 -07002715int __netdev_update_features(struct net_device *dev);
Michał Mirosław5455c692011-02-15 16:59:17 +00002716void netdev_update_features(struct net_device *dev);
Michał Mirosławafe12cc2011-05-07 03:22:17 +00002717void netdev_change_features(struct net_device *dev);
Herbert Xu7f353bf2007-08-10 15:47:58 -07002718
Patrick Mullaneyfc4a7482009-12-03 15:59:22 -08002719void netif_stacked_transfer_operstate(const struct net_device *rootdev,
2720 struct net_device *dev);
2721
Michał Mirosławc8f44af2011-11-15 15:29:55 +00002722netdev_features_t netif_skb_features(struct sk_buff *skb);
Jesse Gross58e998c2010-10-29 12:14:55 +00002723
David S. Miller4d295152012-03-07 21:02:35 -05002724static inline bool net_gso_ok(netdev_features_t features, int gso_type)
Herbert Xubcd76112006-06-30 13:36:35 -07002725{
Michał Mirosławc8f44af2011-11-15 15:29:55 +00002726 netdev_features_t feature = gso_type << NETIF_F_GSO_SHIFT;
Michał Mirosław0345e182011-11-16 14:05:33 +00002727
2728 /* check flags correspondence */
2729 BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
2730 BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_UFO >> NETIF_F_GSO_SHIFT));
2731 BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
2732 BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
2733 BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
2734 BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
2735
Herbert Xubcd76112006-06-30 13:36:35 -07002736 return (features & feature) == feature;
2737}
2738
David S. Miller4d295152012-03-07 21:02:35 -05002739static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
Herbert Xu576a30e2006-06-27 13:22:38 -07002740{
Herbert Xu278b2512009-06-03 21:20:51 -07002741 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
David S. Miller21dc3302010-08-23 00:13:46 -07002742 (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
Herbert Xu576a30e2006-06-27 13:22:38 -07002743}
2744
David S. Miller4d295152012-03-07 21:02:35 -05002745static inline bool netif_needs_gso(struct sk_buff *skb,
2746 netdev_features_t features)
Herbert Xu79671682006-06-22 02:40:14 -07002747{
Jesse Grossfc741212011-01-09 06:23:32 +00002748 return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
Yi Zoucdbee742012-03-16 23:08:11 +00002749 unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
2750 (skb->ip_summed != CHECKSUM_UNNECESSARY)));
Herbert Xu79671682006-06-22 02:40:14 -07002751}
2752
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07002753static inline void netif_set_gso_max_size(struct net_device *dev,
2754 unsigned int size)
2755{
2756 dev->gso_max_size = size;
2757}
2758
David S. Miller4d295152012-03-07 21:02:35 -05002759static inline bool netif_is_bond_slave(struct net_device *dev)
Jiri Pirko1765a572011-02-12 06:48:36 +00002760{
2761 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
2762}
2763
Ben Greear3bdc0eb2012-02-11 15:39:30 +00002764static inline bool netif_supports_nofcs(struct net_device *dev)
2765{
2766 return dev->priv_flags & IFF_SUPP_NOFCS;
2767}
2768
Eric W. Biederman505d4f72008-11-07 22:54:20 -08002769extern struct pernet_operations __net_initdata loopback_net_ops;
Patrick McHardyb1b67dd2009-04-20 04:49:28 +00002770
Joe Perches571ba422010-02-09 11:49:47 +00002771/* Logging, debugging and troubleshooting/diagnostic helpers. */
2772
2773/* netdev_printk helpers, similar to dev_printk */
2774
2775static inline const char *netdev_name(const struct net_device *dev)
2776{
2777 if (dev->reg_state != NETREG_REGISTERED)
2778 return "(unregistered net_device)";
2779 return dev->name;
2780}
2781
Joe Perchesb9075fa2011-10-31 17:11:33 -07002782extern __printf(3, 4)
2783int netdev_printk(const char *level, const struct net_device *dev,
2784 const char *format, ...);
2785extern __printf(2, 3)
2786int netdev_emerg(const struct net_device *dev, const char *format, ...);
2787extern __printf(2, 3)
2788int netdev_alert(const struct net_device *dev, const char *format, ...);
2789extern __printf(2, 3)
2790int netdev_crit(const struct net_device *dev, const char *format, ...);
2791extern __printf(2, 3)
2792int netdev_err(const struct net_device *dev, const char *format, ...);
2793extern __printf(2, 3)
2794int netdev_warn(const struct net_device *dev, const char *format, ...);
2795extern __printf(2, 3)
2796int netdev_notice(const struct net_device *dev, const char *format, ...);
2797extern __printf(2, 3)
2798int netdev_info(const struct net_device *dev, const char *format, ...);
Joe Perches571ba422010-02-09 11:49:47 +00002799
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +03002800#define MODULE_ALIAS_NETDEV(device) \
2801 MODULE_ALIAS("netdev-" device)
2802
Jim Cromieb558c962011-12-19 17:11:18 -05002803#if defined(CONFIG_DYNAMIC_DEBUG)
Joe Perches571ba422010-02-09 11:49:47 +00002804#define netdev_dbg(__dev, format, args...) \
2805do { \
Jason Baronffa10cb2011-08-11 14:36:48 -04002806 dynamic_netdev_dbg(__dev, format, ##args); \
Joe Perches571ba422010-02-09 11:49:47 +00002807} while (0)
Jim Cromieb558c962011-12-19 17:11:18 -05002808#elif defined(DEBUG)
2809#define netdev_dbg(__dev, format, args...) \
2810 netdev_printk(KERN_DEBUG, __dev, format, ##args)
Joe Perches571ba422010-02-09 11:49:47 +00002811#else
2812#define netdev_dbg(__dev, format, args...) \
2813({ \
2814 if (0) \
2815 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
2816 0; \
2817})
2818#endif
2819
2820#if defined(VERBOSE_DEBUG)
2821#define netdev_vdbg netdev_dbg
2822#else
2823
2824#define netdev_vdbg(dev, format, args...) \
2825({ \
2826 if (0) \
2827 netdev_printk(KERN_DEBUG, dev, format, ##args); \
2828 0; \
2829})
2830#endif
2831
2832/*
2833 * netdev_WARN() acts like dev_printk(), but with the key difference
2834 * of using a WARN/WARN_ON to get the message out, including the
2835 * file/line information and a backtrace.
2836 */
2837#define netdev_WARN(dev, format, args...) \
2838 WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
2839
Joe Perchesb3d95c52010-02-09 11:49:49 +00002840/* netif printk helpers, similar to netdev_printk */
2841
2842#define netif_printk(priv, type, level, dev, fmt, args...) \
2843do { \
2844 if (netif_msg_##type(priv)) \
2845 netdev_printk(level, (dev), fmt, ##args); \
2846} while (0)
2847
Joe Perchesf45f4322010-06-27 01:02:36 +00002848#define netif_level(level, priv, type, dev, fmt, args...) \
2849do { \
2850 if (netif_msg_##type(priv)) \
2851 netdev_##level(dev, fmt, ##args); \
2852} while (0)
2853
Joe Perchesb3d95c52010-02-09 11:49:49 +00002854#define netif_emerg(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002855 netif_level(emerg, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002856#define netif_alert(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002857 netif_level(alert, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002858#define netif_crit(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002859 netif_level(crit, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002860#define netif_err(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002861 netif_level(err, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002862#define netif_warn(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002863 netif_level(warn, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002864#define netif_notice(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002865 netif_level(notice, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002866#define netif_info(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002867 netif_level(info, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002868
Joe Perches0053ea92012-05-30 07:43:34 +00002869#if defined(CONFIG_DYNAMIC_DEBUG)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002870#define netif_dbg(priv, type, netdev, format, args...) \
2871do { \
2872 if (netif_msg_##type(priv)) \
Jason Baronb5fb0a02011-08-11 14:36:53 -04002873 dynamic_netdev_dbg(netdev, format, ##args); \
Joe Perchesb3d95c52010-02-09 11:49:49 +00002874} while (0)
Joe Perches0053ea92012-05-30 07:43:34 +00002875#elif defined(DEBUG)
2876#define netif_dbg(priv, type, dev, format, args...) \
2877 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002878#else
2879#define netif_dbg(priv, type, dev, format, args...) \
2880({ \
2881 if (0) \
2882 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
2883 0; \
2884})
2885#endif
2886
2887#if defined(VERBOSE_DEBUG)
Ben Hutchingsbcfcc452010-07-02 07:08:44 +00002888#define netif_vdbg netif_dbg
Joe Perchesb3d95c52010-02-09 11:49:49 +00002889#else
2890#define netif_vdbg(priv, type, dev, format, args...) \
2891({ \
2892 if (0) \
Ben Hutchingsa4ed89c2010-05-18 06:56:32 +00002893 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
Joe Perchesb3d95c52010-02-09 11:49:49 +00002894 0; \
2895})
2896#endif
Joe Perches571ba422010-02-09 11:49:47 +00002897
Cong Wang900ff8c2013-02-18 19:20:33 +00002898/*
2899 * The list of packet types we will receive (as opposed to discard)
2900 * and the routines to invoke.
2901 *
2902 * Why 16. Because with 16 the only overlap we get on a hash of the
2903 * low nibble of the protocol value is RARP/SNAP/X.25.
2904 *
2905 * NOTE: That is no longer true with the addition of VLAN tags. Not
2906 * sure which should go first, but I bet it won't make much
2907 * difference if we are running VLANs. The good news is that
2908 * this protocol won't be in the list unless compiled in, so
2909 * the average user (w/out VLANs) will not be adversely affected.
2910 * --BLG
2911 *
2912 * 0800 IP
2913 * 8100 802.1Q VLAN
2914 * 0001 802.3
2915 * 0002 AX.25
2916 * 0004 802.2
2917 * 8035 RARP
2918 * 0005 SNAP
2919 * 0805 X.25
2920 * 0806 ARP
2921 * 8137 IPX
2922 * 0009 Localtalk
2923 * 86DD IPv6
2924 */
2925#define PTYPE_HASH_SIZE (16)
2926#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
2927
Jiri Pirko385a1542009-05-27 15:48:07 -07002928#endif /* _LINUX_NETDEVICE_H */