blob: 34f3abc6457a73cd3044a9435962ead55d99d2d4 [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
28#include <linux/if.h>
29#include <linux/if_ether.h>
30#include <linux/if_packet.h>
Williams, Mitch A95c26df2010-02-10 01:43:46 +000031#include <linux/if_link.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33#ifdef __KERNEL__
Mark Grossed771342010-05-06 01:59:26 +020034#include <linux/pm_qos_params.h>
Al Virod7fe0f22006-12-03 23:15:30 -050035#include <linux/timer.h>
Stephen Hemmingerbea33482007-10-03 16:41:36 -070036#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <asm/atomic.h>
38#include <asm/cache.h>
39#include <asm/byteorder.h>
40
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/device.h>
42#include <linux/percpu.h>
David S. Miller4d5b78c2009-05-06 16:52:51 -070043#include <linux/rculist.h>
Chris Leechdb217332006-06-17 21:24:58 -070044#include <linux/dmaengine.h>
Stephen Hemmingerbea33482007-10-03 16:41:36 -070045#include <linux/workqueue.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Patrick McHardyb1b67dd2009-04-20 04:49:28 +000047#include <linux/ethtool.h>
Daniel Lezcanoa050c332007-09-12 14:57:09 +020048#include <net/net_namespace.h>
Lennert Buytenhekcf85d082008-10-07 13:45:02 +000049#include <net/dsa.h>
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -080050#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -080051#include <net/dcbnl.h>
52#endif
Daniel Lezcanoa050c332007-09-12 14:57:09 +020053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054struct vlan_group;
Jeff Moyer115c1d62005-06-22 22:05:31 -070055struct netpoll_info;
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
Stefan Assmannc1f79422010-07-22 02:50:21 +000063/* hardware address assignment types */
64#define NET_ADDR_PERM 0 /* address is permanent (default) */
65#define NET_ADDR_RANDOM 1 /* address is generated randomly */
66#define NET_ADDR_STOLEN 2 /* address is stolen from other device */
67
Jarek Poplawski9a1654b2009-11-15 07:20:12 +000068/* Backlog congestion levels */
69#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
70#define NET_RX_DROP 1 /* packet dropped */
71
Patrick McHardy572a9d72009-11-10 06:14:14 +000072/*
73 * Transmit return codes: transmit return codes originate from three different
74 * namespaces:
75 *
76 * - qdisc return codes
77 * - driver transmit return codes
78 * - errno values
79 *
80 * Drivers are allowed to return any one of those in their hard_start_xmit()
81 * function. Real network devices commonly used with qdiscs should only return
82 * the driver transmit return codes though - when qdiscs are used, the actual
83 * transmission happens asynchronously, so the value is not propagated to
84 * higher layers. Virtual network devices transmit synchronously, in this case
85 * the driver transmit return codes are consumed by dev_queue_xmit(), all
86 * others are propagated to higher layers.
87 */
88
89/* qdisc ->enqueue() return codes. */
90#define NET_XMIT_SUCCESS 0x00
Jarek Poplawski9a1654b2009-11-15 07:20:12 +000091#define NET_XMIT_DROP 0x01 /* skb dropped */
92#define NET_XMIT_CN 0x02 /* congestion notification */
93#define NET_XMIT_POLICED 0x03 /* skb is shot by police */
94#define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -020096/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
97 * indicates that the device will soon be dropping packets, or already drops
98 * some packets of the same priority; prompting us to send less aggressively. */
Patrick McHardy572a9d72009-11-10 06:14:14 +000099#define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
101
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000102/* Driver transmit return codes */
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000103#define NETDEV_TX_MASK 0xf0
Patrick McHardy572a9d72009-11-10 06:14:14 +0000104
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000105enum netdev_tx {
Patrick McHardy572a9d72009-11-10 06:14:14 +0000106 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000107 NETDEV_TX_OK = 0x00, /* driver took care of packet */
108 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
109 NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000110};
111typedef enum netdev_tx netdev_tx_t;
112
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000113/*
114 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
115 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
116 */
117static inline bool dev_xmit_complete(int rc)
118{
119 /*
120 * Positive cases with an skb consumed by a driver:
121 * - successful transmission (rc == NETDEV_TX_OK)
122 * - error while transmitting (rc < 0)
123 * - error while queueing to a different device (rc & NET_XMIT_MASK)
124 */
125 if (likely(rc < NET_XMIT_MASK))
126 return true;
127
128 return false;
129}
130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131#endif
132
133#define MAX_ADDR_LEN 32 /* Largest hardware address length */
134
Vlad Dogaru23b41162011-02-26 22:39:12 +0000135/* Initial net device group. All devices belong to group 0 by default. */
136#define INIT_NETDEV_GROUP 0
137
Adrian Bunkc88e6f52008-06-27 19:54:54 -0700138#ifdef __KERNEL__
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139/*
140 * Compute the worst case header length according to the protocols
141 * used.
142 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800143
John W. Linvillecaf66e52010-02-25 12:02:45 -0500144#if defined(CONFIG_WLAN) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
David S. Miller8388e3d2008-05-12 20:17:33 -0700145# if defined(CONFIG_MAC80211_MESH)
146# define LL_MAX_HEADER 128
147# else
148# define LL_MAX_HEADER 96
149# endif
Adrian Bunkc759a6b2009-04-27 02:36:20 -0700150#elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
David S. Miller8388e3d2008-05-12 20:17:33 -0700151# define LL_MAX_HEADER 48
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152#else
David S. Miller8388e3d2008-05-12 20:17:33 -0700153# define LL_MAX_HEADER 32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154#endif
155
David S. Millere81c73592006-11-28 20:53:39 -0800156#if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
157 !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
158 !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
159 !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160#define MAX_HEADER LL_MAX_HEADER
161#else
162#define MAX_HEADER (LL_MAX_HEADER + 48)
163#endif
164
165/*
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000166 * Old network device statistics. Fields are native words
167 * (unsigned long) so they can be read and written atomically.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800169
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800170struct net_device_stats {
Ben Hutchings3cfde792010-07-09 09:11:52 +0000171 unsigned long rx_packets;
172 unsigned long tx_packets;
173 unsigned long rx_bytes;
174 unsigned long tx_bytes;
175 unsigned long rx_errors;
176 unsigned long tx_errors;
177 unsigned long rx_dropped;
178 unsigned long tx_dropped;
179 unsigned long multicast;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 unsigned long collisions;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 unsigned long rx_length_errors;
Ben Hutchings3cfde792010-07-09 09:11:52 +0000182 unsigned long rx_over_errors;
183 unsigned long rx_crc_errors;
184 unsigned long rx_frame_errors;
185 unsigned long rx_fifo_errors;
186 unsigned long rx_missed_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 unsigned long tx_aborted_errors;
188 unsigned long tx_carrier_errors;
189 unsigned long tx_fifo_errors;
190 unsigned long tx_heartbeat_errors;
191 unsigned long tx_window_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 unsigned long rx_compressed;
193 unsigned long tx_compressed;
194};
195
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000196#endif /* __KERNEL__ */
197
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
199/* Media selection options. */
200enum {
201 IF_PORT_UNKNOWN = 0,
202 IF_PORT_10BASE2,
203 IF_PORT_10BASET,
204 IF_PORT_AUI,
205 IF_PORT_100BASET,
206 IF_PORT_100BASETX,
207 IF_PORT_100BASEFX
208};
209
210#ifdef __KERNEL__
211
212#include <linux/cache.h>
213#include <linux/skbuff.h>
214
215struct neighbour;
216struct neigh_parms;
217struct sk_buff;
218
Jiri Pirkof001fde2009-05-05 02:48:28 +0000219struct netdev_hw_addr {
220 struct list_head list;
221 unsigned char addr[MAX_ADDR_LEN];
222 unsigned char type;
Jiri Pirkoccffad252009-05-22 23:22:17 +0000223#define NETDEV_HW_ADDR_T_LAN 1
224#define NETDEV_HW_ADDR_T_SAN 2
225#define NETDEV_HW_ADDR_T_SLAVE 3
226#define NETDEV_HW_ADDR_T_UNICAST 4
Jiri Pirko22bedad32010-04-01 21:22:57 +0000227#define NETDEV_HW_ADDR_T_MULTICAST 5
Jiri Pirkoccffad252009-05-22 23:22:17 +0000228 bool synced;
Jiri Pirko22bedad32010-04-01 21:22:57 +0000229 bool global_use;
Eric Dumazet8f8f1032010-09-19 11:24:02 -0700230 int refcount;
Jiri Pirkof001fde2009-05-05 02:48:28 +0000231 struct rcu_head rcu_head;
232};
233
Jiri Pirko31278e72009-06-17 01:12:19 +0000234struct netdev_hw_addr_list {
235 struct list_head list;
236 int count;
237};
238
Jiri Pirko22bedad32010-04-01 21:22:57 +0000239#define netdev_hw_addr_list_count(l) ((l)->count)
240#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
241#define netdev_hw_addr_list_for_each(ha, l) \
242 list_for_each_entry(ha, &(l)->list, list)
243
244#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
245#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
Jiri Pirko32e7bfc2010-01-25 13:36:10 -0800246#define netdev_for_each_uc_addr(ha, dev) \
Jiri Pirko22bedad32010-04-01 21:22:57 +0000247 netdev_hw_addr_list_for_each(ha, &(dev)->uc)
Jiri Pirko32e7bfc2010-01-25 13:36:10 -0800248
Jiri Pirko22bedad32010-04-01 21:22:57 +0000249#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
250#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
Pavel Roskin18e225f2010-04-07 16:40:09 -0700251#define netdev_for_each_mc_addr(ha, dev) \
Jiri Pirko22bedad32010-04-01 21:22:57 +0000252 netdev_hw_addr_list_for_each(ha, &(dev)->mc)
Jiri Pirko6683ece2010-02-04 10:22:25 -0800253
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800254struct hh_cache {
David S. Millerf6b72b622011-07-14 07:53:20 -0700255 u16 hh_len;
David S. Miller5c25f682011-07-13 00:51:10 -0700256 u16 __pad;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800257 seqlock_t hh_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
259 /* cached hardware header; allow for machine alignment needs. */
260#define HH_DATA_MOD 16
261#define HH_DATA_OFF(__len) \
Jiri Benc5ba0eac2005-06-02 16:48:05 -0700262 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263#define HH_DATA_ALIGN(__len) \
264 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
265 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
266};
267
268/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
269 * Alternative is:
270 * dev->hard_header_len ? (dev->hard_header_len +
271 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
272 *
273 * We could use other alignment values, but we must maintain the
274 * relationship HH alignment <= LL alignment.
Johannes Bergf5184d22008-05-12 20:48:31 -0700275 *
276 * LL_ALLOCATED_SPACE also takes into account the tailroom the device
277 * may need.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 */
279#define LL_RESERVED_SPACE(dev) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700280 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700282 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
283#define LL_ALLOCATED_SPACE(dev) \
284 ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700286struct header_ops {
287 int (*create) (struct sk_buff *skb, struct net_device *dev,
288 unsigned short type, const void *daddr,
289 const void *saddr, unsigned len);
290 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
291 int (*rebuild)(struct sk_buff *skb);
David S. Millere69dd332011-07-12 23:28:12 -0700292 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700293 void (*cache_update)(struct hh_cache *hh,
294 const struct net_device *dev,
295 const unsigned char *haddr);
296};
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298/* These flag bits are private to the generic network queueing
299 * layer, they may not be explicitly referenced by any other
300 * code.
301 */
302
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800303enum netdev_state_t {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 __LINK_STATE_START,
305 __LINK_STATE_PRESENT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 __LINK_STATE_NOCARRIER,
Stefan Rompfb00055a2006-03-20 17:09:11 -0800307 __LINK_STATE_LINKWATCH_PENDING,
308 __LINK_STATE_DORMANT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309};
310
311
312/*
313 * This structure holds at boot time configured netdevice settings. They
Graf Yangfe2918b2009-02-05 21:26:19 -0800314 * are then used in the device probing.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 */
316struct netdev_boot_setup {
317 char name[IFNAMSIZ];
318 struct ifmap map;
319};
320#define NETDEV_BOOT_SETUP_MAX 8
321
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -0300322extern int __init netdev_boot_setup(char *str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
324/*
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700325 * Structure for NAPI scheduling similar to tasklet but with weighting
326 */
327struct napi_struct {
328 /* The poll_list must only be managed by the entity which
329 * changes the state of the NAPI_STATE_SCHED bit. This means
330 * whoever atomically sets that bit can add this napi_struct
331 * to the per-cpu poll_list, and whoever clears that bit
332 * can remove from the list right before clearing the bit.
333 */
334 struct list_head poll_list;
335
336 unsigned long state;
337 int weight;
338 int (*poll)(struct napi_struct *, int);
339#ifdef CONFIG_NETPOLL
340 spinlock_t poll_lock;
341 int poll_owner;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700342#endif
Herbert Xu4ae55442009-02-08 18:00:36 +0000343
344 unsigned int gro_count;
345
Herbert Xu5d38a072009-01-04 16:13:40 -0800346 struct net_device *dev;
Herbert Xud565b0a2008-12-15 23:38:52 -0800347 struct list_head dev_list;
348 struct sk_buff *gro_list;
Herbert Xu5d38a072009-01-04 16:13:40 -0800349 struct sk_buff *skb;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700350};
351
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800352enum {
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700353 NAPI_STATE_SCHED, /* Poll is scheduled */
David S. Millera0a46192008-01-07 20:35:07 -0800354 NAPI_STATE_DISABLE, /* Disable pending */
Neil Horman7b363e42008-12-09 23:22:26 -0800355 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700356};
357
Ben Hutchings5b252f02009-10-29 07:17:09 +0000358enum gro_result {
Herbert Xud1c76af2009-03-16 10:50:02 -0700359 GRO_MERGED,
360 GRO_MERGED_FREE,
361 GRO_HELD,
362 GRO_NORMAL,
363 GRO_DROP,
364};
Ben Hutchings5b252f02009-10-29 07:17:09 +0000365typedef enum gro_result gro_result_t;
Herbert Xud1c76af2009-03-16 10:50:02 -0700366
Jiri Pirko8a4eb572011-03-12 03:14:39 +0000367/*
368 * enum rx_handler_result - Possible return values for rx_handlers.
369 * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
370 * further.
371 * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
372 * case skb->dev was changed by rx_handler.
373 * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
374 * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called.
375 *
376 * rx_handlers are functions called from inside __netif_receive_skb(), to do
377 * special processing of the skb, prior to delivery to protocol handlers.
378 *
379 * Currently, a net_device can only have a single rx_handler registered. Trying
380 * to register a second rx_handler will return -EBUSY.
381 *
382 * To register a rx_handler on a net_device, use netdev_rx_handler_register().
383 * To unregister a rx_handler on a net_device, use
384 * netdev_rx_handler_unregister().
385 *
386 * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
387 * do with the skb.
388 *
389 * If the rx_handler consumed to skb in some way, it should return
390 * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
391 * the skb to be delivered in some other ways.
392 *
393 * If the rx_handler changed skb->dev, to divert the skb to another
394 * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
395 * new device will be called if it exists.
396 *
397 * If the rx_handler consider the skb should be ignored, it should return
398 * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
399 * are registred on exact device (ptype->dev == skb->dev).
400 *
401 * If the rx_handler didn't changed skb->dev, but want the skb to be normally
402 * delivered, it should return RX_HANDLER_PASS.
403 *
404 * A device without a registered rx_handler will behave as if rx_handler
405 * returned RX_HANDLER_PASS.
406 */
407
408enum rx_handler_result {
409 RX_HANDLER_CONSUMED,
410 RX_HANDLER_ANOTHER,
411 RX_HANDLER_EXACT,
412 RX_HANDLER_PASS,
413};
414typedef enum rx_handler_result rx_handler_result_t;
415typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
Jiri Pirkoab95bfe2010-06-01 21:52:08 +0000416
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800417extern void __napi_schedule(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700418
David S. Millera0a46192008-01-07 20:35:07 -0800419static inline int napi_disable_pending(struct napi_struct *n)
420{
421 return test_bit(NAPI_STATE_DISABLE, &n->state);
422}
423
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700424/**
425 * napi_schedule_prep - check if napi can be scheduled
426 * @n: napi context
427 *
428 * Test if NAPI routine is already running, and if not mark
429 * it as running. This is used as a condition variable
David S. Millera0a46192008-01-07 20:35:07 -0800430 * insure only one NAPI poll instance runs. We also make
431 * sure there is no pending NAPI disable.
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700432 */
433static inline int napi_schedule_prep(struct napi_struct *n)
434{
David S. Millera0a46192008-01-07 20:35:07 -0800435 return !napi_disable_pending(n) &&
436 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700437}
438
439/**
440 * napi_schedule - schedule NAPI poll
441 * @n: napi context
442 *
443 * Schedule NAPI poll routine to be called if it is not already
444 * running.
445 */
446static inline void napi_schedule(struct napi_struct *n)
447{
448 if (napi_schedule_prep(n))
449 __napi_schedule(n);
450}
451
Roland Dreierbfe13f52007-10-09 15:47:37 -0700452/* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
453static inline int napi_reschedule(struct napi_struct *napi)
454{
455 if (napi_schedule_prep(napi)) {
456 __napi_schedule(napi);
457 return 1;
458 }
459 return 0;
460}
461
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700462/**
463 * napi_complete - NAPI processing complete
464 * @n: napi context
465 *
466 * Mark NAPI processing as complete.
467 */
Herbert Xud565b0a2008-12-15 23:38:52 -0800468extern void __napi_complete(struct napi_struct *n);
469extern void napi_complete(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700470
471/**
472 * napi_disable - prevent NAPI from scheduling
473 * @n: napi context
474 *
475 * Stop NAPI from being scheduled on this context.
476 * Waits till any outstanding processing completes.
477 */
478static inline void napi_disable(struct napi_struct *n)
479{
David S. Millera0a46192008-01-07 20:35:07 -0800480 set_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700481 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
Benjamin Herrenschmidt43cc7382007-10-26 04:23:22 -0700482 msleep(1);
David S. Millera0a46192008-01-07 20:35:07 -0800483 clear_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700484}
485
486/**
487 * napi_enable - enable NAPI scheduling
488 * @n: napi context
489 *
490 * Resume NAPI from being scheduled on this context.
491 * Must be paired with napi_disable.
492 */
493static inline void napi_enable(struct napi_struct *n)
494{
495 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
496 smp_mb__before_clear_bit();
497 clear_bit(NAPI_STATE_SCHED, &n->state);
498}
499
Stephen Hemmingerc264c3d2007-10-17 13:26:41 -0700500#ifdef CONFIG_SMP
501/**
502 * napi_synchronize - wait until NAPI is not running
503 * @n: napi context
504 *
505 * Wait until NAPI is done being scheduled on this context.
506 * Waits till any outstanding processing completes but
507 * does not disable future activations.
508 */
509static inline void napi_synchronize(const struct napi_struct *n)
510{
511 while (test_bit(NAPI_STATE_SCHED, &n->state))
512 msleep(1);
513}
514#else
515# define napi_synchronize(n) barrier()
516#endif
517
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800518enum netdev_queue_state_t {
David S. Miller79d16382008-07-08 23:14:46 -0700519 __QUEUE_STATE_XOFF,
David S. Millerc3f26a22008-07-31 16:58:50 -0700520 __QUEUE_STATE_FROZEN,
Eric Dumazet5a0d2262010-11-23 10:42:02 +0000521#define QUEUE_STATE_XOFF_OR_FROZEN ((1 << __QUEUE_STATE_XOFF) | \
522 (1 << __QUEUE_STATE_FROZEN))
David S. Miller79d16382008-07-08 23:14:46 -0700523};
524
David S. Millerbb949fb2008-07-08 16:55:56 -0700525struct netdev_queue {
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700526/*
527 * read mostly part
528 */
David S. Millerbb949fb2008-07-08 16:55:56 -0700529 struct net_device *dev;
David S. Millerb0e1e642008-07-08 17:42:10 -0700530 struct Qdisc *qdisc;
David S. Miller79d16382008-07-08 23:14:46 -0700531 unsigned long state;
David S. Millerb0e1e642008-07-08 17:42:10 -0700532 struct Qdisc *qdisc_sleeping;
Choi, Jong-Hwane3dbc462011-07-20 20:33:03 +0000533#if defined(CONFIG_RPS) || defined(CONFIG_XPS)
Tom Herbert1d24eb42010-11-21 13:17:27 +0000534 struct kobject kobj;
535#endif
Eric Dumazetf2cd2d32010-11-29 08:14:37 +0000536#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
537 int numa_node;
538#endif
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700539/*
540 * write mostly part
541 */
542 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
543 int xmit_lock_owner;
Eric Dumazet9d214932009-05-17 20:55:16 -0700544 /*
545 * please use this field instead of dev->trans_start
546 */
547 unsigned long trans_start;
David S. Millere8a04642008-07-17 00:34:19 -0700548} ____cacheline_aligned_in_smp;
David S. Millerbb949fb2008-07-08 16:55:56 -0700549
Eric Dumazetf2cd2d32010-11-29 08:14:37 +0000550static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
551{
552#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
553 return q->numa_node;
554#else
Changli Gaob236da62010-12-14 03:09:15 +0000555 return NUMA_NO_NODE;
Eric Dumazetf2cd2d32010-11-29 08:14:37 +0000556#endif
557}
558
559static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
560{
561#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
562 q->numa_node = node;
563#endif
564}
565
Eric Dumazetdf334542010-03-24 19:13:54 +0000566#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000567/*
568 * This structure holds an RPS map which can be of variable length. The
569 * map is an array of CPUs.
570 */
571struct rps_map {
572 unsigned int len;
573 struct rcu_head rcu;
574 u16 cpus[0];
575};
576#define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + (_num * sizeof(u16)))
577
Tom Herbertfec5e652010-04-16 16:01:27 -0700578/*
Ben Hutchingsc4454772011-01-19 11:03:53 +0000579 * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
580 * tail pointer for that CPU's input queue at the time of last enqueue, and
581 * a hardware filter index.
Tom Herbertfec5e652010-04-16 16:01:27 -0700582 */
583struct rps_dev_flow {
584 u16 cpu;
Ben Hutchingsc4454772011-01-19 11:03:53 +0000585 u16 filter;
Tom Herbertfec5e652010-04-16 16:01:27 -0700586 unsigned int last_qtail;
587};
Ben Hutchingsc4454772011-01-19 11:03:53 +0000588#define RPS_NO_FILTER 0xffff
Tom Herbertfec5e652010-04-16 16:01:27 -0700589
590/*
591 * The rps_dev_flow_table structure contains a table of flow mappings.
592 */
593struct rps_dev_flow_table {
594 unsigned int mask;
595 struct rcu_head rcu;
596 struct work_struct free_work;
597 struct rps_dev_flow flows[0];
598};
599#define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
600 (_num * sizeof(struct rps_dev_flow)))
601
602/*
603 * The rps_sock_flow_table contains mappings of flows to the last CPU
604 * on which they were processed by the application (set in recvmsg).
605 */
606struct rps_sock_flow_table {
607 unsigned int mask;
608 u16 ents[0];
609};
610#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
611 (_num * sizeof(u16)))
612
613#define RPS_NO_CPU 0xffff
614
615static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
616 u32 hash)
617{
618 if (table && hash) {
619 unsigned int cpu, index = hash & table->mask;
620
621 /* We only give a hint, preemption can change cpu under us */
622 cpu = raw_smp_processor_id();
623
624 if (table->ents[index] != cpu)
625 table->ents[index] = cpu;
626 }
627}
628
629static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
630 u32 hash)
631{
632 if (table && hash)
633 table->ents[hash & table->mask] = RPS_NO_CPU;
634}
635
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000636extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
Tom Herbertfec5e652010-04-16 16:01:27 -0700637
Ben Hutchingsc4454772011-01-19 11:03:53 +0000638#ifdef CONFIG_RFS_ACCEL
639extern bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
640 u32 flow_id, u16 filter_id);
641#endif
642
Tom Herbert0a9627f2010-03-16 08:03:29 +0000643/* This structure contains an instance of an RX queue. */
644struct netdev_rx_queue {
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000645 struct rps_map __rcu *rps_map;
646 struct rps_dev_flow_table __rcu *rps_flow_table;
647 struct kobject kobj;
Tom Herbertfe822242010-11-09 10:47:38 +0000648 struct net_device *dev;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000649} ____cacheline_aligned_in_smp;
Tom Herbertfec5e652010-04-16 16:01:27 -0700650#endif /* CONFIG_RPS */
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800651
Tom Herbertbf264142010-11-26 08:36:09 +0000652#ifdef CONFIG_XPS
653/*
654 * This structure holds an XPS map which can be of variable length. The
655 * map is an array of queues.
656 */
657struct xps_map {
658 unsigned int len;
659 unsigned int alloc_len;
660 struct rcu_head rcu;
661 u16 queues[0];
662};
663#define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + (_num * sizeof(u16)))
664#define XPS_MIN_MAP_ALLOC ((L1_CACHE_BYTES - sizeof(struct xps_map)) \
665 / sizeof(u16))
666
667/*
668 * This structure holds all XPS maps for device. Maps are indexed by CPU.
669 */
670struct xps_dev_maps {
671 struct rcu_head rcu;
Eric Dumazeta4177862010-11-28 21:43:02 +0000672 struct xps_map __rcu *cpu_map[0];
Tom Herbertbf264142010-11-26 08:36:09 +0000673};
674#define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) + \
675 (nr_cpu_ids * sizeof(struct xps_map *)))
676#endif /* CONFIG_XPS */
677
John Fastabend4f57c082011-01-17 08:06:04 +0000678#define TC_MAX_QUEUE 16
679#define TC_BITMASK 15
680/* HW offloaded queuing disciplines txq count and offset maps */
681struct netdev_tc_txq {
682 u16 count;
683 u16 offset;
684};
685
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800686/*
687 * This structure defines the management hooks for network devices.
Stephen Hemminger00829822008-11-20 20:14:53 -0800688 * The following hooks can be defined; unless noted otherwise, they are
689 * optional and can be filled with a null pointer.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800690 *
691 * int (*ndo_init)(struct net_device *dev);
692 * This function is called once when network device is registered.
693 * The network device can use this to any late stage initializaton
694 * or semantic validattion. It can fail with an error code which will
695 * be propogated back to register_netdev
696 *
697 * void (*ndo_uninit)(struct net_device *dev);
698 * This function is called when device is unregistered or when registration
699 * fails. It is not called if init fails.
700 *
701 * int (*ndo_open)(struct net_device *dev);
702 * This function is called when network device transistions to the up
703 * state.
704 *
705 * int (*ndo_stop)(struct net_device *dev);
706 * This function is called when network device transistions to the down
707 * state.
708 *
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000709 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
710 * struct net_device *dev);
Stephen Hemminger00829822008-11-20 20:14:53 -0800711 * Called when a packet needs to be transmitted.
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000712 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
713 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
Stephen Hemminger00829822008-11-20 20:14:53 -0800714 * Required can not be NULL.
715 *
716 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
717 * Called to decide which queue to when device supports multiple
718 * transmit queues.
719 *
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800720 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
721 * This function is called to allow device receiver to make
722 * changes to configuration when multicast or promiscious is enabled.
723 *
724 * void (*ndo_set_rx_mode)(struct net_device *dev);
725 * This function is called device changes address list filtering.
726 *
727 * void (*ndo_set_multicast_list)(struct net_device *dev);
728 * This function is called when the multicast address list changes.
729 *
730 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
731 * This function is called when the Media Access Control address
Mike Rapoport37b607c2009-04-27 05:45:54 -0700732 * needs to be changed. If this interface is not defined, the
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800733 * mac address can not be changed.
734 *
735 * int (*ndo_validate_addr)(struct net_device *dev);
736 * Test if Media Access Control address is valid for the device.
737 *
738 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
739 * Called when a user request an ioctl which can't be handled by
740 * the generic interface code. If not defined ioctl's return
741 * not supported error code.
742 *
743 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
744 * Used to set network devices bus interface parameters. This interface
745 * is retained for legacy reason, new devices should use the bus
746 * interface (PCI) for low level management.
747 *
748 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
749 * Called when a user wants to change the Maximum Transfer Unit
750 * of a device. If not defined, any request to change MTU will
751 * will return an error.
752 *
Stephen Hemminger00829822008-11-20 20:14:53 -0800753 * void (*ndo_tx_timeout)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800754 * Callback uses when the transmitter has not made any progress
755 * for dev->watchdog ticks.
756 *
Ben Hutchings3cfde792010-07-09 09:11:52 +0000757 * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
Eric Dumazet28172732010-07-07 14:58:56 -0700758 * struct rtnl_link_stats64 *storage);
Wolfram Sangd308e382009-10-07 13:53:11 -0700759 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800760 * Called when a user wants to get the network device usage
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000761 * statistics. Drivers must do one of the following:
Ben Hutchings3cfde792010-07-09 09:11:52 +0000762 * 1. Define @ndo_get_stats64 to fill in a zero-initialised
763 * rtnl_link_stats64 structure passed by the caller.
Ben Hutchings82695d92010-06-15 15:08:48 -0700764 * 2. Define @ndo_get_stats to update a net_device_stats structure
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000765 * (which should normally be dev->stats) and return a pointer to
766 * it. The structure may be changed asynchronously only if each
767 * field is written atomically.
768 * 3. Update dev->stats asynchronously and atomically, and define
769 * neither operation.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800770 *
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800771 * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
772 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
773 * this function is called when a VLAN id is registered.
774 *
775 * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
776 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
777 * this function is called when a VLAN id is unregistered.
778 *
779 * void (*ndo_poll_controller)(struct net_device *dev);
Williams, Mitch A95c26df2010-02-10 01:43:46 +0000780 *
781 * SR-IOV management functions.
782 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
783 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
784 * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate);
785 * int (*ndo_get_vf_config)(struct net_device *dev,
786 * int vf, struct ifla_vf_info *ivf);
Scott Feldman57b61082010-05-17 22:49:55 -0700787 * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
788 * struct nlattr *port[]);
789 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
John Fastabend4f57c082011-01-17 08:06:04 +0000790 * int (*ndo_setup_tc)(struct net_device *dev, u8 tc)
791 * Called to setup 'tc' number of traffic classes in the net device. This
792 * is always called from the stack with the rtnl lock held and netif tx
793 * queues stopped. This allows the netdevice to perform queue management
794 * safely.
Ben Hutchingsc4454772011-01-19 11:03:53 +0000795 *
Yi Zoue9bce842011-03-09 08:48:03 +0000796 * Fiber Channel over Ethernet (FCoE) offload functions.
797 * int (*ndo_fcoe_enable)(struct net_device *dev);
798 * Called when the FCoE protocol stack wants to start using LLD for FCoE
799 * so the underlying device can perform whatever needed configuration or
800 * initialization to support acceleration of FCoE traffic.
801 *
802 * int (*ndo_fcoe_disable)(struct net_device *dev);
803 * Called when the FCoE protocol stack wants to stop using LLD for FCoE
804 * so the underlying device can perform whatever needed clean-ups to
805 * stop supporting acceleration of FCoE traffic.
806 *
807 * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
808 * struct scatterlist *sgl, unsigned int sgc);
809 * Called when the FCoE Initiator wants to initialize an I/O that
810 * is a possible candidate for Direct Data Placement (DDP). The LLD can
811 * perform necessary setup and returns 1 to indicate the device is set up
812 * successfully to perform DDP on this I/O, otherwise this returns 0.
813 *
814 * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid);
815 * Called when the FCoE Initiator/Target is done with the DDPed I/O as
816 * indicated by the FC exchange id 'xid', so the underlying device can
817 * clean up and reuse resources for later DDP requests.
818 *
819 * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
820 * struct scatterlist *sgl, unsigned int sgc);
821 * Called when the FCoE Target wants to initialize an I/O that
822 * is a possible candidate for Direct Data Placement (DDP). The LLD can
823 * perform necessary setup and returns 1 to indicate the device is set up
824 * successfully to perform DDP on this I/O, otherwise this returns 0.
825 *
826 * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
827 * Called when the underlying device wants to override default World Wide
828 * Name (WWN) generation mechanism in FCoE protocol stack to pass its own
829 * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
830 * protocol stack to use.
831 *
Ben Hutchingsc4454772011-01-19 11:03:53 +0000832 * RFS acceleration.
833 * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
834 * u16 rxq_index, u32 flow_id);
835 * Set hardware filter for RFS. rxq_index is the target queue index;
836 * flow_id is a flow ID to be passed to rps_may_expire_flow() later.
837 * Return the filter ID on success, or a negative error code.
Jiri Pirkofbaec0e2011-02-13 10:15:37 +0000838 *
839 * Slave management functions (for bridge, bonding, etc). User should
840 * call netdev_set_master() to set dev->master properly.
841 * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
842 * Called to make another netdev an underling.
843 *
844 * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
845 * Called to release previously enslaved netdev.
Michał Mirosław5455c692011-02-15 16:59:17 +0000846 *
847 * Feature/offload setting functions.
848 * u32 (*ndo_fix_features)(struct net_device *dev, u32 features);
849 * Adjusts the requested feature flags according to device-specific
850 * constraints, and returns the resulting flags. Must not modify
851 * the device state.
852 *
853 * int (*ndo_set_features)(struct net_device *dev, u32 features);
854 * Called to update device configuration to new features. Passed
855 * feature set might be less than what was returned by ndo_fix_features()).
856 * Must return >0 or -errno if it changed dev->features itself.
857 *
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800858 */
859struct net_device_ops {
860 int (*ndo_init)(struct net_device *dev);
861 void (*ndo_uninit)(struct net_device *dev);
862 int (*ndo_open)(struct net_device *dev);
863 int (*ndo_stop)(struct net_device *dev);
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000864 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,
Stephen Hemminger00829822008-11-20 20:14:53 -0800865 struct net_device *dev);
866 u16 (*ndo_select_queue)(struct net_device *dev,
867 struct sk_buff *skb);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800868 void (*ndo_change_rx_flags)(struct net_device *dev,
869 int flags);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800870 void (*ndo_set_rx_mode)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800871 void (*ndo_set_multicast_list)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800872 int (*ndo_set_mac_address)(struct net_device *dev,
873 void *addr);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800874 int (*ndo_validate_addr)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800875 int (*ndo_do_ioctl)(struct net_device *dev,
876 struct ifreq *ifr, int cmd);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800877 int (*ndo_set_config)(struct net_device *dev,
878 struct ifmap *map);
Stephen Hemminger00829822008-11-20 20:14:53 -0800879 int (*ndo_change_mtu)(struct net_device *dev,
880 int new_mtu);
881 int (*ndo_neigh_setup)(struct net_device *dev,
882 struct neigh_parms *);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800883 void (*ndo_tx_timeout) (struct net_device *dev);
884
Eric Dumazet28172732010-07-07 14:58:56 -0700885 struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
886 struct rtnl_link_stats64 *storage);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800887 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
888
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800889 void (*ndo_vlan_rx_add_vid)(struct net_device *dev,
890 unsigned short vid);
891 void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
892 unsigned short vid);
893#ifdef CONFIG_NET_POLL_CONTROLLER
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800894 void (*ndo_poll_controller)(struct net_device *dev);
Herbert Xu4247e162010-06-10 16:12:47 +0000895 int (*ndo_netpoll_setup)(struct net_device *dev,
896 struct netpoll_info *info);
WANG Cong0e34e932010-05-06 00:47:21 -0700897 void (*ndo_netpoll_cleanup)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800898#endif
Williams, Mitch A95c26df2010-02-10 01:43:46 +0000899 int (*ndo_set_vf_mac)(struct net_device *dev,
900 int queue, u8 *mac);
901 int (*ndo_set_vf_vlan)(struct net_device *dev,
902 int queue, u16 vlan, u8 qos);
903 int (*ndo_set_vf_tx_rate)(struct net_device *dev,
904 int vf, int rate);
905 int (*ndo_get_vf_config)(struct net_device *dev,
906 int vf,
907 struct ifla_vf_info *ivf);
Scott Feldman57b61082010-05-17 22:49:55 -0700908 int (*ndo_set_vf_port)(struct net_device *dev,
909 int vf,
910 struct nlattr *port[]);
911 int (*ndo_get_vf_port)(struct net_device *dev,
912 int vf, struct sk_buff *skb);
John Fastabend4f57c082011-01-17 08:06:04 +0000913 int (*ndo_setup_tc)(struct net_device *dev, u8 tc);
Yi Zou4d288d52009-02-27 14:06:59 -0800914#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
Yi Zoucb454392009-08-31 12:31:36 +0000915 int (*ndo_fcoe_enable)(struct net_device *dev);
916 int (*ndo_fcoe_disable)(struct net_device *dev);
Yi Zou4d288d52009-02-27 14:06:59 -0800917 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
918 u16 xid,
919 struct scatterlist *sgl,
920 unsigned int sgc);
921 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
922 u16 xid);
Yi Zou6247e082011-02-01 07:22:06 +0000923 int (*ndo_fcoe_ddp_target)(struct net_device *dev,
924 u16 xid,
925 struct scatterlist *sgl,
926 unsigned int sgc);
Yi Zoudf5c7942009-10-28 18:24:35 +0000927#define NETDEV_FCOE_WWNN 0
928#define NETDEV_FCOE_WWPN 1
929 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
930 u64 *wwn, int type);
Yi Zou4d288d52009-02-27 14:06:59 -0800931#endif
Ben Hutchingsc4454772011-01-19 11:03:53 +0000932#ifdef CONFIG_RFS_ACCEL
933 int (*ndo_rx_flow_steer)(struct net_device *dev,
934 const struct sk_buff *skb,
935 u16 rxq_index,
936 u32 flow_id);
937#endif
Jiri Pirkofbaec0e2011-02-13 10:15:37 +0000938 int (*ndo_add_slave)(struct net_device *dev,
939 struct net_device *slave_dev);
940 int (*ndo_del_slave)(struct net_device *dev,
941 struct net_device *slave_dev);
Michał Mirosław5455c692011-02-15 16:59:17 +0000942 u32 (*ndo_fix_features)(struct net_device *dev,
943 u32 features);
944 int (*ndo_set_features)(struct net_device *dev,
945 u32 features);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800946};
947
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700948/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 * The DEVICE structure.
950 * Actually, this whole structure is a big mistake. It mixes I/O
951 * data with strictly "high-level" data, and it has to know about
952 * almost every data structure used in the INET module.
953 *
954 * FIXME: cleanup struct net_device such that network protocol info
955 * moves out.
956 */
957
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800958struct net_device {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960 /*
961 * This is the first field of the "visible" part of this structure
962 * (i.e. as seen by users in the "Space.c" file). It is the name
Justin P. Mattock724df612010-05-26 09:22:40 -0700963 * of the interface.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 */
965 char name[IFNAMSIZ];
Mark Grossed771342010-05-06 01:59:26 +0200966
James Bottomley82f68252010-07-05 22:53:06 +0200967 struct pm_qos_request_list pm_qos_req;
Mark Grossed771342010-05-06 01:59:26 +0200968
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700969 /* device name hash chain */
970 struct hlist_node name_hlist;
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700971 /* snmp alias */
972 char *ifalias;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
974 /*
975 * I/O specific fields
976 * FIXME: Merge these and struct ifmap into one
977 */
978 unsigned long mem_end; /* shared mem end */
979 unsigned long mem_start; /* shared mem start */
980 unsigned long base_addr; /* device I/O address */
981 unsigned int irq; /* device IRQ number */
982
983 /*
984 * Some hardware also needs these fields, but they are not
985 * part of the usual set specified in Space.c.
986 */
987
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 unsigned long state;
989
Pavel Emelianov7562f872007-05-03 15:13:45 -0700990 struct list_head dev_list;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700991 struct list_head napi_list;
Eric Dumazet44a08732009-10-27 07:03:04 +0000992 struct list_head unreg_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
Michał Mirosław5455c692011-02-15 16:59:17 +0000994 /* currently active device features */
Michał Mirosław04ed3e72011-01-24 15:32:47 -0800995 u32 features;
Michał Mirosław5455c692011-02-15 16:59:17 +0000996 /* user-changeable features */
997 u32 hw_features;
998 /* user-requested features */
999 u32 wanted_features;
Michał Mirosław1aac6262011-04-12 04:07:39 +00001000 /* mask of features inheritable by VLAN devices */
Michał Mirosław04ed3e72011-01-24 15:32:47 -08001001 u32 vlan_features;
1002
Michał Mirosław5455c692011-02-15 16:59:17 +00001003 /* Net device feature bits; if you change something,
1004 * also update netdev_features_strings[] in ethtool.c */
1005
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001006#define NETIF_F_SG 1 /* Scatter/gather IO. */
Stephen Hemmingerd212f872007-06-27 00:47:37 -07001007#define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001008#define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
1009#define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
Stephen Hemmingerd212f872007-06-27 00:47:37 -07001010#define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001011#define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
1012#define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
1013#define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
1014#define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
1015#define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
1016#define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
Herbert Xu37c31852006-06-22 03:07:29 -07001017#define NETIF_F_GSO 2048 /* Enable software GSO. */
Christian Borntraegere24eb522007-09-25 19:42:02 -07001018#define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */
1019 /* do not use LLTX in new drivers */
Eric W. Biedermance286d32007-09-12 13:53:49 +02001020#define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */
Herbert Xud565b0a2008-12-15 23:38:52 -08001021#define NETIF_F_GRO 16384 /* Generic receive offload */
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001022#define NETIF_F_LRO 32768 /* large receive offload */
Herbert Xu79671682006-06-22 02:40:14 -07001023
Jesse Brandeburg8dc92f72009-04-27 22:35:52 +00001024/* the GSO_MASK reserves bits 16 through 23 */
Chris Leech01d5b2f2009-02-27 14:06:49 -08001025#define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */
Jesse Brandeburg8dc92f72009-04-27 22:35:52 +00001026#define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */
Yi Zoubb2af4f2009-08-14 12:41:57 +00001027#define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001028#define NETIF_F_NTUPLE (1 << 27) /* N-tuple filters supported */
stephen hemmingerb00fabb2010-03-29 14:47:27 +00001029#define NETIF_F_RXHASH (1 << 28) /* Receive hashing offload */
Michał Mirosławe83d3602011-02-15 16:59:18 +00001030#define NETIF_F_RXCSUM (1 << 29) /* Receive checksumming offload */
Tom Herbertc6e1a0d2011-04-04 22:30:30 -07001031#define NETIF_F_NOCACHE_COPY (1 << 30) /* Use no-cache copyfromuser */
Mahesh Bandewareed2a122011-05-04 15:30:11 +00001032#define NETIF_F_LOOPBACK (1 << 31) /* Enable loopback */
Chris Leech01d5b2f2009-02-27 14:06:49 -08001033
Herbert Xu79671682006-06-22 02:40:14 -07001034 /* Segmentation offload features */
Patrick McHardy289c79a2008-05-23 00:22:04 -07001035#define NETIF_F_GSO_SHIFT 16
Chris Leech43eb99c2009-02-27 14:06:43 -08001036#define NETIF_F_GSO_MASK 0x00ff0000
Herbert Xu79671682006-06-22 02:40:14 -07001037#define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
Herbert Xuf83ef8c2006-06-30 13:37:03 -07001038#define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
Herbert Xu576a30e2006-06-27 13:22:38 -07001039#define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
Herbert Xuf83ef8c2006-06-30 13:37:03 -07001040#define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
1041#define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
Chris Leech01d5b2f2009-02-27 14:06:49 -08001042#define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001043
Michał Mirosław5455c692011-02-15 16:59:17 +00001044 /* Features valid for ethtool to change */
1045 /* = all defined minus driver/device-class-related */
Michał Mirosławfa2bd7f2011-04-22 06:31:16 +00001046#define NETIF_F_NEVER_CHANGE (NETIF_F_VLAN_CHALLENGED | \
Michał Mirosław5455c692011-02-15 16:59:17 +00001047 NETIF_F_LLTX | NETIF_F_NETNS_LOCAL)
Mahesh Bandewareed2a122011-05-04 15:30:11 +00001048#define NETIF_F_ETHTOOL_BITS (0xff3fffff & ~NETIF_F_NEVER_CHANGE)
Michał Mirosław5455c692011-02-15 16:59:17 +00001049
Herbert Xu78eb8872006-08-17 18:22:32 -07001050 /* List of features with software fallbacks. */
Herbert Xud29c0c52010-06-14 20:21:04 +00001051#define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | \
1052 NETIF_F_TSO6 | NETIF_F_UFO)
Herbert Xu78eb8872006-08-17 18:22:32 -07001053
Stephen Hemmingerd212f872007-06-27 00:47:37 -07001054
Herbert Xu8648b302006-06-17 22:06:05 -07001055#define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
Stephen Hemmingerd212f872007-06-27 00:47:37 -07001056#define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
1057#define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
1058#define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
Herbert Xu8648b302006-06-17 22:06:05 -07001059
Michał Mirosław0a417702011-02-15 16:59:17 +00001060#define NETIF_F_ALL_TSO (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
1061
Yi Zou7f2670512011-05-09 11:53:27 +00001062#define NETIF_F_ALL_FCOE (NETIF_F_FCOE_CRC | NETIF_F_FCOE_MTU | \
1063 NETIF_F_FSO)
1064
Herbert Xub63365a2008-10-23 01:11:29 -07001065 /*
1066 * If one device supports one of these features, then enable them
1067 * for all in netdev_increment_features.
1068 */
1069#define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001070 NETIF_F_SG | NETIF_F_HIGHDMA | \
Michał Mirosław1742f182011-04-22 06:31:16 +00001071 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED)
1072 /*
1073 * If one device doesn't support one of these features, then disable it
1074 * for all in netdev_increment_features.
1075 */
1076#define NETIF_F_ALL_FOR_ALL (NETIF_F_NOCACHE_COPY | NETIF_F_FSO)
Herbert Xub63365a2008-10-23 01:11:29 -07001077
Michał Mirosław212b5732011-02-15 16:59:16 +00001078 /* changeable features with no special hardware requirements */
1079#define NETIF_F_SOFT_FEATURES (NETIF_F_GSO | NETIF_F_GRO)
1080
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 /* Interface index. Unique device identifier */
1082 int ifindex;
1083 int iflink;
1084
Rusty Russellc45d2862007-03-28 14:29:08 -07001085 struct net_device_stats stats;
Eric Dumazetcaf586e2010-09-30 21:06:55 +00001086 atomic_long_t rx_dropped; /* dropped packets by core network
1087 * Do not use this in drivers.
1088 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
Johannes Bergb86e0282007-04-26 20:48:23 -07001090#ifdef CONFIG_WIRELESS_EXT
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 /* List of functions to handle Wireless Extensions (instead of ioctl).
1092 * See <net/iw_handler.h> for details. Jean II */
1093 const struct iw_handler_def * wireless_handlers;
1094 /* Instance data managed by the core of Wireless Extensions. */
1095 struct iw_public_data * wireless_data;
Johannes Bergb86e0282007-04-26 20:48:23 -07001096#endif
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001097 /* Management operations */
1098 const struct net_device_ops *netdev_ops;
Stephen Hemminger76fd8592006-09-08 11:16:13 -07001099 const struct ethtool_ops *ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001101 /* Hardware header description */
1102 const struct header_ops *header_ops;
1103
Stefan Rompfb00055a2006-03-20 17:09:11 -08001104 unsigned int flags; /* interface flags (a la BSD) */
Joe Perchesbdc220d2011-05-09 17:42:46 +00001105 unsigned int priv_flags; /* Like 'flags' but invisible to userspace. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 unsigned short gflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 unsigned short padded; /* How much padding added by alloc_netdev() */
1108
Stefan Rompfb00055a2006-03-20 17:09:11 -08001109 unsigned char operstate; /* RFC2863 operstate */
1110 unsigned char link_mode; /* mapping policy to operstate */
1111
Joe Perchesbdc220d2011-05-09 17:42:46 +00001112 unsigned char if_port; /* Selectable AUI, TP,..*/
1113 unsigned char dma; /* DMA channel */
1114
David S. Millercd7b5392010-05-02 22:27:59 -07001115 unsigned int mtu; /* interface MTU value */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 unsigned short type; /* interface hardware type */
1117 unsigned short hard_header_len; /* hardware hdr length */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118
Johannes Bergf5184d22008-05-12 20:48:31 -07001119 /* extra head- and tailroom the hardware may need, but not in all cases
1120 * can this be guaranteed, especially tailroom. Some cases also use
1121 * LL_MAX_HEADER instead to allocate the skb.
1122 */
1123 unsigned short needed_headroom;
1124 unsigned short needed_tailroom;
1125
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 /* Interface address info. */
Jon Wetzela6f9a702005-08-20 17:15:54 -07001127 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
Stefan Assmannc1f79422010-07-22 02:50:21 +00001128 unsigned char addr_assign_type; /* hw address assignment type */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 unsigned char addr_len; /* hardware address length */
1130 unsigned short dev_id; /* for shared network cards */
1131
Jiri Pirkoccffad252009-05-22 23:22:17 +00001132 spinlock_t addr_list_lock;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001133 struct netdev_hw_addr_list uc; /* Unicast mac addresses */
1134 struct netdev_hw_addr_list mc; /* Multicast mac addresses */
1135 int uc_promisc;
Wang Chen9d45abe2008-06-17 21:12:48 -07001136 unsigned int promiscuity;
1137 unsigned int allmulti;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
1140 /* Protocol specific pointers */
Jesse Gross65ac6a52010-10-20 13:56:05 +00001141
1142#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
Eric Dumazetb616b092010-10-24 21:31:58 +00001143 struct vlan_group __rcu *vlgrp; /* VLAN group */
Jesse Gross65ac6a52010-10-20 13:56:05 +00001144#endif
Lennert Buytenhek91da11f2008-10-07 13:44:02 +00001145#ifdef CONFIG_NET_DSA
1146 void *dsa_ptr; /* dsa specific data */
1147#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 void *atalk_ptr; /* AppleTalk link */
Eric Dumazet95ae6b22010-09-15 04:04:31 +00001149 struct in_device __rcu *ip_ptr; /* IPv4 specific data */
Eric Dumazetfc766e4c2010-10-29 03:09:24 +00001150 struct dn_dev __rcu *dn_ptr; /* DECnet specific data */
Eric Dumazet198caec2010-10-24 21:32:05 +00001151 struct inet6_dev __rcu *ip6_ptr; /* IPv6 specific data */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 void *ec_ptr; /* Econet specific data */
1153 void *ax25_ptr; /* AX.25 specific data */
Johannes Berg704232c2007-04-23 12:20:05 -07001154 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
1155 assign before registering */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001157/*
Eric Dumazetcd135392010-09-16 02:58:13 +00001158 * Cache lines mostly used on receive path (including eth_type_trans())
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001159 */
Eric Dumazet4dc89132010-08-31 07:40:16 +00001160 unsigned long last_rx; /* Time of last Rx
1161 * This should not be set in
1162 * drivers, unless really needed,
1163 * because network stack (bonding)
1164 * use it if/when necessary, to
1165 * avoid dirtying this cache line.
1166 */
1167
Eric Dumazetcd135392010-09-16 02:58:13 +00001168 struct net_device *master; /* Pointer to master device of a group,
1169 * which this device is member of.
1170 */
1171
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001172 /* Interface address info used in eth_type_trans() */
Jiri Pirkof001fde2009-05-05 02:48:28 +00001173 unsigned char *dev_addr; /* hw address, (before bcast
1174 because most packets are
1175 unicast) */
1176
Jiri Pirko31278e72009-06-17 01:12:19 +00001177 struct netdev_hw_addr_list dev_addrs; /* list of device
1178 hw addresses */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001180 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
1181
Choi, Jong-Hwane3dbc462011-07-20 20:33:03 +00001182#if defined(CONFIG_RPS) || defined(CONFIG_XPS)
Tom Herbert0a9627f2010-03-16 08:03:29 +00001183 struct kset *queues_kset;
1184
1185 struct netdev_rx_queue *_rx;
1186
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001187 /* Number of RX queues allocated at register_netdev() time */
Tom Herbert0a9627f2010-03-16 08:03:29 +00001188 unsigned int num_rx_queues;
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001189
1190 /* Number of RX queues currently active in device */
1191 unsigned int real_num_rx_queues;
Ben Hutchingsc4454772011-01-19 11:03:53 +00001192
1193#ifdef CONFIG_RFS_ACCEL
1194 /* CPU reverse-mapping for RX completion interrupts, indexed
1195 * by RX queue number. Assigned by driver. This must only be
1196 * set if the ndo_rx_flow_steer operation is defined. */
1197 struct cpu_rmap *rx_cpu_rmap;
1198#endif
Eric Dumazetdf334542010-03-24 19:13:54 +00001199#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +00001200
stephen hemminger61391cd2010-11-15 06:38:12 +00001201 rx_handler_func_t __rcu *rx_handler;
1202 void __rcu *rx_handler_data;
David S. Millere8a04642008-07-17 00:34:19 -07001203
Eric Dumazet24824a02010-10-02 06:11:55 +00001204 struct netdev_queue __rcu *ingress_queue;
Eric Dumazetcd135392010-09-16 02:58:13 +00001205
1206/*
1207 * Cache lines mostly used on transmit path
1208 */
David S. Millere8a04642008-07-17 00:34:19 -07001209 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001210
1211 /* Number of TX queues allocated at alloc_netdev_mq() time */
David S. Millere8a04642008-07-17 00:34:19 -07001212 unsigned int num_tx_queues;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001213
1214 /* Number of TX queues currently active in device */
1215 unsigned int real_num_tx_queues;
1216
Patrick McHardyaf356af2009-09-04 06:41:18 +00001217 /* root qdisc from userspace point of view */
1218 struct Qdisc *qdisc;
1219
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 unsigned long tx_queue_len; /* Max frames per queue allowed */
David S. Millerc3f26a22008-07-31 16:58:50 -07001221 spinlock_t tx_global_lock;
Eric Dumazetcd135392010-09-16 02:58:13 +00001222
Tom Herbertbf264142010-11-26 08:36:09 +00001223#ifdef CONFIG_XPS
Eric Dumazeta4177862010-11-28 21:43:02 +00001224 struct xps_dev_maps __rcu *xps_maps;
Tom Herbertbf264142010-11-26 08:36:09 +00001225#endif
Tom Herbert1d24eb42010-11-21 13:17:27 +00001226
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001227 /* These may be needed for future network-power-down code. */
Eric Dumazet9d214932009-05-17 20:55:16 -07001228
1229 /*
1230 * trans_start here is expensive for high speed devices on SMP,
1231 * please use netdev_queue->trans_start instead.
1232 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001233 unsigned long trans_start; /* Time (in jiffies) of last Tx */
1234
1235 int watchdog_timeo; /* used by dev_watchdog() */
1236 struct timer_list watchdog_timer;
1237
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 /* Number of references to this device */
Eric Dumazet29b44332010-10-11 10:22:12 +00001239 int __percpu *pcpu_refcnt;
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001240
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 /* delayed register/unregister */
1242 struct list_head todo_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 /* device index hash chain */
1244 struct hlist_node index_hlist;
1245
Eric Dumazete014deb2009-11-17 05:59:21 +00001246 struct list_head link_watch_list;
Herbert Xu572a1032007-05-08 18:34:17 -07001247
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 /* register/unregister state machine */
1249 enum { NETREG_UNINITIALIZED=0,
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07001250 NETREG_REGISTERED, /* completed register_netdevice */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 NETREG_UNREGISTERING, /* called unregister_netdevice */
1252 NETREG_UNREGISTERED, /* completed unregister todo */
1253 NETREG_RELEASED, /* called free_netdev */
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001254 NETREG_DUMMY, /* dummy device for NAPI poll */
Eric Dumazet449f4542011-05-19 12:24:16 +00001255 } reg_state:8;
1256
1257 bool dismantle; /* device is going do be freed */
Patrick McHardya2835762010-02-26 06:34:51 +00001258
1259 enum {
1260 RTNL_LINK_INITIALIZED,
1261 RTNL_LINK_INITIALIZING,
1262 } rtnl_link_state:16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001264 /* Called from unregister, can be used to call free_netdev */
1265 void (*destructor)(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267#ifdef CONFIG_NETPOLL
Jeff Moyer115c1d62005-06-22 22:05:31 -07001268 struct netpoll_info *npinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269#endif
David S. Millereae792b2008-07-15 03:03:33 -07001270
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001271#ifdef CONFIG_NET_NS
Eric W. Biederman4a1c5372007-09-12 11:56:32 +02001272 /* Network namespace this network device is inside */
1273 struct net *nd_net;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001274#endif
Eric W. Biederman4a1c5372007-09-12 11:56:32 +02001275
David S. Miller49517042008-05-12 03:29:11 -07001276 /* mid-layer private */
Eric Dumazeta7855c72010-09-23 23:51:51 +00001277 union {
1278 void *ml_priv;
1279 struct pcpu_lstats __percpu *lstats; /* loopback stats */
Eric Dumazet290b8952010-09-27 00:33:35 +00001280 struct pcpu_tstats __percpu *tstats; /* tunnel stats */
Eric Dumazet6d81f412010-09-27 20:50:33 +00001281 struct pcpu_dstats __percpu *dstats; /* dummy stats */
Eric Dumazeta7855c72010-09-23 23:51:51 +00001282 };
Patrick McHardyeca9eba2008-07-05 21:26:13 -07001283 /* GARP */
Eric Dumazet3cc77ec2010-10-24 21:32:36 +00001284 struct garp_port __rcu *garp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 /* class/net/name entry */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001287 struct device dev;
Eric W. Biederman0c509a62009-10-29 14:18:21 +00001288 /* space for optional device, statistics, and wireless sysfs groups */
1289 const struct attribute_group *sysfs_groups[4];
Patrick McHardy38f7b872007-06-13 12:03:51 -07001290
1291 /* rtnetlink link ops */
1292 const struct rtnl_link_ops *rtnl_link_ops;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001293
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001294 /* for setting kernel sock attribute on TCP connection setup */
1295#define GSO_MAX_SIZE 65536
1296 unsigned int gso_max_size;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001297
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -08001298#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -08001299 /* Data Center Bridging netlink ops */
Stephen Hemminger32953542009-10-05 06:01:03 +00001300 const struct dcbnl_rtnl_ops *dcbnl_ops;
Alexander Duyck2f90b862008-11-20 20:52:10 -08001301#endif
John Fastabend4f57c082011-01-17 08:06:04 +00001302 u8 num_tc;
1303 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
1304 u8 prio_tc_map[TC_BITMASK + 1];
Alexander Duyck2f90b862008-11-20 20:52:10 -08001305
Yi Zou4d288d52009-02-27 14:06:59 -08001306#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
1307 /* max exchange id for FCoE LRO by ddp */
1308 unsigned int fcoe_ddp_xid;
1309#endif
Richard Cochranc1f19b52010-07-17 08:49:36 +00001310 /* phy device may attach itself for hardware timestamping */
1311 struct phy_device *phydev;
Vlad Dogarucbda10f2011-01-13 23:38:30 +00001312
1313 /* group the device belongs to */
1314 int group;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315};
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001316#define to_net_dev(d) container_of(d, struct net_device, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
1318#define NETDEV_ALIGN 32
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
David S. Millere8a04642008-07-17 00:34:19 -07001320static inline
John Fastabend4f57c082011-01-17 08:06:04 +00001321int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
1322{
1323 return dev->prio_tc_map[prio & TC_BITMASK];
1324}
1325
1326static inline
1327int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
1328{
1329 if (tc >= dev->num_tc)
1330 return -EINVAL;
1331
1332 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
1333 return 0;
1334}
1335
1336static inline
1337void netdev_reset_tc(struct net_device *dev)
1338{
1339 dev->num_tc = 0;
1340 memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
1341 memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
1342}
1343
1344static inline
1345int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
1346{
1347 if (tc >= dev->num_tc)
1348 return -EINVAL;
1349
1350 dev->tc_to_txq[tc].count = count;
1351 dev->tc_to_txq[tc].offset = offset;
1352 return 0;
1353}
1354
1355static inline
1356int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
1357{
1358 if (num_tc > TC_MAX_QUEUE)
1359 return -EINVAL;
1360
1361 dev->num_tc = num_tc;
1362 return 0;
1363}
1364
1365static inline
1366int netdev_get_num_tc(struct net_device *dev)
1367{
1368 return dev->num_tc;
1369}
1370
1371static inline
David S. Millere8a04642008-07-17 00:34:19 -07001372struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
1373 unsigned int index)
1374{
1375 return &dev->_tx[index];
1376}
1377
1378static inline void netdev_for_each_tx_queue(struct net_device *dev,
1379 void (*f)(struct net_device *,
1380 struct netdev_queue *,
1381 void *),
1382 void *arg)
1383{
1384 unsigned int i;
1385
1386 for (i = 0; i < dev->num_tx_queues; i++)
1387 f(dev, &dev->_tx[i], arg);
1388}
1389
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001390/*
1391 * Net namespace inlines
1392 */
1393static inline
1394struct net *dev_net(const struct net_device *dev)
1395{
Eric Dumazetc2d9ba92010-06-01 06:51:19 +00001396 return read_pnet(&dev->nd_net);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001397}
1398
1399static inline
Denis V. Lunevf5aa23f2008-03-26 00:48:17 -07001400void dev_net_set(struct net_device *dev, struct net *net)
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001401{
1402#ifdef CONFIG_NET_NS
Denis V. Lunevf3005d72008-04-16 02:02:18 -07001403 release_net(dev->nd_net);
1404 dev->nd_net = hold_net(net);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001405#endif
1406}
1407
Lennert Buytenhekcf85d082008-10-07 13:45:02 +00001408static inline bool netdev_uses_dsa_tags(struct net_device *dev)
1409{
1410#ifdef CONFIG_NET_DSA_TAG_DSA
1411 if (dev->dsa_ptr != NULL)
1412 return dsa_uses_dsa_tags(dev->dsa_ptr);
1413#endif
1414
1415 return 0;
1416}
1417
Arnd Bergmann8a83a002010-01-30 12:23:03 +00001418#ifndef CONFIG_NET_NS
1419static inline void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
1420{
1421 skb->dev = dev;
1422}
1423#else /* CONFIG_NET_NS */
1424void skb_set_dev(struct sk_buff *skb, struct net_device *dev);
1425#endif
1426
Lennert Buytenhek396138f2008-10-07 13:46:07 +00001427static inline bool netdev_uses_trailer_tags(struct net_device *dev)
1428{
1429#ifdef CONFIG_NET_DSA_TAG_TRAILER
1430 if (dev->dsa_ptr != NULL)
1431 return dsa_uses_trailer_tags(dev->dsa_ptr);
1432#endif
1433
1434 return 0;
1435}
1436
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001437/**
1438 * netdev_priv - access network device private data
1439 * @dev: network device
1440 *
1441 * Get network device private data
1442 */
Patrick McHardy6472ce62007-06-13 12:03:21 -07001443static inline void *netdev_priv(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444{
Eric Dumazet1ce8e7b2009-05-27 04:42:37 +00001445 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446}
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448/* Set the sysfs physical device reference for the network logical device
1449 * if set prior to registration will cause a symlink during initialization.
1450 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001451#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452
Marcel Holtmann384912e2009-08-31 21:08:19 +00001453/* Set the sysfs device type for the network logical device to allow
1454 * fin grained indentification of different network device types. For
1455 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
1456 */
1457#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
1458
Stephen Hemminger3b582cc2007-11-01 02:21:47 -07001459/**
1460 * netif_napi_add - initialize a napi context
1461 * @dev: network device
1462 * @napi: napi context
1463 * @poll: polling function
1464 * @weight: default weight
1465 *
1466 * netif_napi_add() must be used to initialize a napi context prior to calling
1467 * *any* of the other napi related functions.
1468 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001469void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
1470 int (*poll)(struct napi_struct *, int), int weight);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001471
Alexander Duyckd8156532008-07-08 15:13:05 -07001472/**
1473 * netif_napi_del - remove a napi context
1474 * @napi: napi context
1475 *
1476 * netif_napi_del() removes a napi context from the network device napi list
1477 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001478void netif_napi_del(struct napi_struct *napi);
1479
1480struct napi_gro_cb {
Herbert Xu78a478d2009-05-26 18:50:21 +00001481 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
1482 void *frag0;
1483
Herbert Xu74895942009-05-26 18:50:27 +00001484 /* Length of frag0. */
1485 unsigned int frag0_len;
1486
Herbert Xu86911732009-01-29 14:19:50 +00001487 /* This indicates where we are processing relative to skb->data. */
1488 int data_offset;
1489
Herbert Xud565b0a2008-12-15 23:38:52 -08001490 /* This is non-zero if the packet may be of the same flow. */
1491 int same_flow;
1492
1493 /* This is non-zero if the packet cannot be merged with the new skb. */
1494 int flush;
1495
1496 /* Number of segments aggregated. */
1497 int count;
Herbert Xu5d38a072009-01-04 16:13:40 -08001498
1499 /* Free the skb? */
1500 int free;
Herbert Xud565b0a2008-12-15 23:38:52 -08001501};
1502
1503#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
Alexander Duyckd8156532008-07-08 15:13:05 -07001504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505struct packet_type {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001506 __be16 type; /* This is really htons(ether_type). */
1507 struct net_device *dev; /* NULL is wildcarded here */
1508 int (*func) (struct sk_buff *,
1509 struct net_device *,
1510 struct packet_type *,
1511 struct net_device *);
Herbert Xu576a30e2006-06-27 13:22:38 -07001512 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
Michał Mirosław04ed3e72011-01-24 15:32:47 -08001513 u32 features);
Herbert Xua430a432006-07-08 13:34:56 -07001514 int (*gso_send_check)(struct sk_buff *skb);
Herbert Xud565b0a2008-12-15 23:38:52 -08001515 struct sk_buff **(*gro_receive)(struct sk_buff **head,
1516 struct sk_buff *skb);
1517 int (*gro_complete)(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 void *af_packet_priv;
1519 struct list_head list;
1520};
1521
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522#include <linux/notifier.h>
1523
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524extern rwlock_t dev_base_lock; /* Device list lock */
1525
Eric W. Biederman881d9662007-09-17 11:56:21 -07001526
1527#define for_each_netdev(net, d) \
1528 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
Eric W. Biedermandcbccbd42009-11-29 22:25:26 +00001529#define for_each_netdev_reverse(net, d) \
1530 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001531#define for_each_netdev_rcu(net, d) \
1532 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
Eric W. Biederman881d9662007-09-17 11:56:21 -07001533#define for_each_netdev_safe(net, d, n) \
1534 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
1535#define for_each_netdev_continue(net, d) \
1536 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
stephen hemminger254245d2009-11-10 07:54:47 +00001537#define for_each_netdev_continue_rcu(net, d) \
1538 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001539#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
1540
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001541static inline struct net_device *next_net_device(struct net_device *dev)
1542{
1543 struct list_head *lh;
1544 struct net *net;
Pavel Emelianov7562f872007-05-03 15:13:45 -07001545
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001546 net = dev_net(dev);
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001547 lh = dev->dev_list.next;
1548 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1549}
1550
Eric Dumazetce81b762009-11-11 17:34:30 +00001551static inline struct net_device *next_net_device_rcu(struct net_device *dev)
1552{
1553 struct list_head *lh;
1554 struct net *net;
1555
1556 net = dev_net(dev);
Eric Dumazetccf43432011-01-26 18:08:02 +00001557 lh = rcu_dereference(list_next_rcu(&dev->dev_list));
Eric Dumazetce81b762009-11-11 17:34:30 +00001558 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1559}
1560
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001561static inline struct net_device *first_net_device(struct net *net)
1562{
1563 return list_empty(&net->dev_base_head) ? NULL :
1564 net_device_entry(net->dev_base_head.next);
1565}
Pavel Emelianov7562f872007-05-03 15:13:45 -07001566
Eric Dumazetccf43432011-01-26 18:08:02 +00001567static inline struct net_device *first_net_device_rcu(struct net *net)
1568{
1569 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
1570
1571 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1572}
1573
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574extern int netdev_boot_setup_check(struct net_device *dev);
1575extern unsigned long netdev_boot_base(const char *prefix, int unit);
Eric Dumazet941666c2010-12-05 01:23:53 +00001576extern struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
1577 const char *hwaddr);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001578extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
1579extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580extern void dev_add_pack(struct packet_type *pt);
1581extern void dev_remove_pack(struct packet_type *pt);
1582extern void __dev_remove_pack(struct packet_type *pt);
1583
Eric Dumazetbb69ae02010-06-07 11:42:13 +00001584extern struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags,
1585 unsigned short mask);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001586extern struct net_device *dev_get_by_name(struct net *net, const char *name);
Eric Dumazet72c95282009-10-30 07:11:27 +00001587extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001588extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589extern int dev_alloc_name(struct net_device *dev, const char *name);
1590extern int dev_open(struct net_device *dev);
1591extern int dev_close(struct net_device *dev);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001592extern void dev_disable_lro(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593extern int dev_queue_xmit(struct sk_buff *skb);
1594extern int register_netdevice(struct net_device *dev);
Eric Dumazet44a08732009-10-27 07:03:04 +00001595extern void unregister_netdevice_queue(struct net_device *dev,
1596 struct list_head *head);
Eric Dumazet9b5e3832009-10-27 07:04:19 +00001597extern void unregister_netdevice_many(struct list_head *head);
Eric Dumazet44a08732009-10-27 07:03:04 +00001598static inline void unregister_netdevice(struct net_device *dev)
1599{
1600 unregister_netdevice_queue(dev, NULL);
1601}
1602
Eric Dumazet29b44332010-10-11 10:22:12 +00001603extern int netdev_refcnt_read(const struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604extern void free_netdev(struct net_device *dev);
1605extern void synchronize_net(void);
1606extern int register_netdevice_notifier(struct notifier_block *nb);
1607extern int unregister_netdevice_notifier(struct notifier_block *nb);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001608extern int init_dummy_netdev(struct net_device *dev);
David S. Miller9d40bbd2009-03-04 23:46:25 -08001609extern void netdev_resync_ops(struct net_device *dev);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001610
Eric W. Biedermanad7379d2007-09-16 15:33:32 -07001611extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001612extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
1613extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
Eric Dumazetfb699dfd2009-10-19 19:18:49 +00001614extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615extern int dev_restart(struct net_device *dev);
1616#ifdef CONFIG_NETPOLL_TRAP
1617extern int netpoll_trap(void);
1618#endif
Herbert Xu86911732009-01-29 14:19:50 +00001619extern int skb_gro_receive(struct sk_buff **head,
1620 struct sk_buff *skb);
Herbert Xu78a478d2009-05-26 18:50:21 +00001621extern void skb_gro_reset_offset(struct sk_buff *skb);
Herbert Xu86911732009-01-29 14:19:50 +00001622
1623static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
1624{
1625 return NAPI_GRO_CB(skb)->data_offset;
1626}
1627
1628static inline unsigned int skb_gro_len(const struct sk_buff *skb)
1629{
1630 return skb->len - NAPI_GRO_CB(skb)->data_offset;
1631}
1632
1633static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
1634{
1635 NAPI_GRO_CB(skb)->data_offset += len;
1636}
1637
Herbert Xua5b1cf22009-05-26 18:50:28 +00001638static inline void *skb_gro_header_fast(struct sk_buff *skb,
1639 unsigned int offset)
Herbert Xu86911732009-01-29 14:19:50 +00001640{
Herbert Xu78a478d2009-05-26 18:50:21 +00001641 return NAPI_GRO_CB(skb)->frag0 + offset;
Herbert Xu86911732009-01-29 14:19:50 +00001642}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
Herbert Xua5b1cf22009-05-26 18:50:28 +00001644static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
1645{
1646 return NAPI_GRO_CB(skb)->frag0_len < hlen;
1647}
1648
1649static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
1650 unsigned int offset)
1651{
1652 NAPI_GRO_CB(skb)->frag0 = NULL;
1653 NAPI_GRO_CB(skb)->frag0_len = 0;
1654 return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
1655}
1656
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001657static inline void *skb_gro_mac_header(struct sk_buff *skb)
1658{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001659 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001660}
1661
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001662static inline void *skb_gro_network_header(struct sk_buff *skb)
1663{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001664 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
1665 skb_network_offset(skb);
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001666}
1667
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001668static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
1669 unsigned short type,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001670 const void *daddr, const void *saddr,
1671 unsigned len)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001672{
Ursula Braunf1ecfd52007-10-22 16:16:14 +02001673 if (!dev->header_ops || !dev->header_ops->create)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001674 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001675
1676 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001677}
1678
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001679static inline int dev_parse_header(const struct sk_buff *skb,
1680 unsigned char *haddr)
1681{
1682 const struct net_device *dev = skb->dev;
1683
Patrick McHardy1b833362007-10-18 05:09:28 -07001684 if (!dev->header_ops || !dev->header_ops->parse)
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001685 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001686 return dev->header_ops->parse(skb, haddr);
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001687}
1688
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
1690extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
1691static inline int unregister_gifconf(unsigned int family)
1692{
1693 return register_gifconf(family, NULL);
1694}
1695
1696/*
Eric Dumazet88751272010-04-19 05:07:33 +00001697 * Incoming packets are placed on per-cpu queues
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 */
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08001699struct softnet_data {
David S. Miller37437bb2008-07-16 02:15:04 -07001700 struct Qdisc *output_queue;
Changli Gaoa9cbd582010-04-26 23:06:24 +00001701 struct Qdisc **output_queue_tailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 struct list_head poll_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 struct sk_buff *completion_queue;
Changli Gao6e7676c2010-04-27 15:07:33 -07001704 struct sk_buff_head process_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705
Changli Gaodee42872010-05-02 05:42:16 +00001706 /* stats */
David S. Millercd7b5392010-05-02 22:27:59 -07001707 unsigned int processed;
1708 unsigned int time_squeeze;
1709 unsigned int cpu_collision;
1710 unsigned int received_rps;
Changli Gaodee42872010-05-02 05:42:16 +00001711
Changli Gaofd793d82010-04-15 00:16:59 -07001712#ifdef CONFIG_RPS
Eric Dumazet88751272010-04-19 05:07:33 +00001713 struct softnet_data *rps_ipi_list;
1714
1715 /* Elements below can be accessed between CPUs for RPS */
Tom Herbert0a9627f2010-03-16 08:03:29 +00001716 struct call_single_data csd ____cacheline_aligned_in_smp;
Eric Dumazet88751272010-04-19 05:07:33 +00001717 struct softnet_data *rps_ipi_next;
1718 unsigned int cpu;
Tom Herbertfec5e652010-04-16 16:01:27 -07001719 unsigned int input_queue_head;
Tom Herbert76cc8b12010-05-20 18:37:59 +00001720 unsigned int input_queue_tail;
Tom Herbert1e94d722010-03-18 17:45:44 -07001721#endif
Changli Gaodee42872010-05-02 05:42:16 +00001722 unsigned dropped;
Tom Herbert0a9627f2010-03-16 08:03:29 +00001723 struct sk_buff_head input_pkt_queue;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001724 struct napi_struct backlog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725};
1726
Tom Herbert76cc8b12010-05-20 18:37:59 +00001727static inline void input_queue_head_incr(struct softnet_data *sd)
Tom Herbertfec5e652010-04-16 16:01:27 -07001728{
1729#ifdef CONFIG_RPS
Tom Herbert76cc8b12010-05-20 18:37:59 +00001730 sd->input_queue_head++;
1731#endif
1732}
1733
1734static inline void input_queue_tail_incr_save(struct softnet_data *sd,
1735 unsigned int *qtail)
1736{
1737#ifdef CONFIG_RPS
1738 *qtail = ++sd->input_queue_tail;
Tom Herbertfec5e652010-04-16 16:01:27 -07001739#endif
1740}
1741
Tom Herbert0a9627f2010-03-16 08:03:29 +00001742DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743
David S. Miller37437bb2008-07-16 02:15:04 -07001744extern void __netif_schedule(struct Qdisc *q);
David S. Miller86d804e2008-07-08 23:11:25 -07001745
1746static inline void netif_schedule_queue(struct netdev_queue *txq)
1747{
David S. Miller79d16382008-07-08 23:14:46 -07001748 if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001749 __netif_schedule(txq->qdisc);
David S. Miller86d804e2008-07-08 23:11:25 -07001750}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001752static inline void netif_tx_schedule_all(struct net_device *dev)
1753{
1754 unsigned int i;
1755
1756 for (i = 0; i < dev->num_tx_queues; i++)
1757 netif_schedule_queue(netdev_get_tx_queue(dev, i));
1758}
1759
Dave Jonesd29f7492008-07-22 14:09:06 -07001760static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
1761{
1762 clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1763}
1764
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001765/**
1766 * netif_start_queue - allow transmit
1767 * @dev: network device
1768 *
1769 * Allow upper layers to call the device hard_start_xmit routine.
1770 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771static inline void netif_start_queue(struct net_device *dev)
1772{
David S. Millere8a04642008-07-17 00:34:19 -07001773 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774}
1775
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001776static inline void netif_tx_start_all_queues(struct net_device *dev)
1777{
1778 unsigned int i;
1779
1780 for (i = 0; i < dev->num_tx_queues; i++) {
1781 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1782 netif_tx_start_queue(txq);
1783 }
1784}
1785
David S. Miller79d16382008-07-08 23:14:46 -07001786static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787{
1788#ifdef CONFIG_NETPOLL_TRAP
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001789 if (netpoll_trap()) {
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001790 netif_tx_start_queue(dev_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 return;
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793#endif
David S. Miller79d16382008-07-08 23:14:46 -07001794 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001795 __netif_schedule(dev_queue->qdisc);
David S. Miller79d16382008-07-08 23:14:46 -07001796}
1797
Dave Jonesd29f7492008-07-22 14:09:06 -07001798/**
1799 * netif_wake_queue - restart transmit
1800 * @dev: network device
1801 *
1802 * Allow upper layers to call the device hard_start_xmit routine.
1803 * Used for flow control when transmit resources are available.
1804 */
David S. Miller79d16382008-07-08 23:14:46 -07001805static inline void netif_wake_queue(struct net_device *dev)
1806{
David S. Millere8a04642008-07-17 00:34:19 -07001807 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808}
1809
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001810static inline void netif_tx_wake_all_queues(struct net_device *dev)
1811{
1812 unsigned int i;
1813
1814 for (i = 0; i < dev->num_tx_queues; i++) {
1815 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1816 netif_tx_wake_queue(txq);
1817 }
1818}
1819
Dave Jonesd29f7492008-07-22 14:09:06 -07001820static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
1821{
Guillaume Chazarain18543a62010-11-06 06:39:32 +00001822 if (WARN_ON(!dev_queue)) {
Joe Perches256ee432011-03-01 07:06:12 +00001823 pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
Guillaume Chazarain18543a62010-11-06 06:39:32 +00001824 return;
1825 }
Dave Jonesd29f7492008-07-22 14:09:06 -07001826 set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1827}
1828
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001829/**
1830 * netif_stop_queue - stop transmitted packets
1831 * @dev: network device
1832 *
1833 * Stop upper layers calling the device hard_start_xmit routine.
1834 * Used for flow control when transmit resources are unavailable.
1835 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836static inline void netif_stop_queue(struct net_device *dev)
1837{
David S. Millere8a04642008-07-17 00:34:19 -07001838 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839}
1840
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001841static inline void netif_tx_stop_all_queues(struct net_device *dev)
1842{
1843 unsigned int i;
1844
1845 for (i = 0; i < dev->num_tx_queues; i++) {
1846 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1847 netif_tx_stop_queue(txq);
1848 }
1849}
1850
Dave Jonesd29f7492008-07-22 14:09:06 -07001851static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
1852{
1853 return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1854}
1855
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001856/**
1857 * netif_queue_stopped - test if transmit queue is flowblocked
1858 * @dev: network device
1859 *
1860 * Test if transmit queue on device is currently unable to send.
1861 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862static inline int netif_queue_stopped(const struct net_device *dev)
1863{
David S. Millere8a04642008-07-17 00:34:19 -07001864 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865}
1866
Eric Dumazet5a0d2262010-11-23 10:42:02 +00001867static inline int netif_tx_queue_frozen_or_stopped(const struct netdev_queue *dev_queue)
David S. Millerc3f26a22008-07-31 16:58:50 -07001868{
Eric Dumazet5a0d2262010-11-23 10:42:02 +00001869 return dev_queue->state & QUEUE_STATE_XOFF_OR_FROZEN;
David S. Millerc3f26a22008-07-31 16:58:50 -07001870}
1871
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001872/**
1873 * netif_running - test if up
1874 * @dev: network device
1875 *
1876 * Test if the device has been brought up.
1877 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878static inline int netif_running(const struct net_device *dev)
1879{
1880 return test_bit(__LINK_STATE_START, &dev->state);
1881}
1882
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001883/*
1884 * Routines to manage the subqueues on a device. We only need start
1885 * stop, and a check if it's stopped. All other device management is
1886 * done at the overall netdevice level.
1887 * Also test the device if we're multiqueue.
1888 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001889
1890/**
1891 * netif_start_subqueue - allow sending packets on subqueue
1892 * @dev: network device
1893 * @queue_index: sub queue index
1894 *
1895 * Start individual transmit queue of a device with multiple transmit queues.
1896 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001897static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
1898{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001899 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001900
1901 netif_tx_start_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001902}
1903
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001904/**
1905 * netif_stop_subqueue - stop sending packets on subqueue
1906 * @dev: network device
1907 * @queue_index: sub queue index
1908 *
1909 * Stop individual transmit queue of a device with multiple transmit queues.
1910 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001911static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
1912{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001913 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001914#ifdef CONFIG_NETPOLL_TRAP
1915 if (netpoll_trap())
1916 return;
1917#endif
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001918 netif_tx_stop_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001919}
1920
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001921/**
1922 * netif_subqueue_stopped - test status of subqueue
1923 * @dev: network device
1924 * @queue_index: sub queue index
1925 *
1926 * Check individual transmit queue of a device with multiple transmit queues.
1927 */
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001928static inline int __netif_subqueue_stopped(const struct net_device *dev,
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001929 u16 queue_index)
1930{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001931 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001932
1933 return netif_tx_queue_stopped(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001934}
1935
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001936static inline int netif_subqueue_stopped(const struct net_device *dev,
1937 struct sk_buff *skb)
1938{
1939 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
1940}
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001941
1942/**
1943 * netif_wake_subqueue - allow sending packets on subqueue
1944 * @dev: network device
1945 * @queue_index: sub queue index
1946 *
1947 * Resume individual transmit queue of a device with multiple transmit queues.
1948 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001949static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
1950{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001951 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001952#ifdef CONFIG_NETPOLL_TRAP
1953 if (netpoll_trap())
1954 return;
1955#endif
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001956 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001957 __netif_schedule(txq->qdisc);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001958}
1959
Vladislav Zolotarova3d22a62010-12-13 06:27:10 +00001960/*
1961 * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
1962 * as a distribution range limit for the returned value.
1963 */
1964static inline u16 skb_tx_hash(const struct net_device *dev,
1965 const struct sk_buff *skb)
1966{
1967 return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
1968}
1969
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001970/**
1971 * netif_is_multiqueue - test if device has multiple transmit queues
1972 * @dev: network device
1973 *
1974 * Check if device has multiple transmit queues
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001975 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001976static inline int netif_is_multiqueue(const struct net_device *dev)
1977{
Eric Dumazeta02cec22010-09-22 20:43:57 +00001978 return dev->num_tx_queues > 1;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001979}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980
Tom Herberte6484932010-10-18 18:04:39 +00001981extern int netif_set_real_num_tx_queues(struct net_device *dev,
1982 unsigned int txq);
John Fastabendf0796d52010-07-01 13:21:57 +00001983
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001984#ifdef CONFIG_RPS
1985extern int netif_set_real_num_rx_queues(struct net_device *dev,
1986 unsigned int rxq);
1987#else
1988static inline int netif_set_real_num_rx_queues(struct net_device *dev,
1989 unsigned int rxq)
1990{
1991 return 0;
1992}
1993#endif
1994
Ben Hutchings3171d022010-09-27 08:24:49 +00001995static inline int netif_copy_real_num_queues(struct net_device *to_dev,
1996 const struct net_device *from_dev)
1997{
1998 netif_set_real_num_tx_queues(to_dev, from_dev->real_num_tx_queues);
1999#ifdef CONFIG_RPS
2000 return netif_set_real_num_rx_queues(to_dev,
2001 from_dev->real_num_rx_queues);
2002#else
2003 return 0;
2004#endif
2005}
2006
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007/* Use this variant when it is known for sure that it
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07002008 * is executing from hardware interrupt context or with hardware interrupts
2009 * disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002011extern void dev_kfree_skb_irq(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012
2013/* Use this variant in places where it could be invoked
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07002014 * from either hardware interrupt or other context, with hardware interrupts
2015 * either disabled or enabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 */
Denis Vlasenko56079432006-03-29 15:57:29 -08002017extern void dev_kfree_skb_any(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019extern int netif_rx(struct sk_buff *skb);
2020extern int netif_rx_ni(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021extern int netif_receive_skb(struct sk_buff *skb);
Ben Hutchings5b252f02009-10-29 07:17:09 +00002022extern gro_result_t dev_gro_receive(struct napi_struct *napi,
Herbert Xu96e93ea2009-01-06 10:49:34 -08002023 struct sk_buff *skb);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07002024extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb);
2025extern gro_result_t napi_gro_receive(struct napi_struct *napi,
Herbert Xud565b0a2008-12-15 23:38:52 -08002026 struct sk_buff *skb);
Eric Dumazet86cac582010-08-31 18:25:32 +00002027extern void napi_gro_flush(struct napi_struct *napi);
Herbert Xu76620aa2009-04-16 02:02:07 -07002028extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07002029extern gro_result_t napi_frags_finish(struct napi_struct *napi,
Ben Hutchings5b252f02009-10-29 07:17:09 +00002030 struct sk_buff *skb,
2031 gro_result_t ret);
Herbert Xu76620aa2009-04-16 02:02:07 -07002032extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07002033extern gro_result_t napi_gro_frags(struct napi_struct *napi);
Herbert Xu76620aa2009-04-16 02:02:07 -07002034
2035static inline void napi_free_frags(struct napi_struct *napi)
2036{
2037 kfree_skb(napi->skb);
2038 napi->skb = NULL;
2039}
2040
Jiri Pirkoab95bfe2010-06-01 21:52:08 +00002041extern int netdev_rx_handler_register(struct net_device *dev,
Jiri Pirko93e2c322010-06-10 03:34:59 +00002042 rx_handler_func_t *rx_handler,
2043 void *rx_handler_data);
Jiri Pirkoab95bfe2010-06-01 21:52:08 +00002044extern void netdev_rx_handler_unregister(struct net_device *dev);
2045
Mitch Williamsc2373ee2005-11-09 10:34:45 -08002046extern int dev_valid_name(const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07002047extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
2048extern int dev_ethtool(struct net *net, struct ifreq *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049extern unsigned dev_get_flags(const struct net_device *);
Patrick McHardybd380812010-02-26 06:34:53 +00002050extern int __dev_change_flags(struct net_device *, unsigned int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051extern int dev_change_flags(struct net_device *, unsigned);
Patrick McHardybd380812010-02-26 06:34:53 +00002052extern void __dev_notify_flags(struct net_device *, unsigned int old_flags);
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -07002053extern int dev_change_name(struct net_device *, const char *);
Stephen Hemminger0b815a12008-09-22 21:28:11 -07002054extern int dev_set_alias(struct net_device *, const char *, size_t);
Eric W. Biedermance286d32007-09-12 13:53:49 +02002055extern int dev_change_net_namespace(struct net_device *,
2056 struct net *, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057extern int dev_set_mtu(struct net_device *, int);
Vlad Dogarucbda10f2011-01-13 23:38:30 +00002058extern void dev_set_group(struct net_device *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059extern int dev_set_mac_address(struct net_device *,
2060 struct sockaddr *);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07002061extern int dev_hard_start_xmit(struct sk_buff *skb,
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002062 struct net_device *dev,
2063 struct netdev_queue *txq);
Arnd Bergmann44540962009-11-26 06:07:08 +00002064extern int dev_forward_skb(struct net_device *dev,
2065 struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002067extern int netdev_budget;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068
2069/* Called by rtnetlink.c:rtnl_unlock() */
2070extern void netdev_run_todo(void);
2071
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002072/**
2073 * dev_put - release reference to device
2074 * @dev: network device
2075 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07002076 * Release reference to device to allow it to be freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002077 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078static inline void dev_put(struct net_device *dev)
2079{
Eric Dumazet29b44332010-10-11 10:22:12 +00002080 irqsafe_cpu_dec(*dev->pcpu_refcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081}
2082
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002083/**
2084 * dev_hold - get reference to device
2085 * @dev: network device
2086 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07002087 * Hold reference to device to keep it from being freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002088 */
Stephen Hemminger15333062006-03-20 22:32:28 -08002089static inline void dev_hold(struct net_device *dev)
2090{
Eric Dumazet29b44332010-10-11 10:22:12 +00002091 irqsafe_cpu_inc(*dev->pcpu_refcnt);
Stephen Hemminger15333062006-03-20 22:32:28 -08002092}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093
2094/* Carrier loss detection, dial on demand. The functions netif_carrier_on
2095 * and _off may be called from IRQ context, but it is caller
2096 * who is responsible for serialization of these calls.
Stefan Rompfb00055a2006-03-20 17:09:11 -08002097 *
2098 * The name carrier is inappropriate, these functions should really be
2099 * called netif_lowerlayer_*() because they represent the state of any
2100 * kind of lower layer not just hardware media.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 */
2102
2103extern void linkwatch_fire_event(struct net_device *dev);
Eric Dumazete014deb2009-11-17 05:59:21 +00002104extern void linkwatch_forget_dev(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002106/**
2107 * netif_carrier_ok - test if carrier present
2108 * @dev: network device
2109 *
2110 * Check if carrier is present on device
2111 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112static inline int netif_carrier_ok(const struct net_device *dev)
2113{
2114 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
2115}
2116
Eric Dumazet9d214932009-05-17 20:55:16 -07002117extern unsigned long dev_trans_start(struct net_device *dev);
2118
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119extern void __netdev_watchdog_up(struct net_device *dev);
2120
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07002121extern void netif_carrier_on(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07002123extern void netif_carrier_off(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
Ian Campbell06c46482010-05-26 00:09:42 +00002125extern void netif_notify_peers(struct net_device *dev);
2126
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002127/**
2128 * netif_dormant_on - mark device as dormant.
2129 * @dev: network device
2130 *
2131 * Mark device as dormant (as per RFC2863).
2132 *
2133 * The dormant state indicates that the relevant interface is not
2134 * actually in a condition to pass packets (i.e., it is not 'up') but is
2135 * in a "pending" state, waiting for some external event. For "on-
2136 * demand" interfaces, this new state identifies the situation where the
2137 * interface is waiting for events to place it in the up state.
2138 *
2139 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08002140static inline void netif_dormant_on(struct net_device *dev)
2141{
2142 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
2143 linkwatch_fire_event(dev);
2144}
2145
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002146/**
2147 * netif_dormant_off - set device as not dormant.
2148 * @dev: network device
2149 *
2150 * Device is not in dormant state.
2151 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08002152static inline void netif_dormant_off(struct net_device *dev)
2153{
2154 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
2155 linkwatch_fire_event(dev);
2156}
2157
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002158/**
2159 * netif_dormant - test if carrier present
2160 * @dev: network device
2161 *
2162 * Check if carrier is present on device
2163 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08002164static inline int netif_dormant(const struct net_device *dev)
2165{
2166 return test_bit(__LINK_STATE_DORMANT, &dev->state);
2167}
2168
2169
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002170/**
2171 * netif_oper_up - test if device is operational
2172 * @dev: network device
2173 *
2174 * Check if carrier is operational
2175 */
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08002176static inline int netif_oper_up(const struct net_device *dev)
2177{
Stefan Rompfb00055a2006-03-20 17:09:11 -08002178 return (dev->operstate == IF_OPER_UP ||
2179 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
2180}
2181
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002182/**
2183 * netif_device_present - is device available or removed
2184 * @dev: network device
2185 *
2186 * Check if device has not been removed from system.
2187 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188static inline int netif_device_present(struct net_device *dev)
2189{
2190 return test_bit(__LINK_STATE_PRESENT, &dev->state);
2191}
2192
Denis Vlasenko56079432006-03-29 15:57:29 -08002193extern void netif_device_detach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194
Denis Vlasenko56079432006-03-29 15:57:29 -08002195extern void netif_device_attach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196
2197/*
2198 * Network interface message level settings
2199 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200
2201enum {
2202 NETIF_MSG_DRV = 0x0001,
2203 NETIF_MSG_PROBE = 0x0002,
2204 NETIF_MSG_LINK = 0x0004,
2205 NETIF_MSG_TIMER = 0x0008,
2206 NETIF_MSG_IFDOWN = 0x0010,
2207 NETIF_MSG_IFUP = 0x0020,
2208 NETIF_MSG_RX_ERR = 0x0040,
2209 NETIF_MSG_TX_ERR = 0x0080,
2210 NETIF_MSG_TX_QUEUED = 0x0100,
2211 NETIF_MSG_INTR = 0x0200,
2212 NETIF_MSG_TX_DONE = 0x0400,
2213 NETIF_MSG_RX_STATUS = 0x0800,
2214 NETIF_MSG_PKTDATA = 0x1000,
2215 NETIF_MSG_HW = 0x2000,
2216 NETIF_MSG_WOL = 0x4000,
2217};
2218
2219#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
2220#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
2221#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
2222#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
2223#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
2224#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
2225#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
2226#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
2227#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
2228#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
2229#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
2230#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
2231#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
2232#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
2233#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
2234
2235static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
2236{
2237 /* use default */
2238 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
2239 return default_msg_enable_bits;
2240 if (debug_value == 0) /* no output */
2241 return 0;
2242 /* set low N bits */
2243 return (1 << debug_value) - 1;
2244}
2245
David S. Millerc773e842008-07-08 23:13:53 -07002246static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
Herbert Xu932ff272006-06-09 12:20:56 -07002247{
David S. Millerc773e842008-07-08 23:13:53 -07002248 spin_lock(&txq->_xmit_lock);
2249 txq->xmit_lock_owner = cpu;
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002250}
2251
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002252static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
2253{
2254 spin_lock_bh(&txq->_xmit_lock);
2255 txq->xmit_lock_owner = smp_processor_id();
2256}
2257
David S. Millerc773e842008-07-08 23:13:53 -07002258static inline int __netif_tx_trylock(struct netdev_queue *txq)
2259{
2260 int ok = spin_trylock(&txq->_xmit_lock);
2261 if (likely(ok))
2262 txq->xmit_lock_owner = smp_processor_id();
2263 return ok;
Herbert Xu932ff272006-06-09 12:20:56 -07002264}
2265
David S. Millerc773e842008-07-08 23:13:53 -07002266static inline void __netif_tx_unlock(struct netdev_queue *txq)
2267{
2268 txq->xmit_lock_owner = -1;
2269 spin_unlock(&txq->_xmit_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07002270}
2271
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002272static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
2273{
2274 txq->xmit_lock_owner = -1;
2275 spin_unlock_bh(&txq->_xmit_lock);
2276}
2277
Eric Dumazet08baf562009-05-25 22:58:01 -07002278static inline void txq_trans_update(struct netdev_queue *txq)
2279{
2280 if (txq->xmit_lock_owner != -1)
2281 txq->trans_start = jiffies;
2282}
2283
David S. Millerc3f26a22008-07-31 16:58:50 -07002284/**
2285 * netif_tx_lock - grab network device transmit lock
2286 * @dev: network device
David S. Millerc3f26a22008-07-31 16:58:50 -07002287 *
2288 * Get network device transmit lock
2289 */
2290static inline void netif_tx_lock(struct net_device *dev)
2291{
2292 unsigned int i;
2293 int cpu;
2294
2295 spin_lock(&dev->tx_global_lock);
2296 cpu = smp_processor_id();
2297 for (i = 0; i < dev->num_tx_queues; i++) {
2298 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2299
2300 /* We are the only thread of execution doing a
2301 * freeze, but we have to grab the _xmit_lock in
2302 * order to synchronize with threads which are in
2303 * the ->hard_start_xmit() handler and already
2304 * checked the frozen bit.
2305 */
2306 __netif_tx_lock(txq, cpu);
2307 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
2308 __netif_tx_unlock(txq);
2309 }
2310}
2311
2312static inline void netif_tx_lock_bh(struct net_device *dev)
2313{
2314 local_bh_disable();
2315 netif_tx_lock(dev);
2316}
2317
Herbert Xu932ff272006-06-09 12:20:56 -07002318static inline void netif_tx_unlock(struct net_device *dev)
2319{
David S. Millere8a04642008-07-17 00:34:19 -07002320 unsigned int i;
David S. Millerc773e842008-07-08 23:13:53 -07002321
David S. Millere8a04642008-07-17 00:34:19 -07002322 for (i = 0; i < dev->num_tx_queues; i++) {
2323 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millere8a04642008-07-17 00:34:19 -07002324
David S. Millerc3f26a22008-07-31 16:58:50 -07002325 /* No need to grab the _xmit_lock here. If the
2326 * queue is not stopped for another reason, we
2327 * force a schedule.
2328 */
2329 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00002330 netif_schedule_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07002331 }
2332 spin_unlock(&dev->tx_global_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07002333}
2334
2335static inline void netif_tx_unlock_bh(struct net_device *dev)
2336{
David S. Millere8a04642008-07-17 00:34:19 -07002337 netif_tx_unlock(dev);
2338 local_bh_enable();
Herbert Xu932ff272006-06-09 12:20:56 -07002339}
2340
David S. Millerc773e842008-07-08 23:13:53 -07002341#define HARD_TX_LOCK(dev, txq, cpu) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002342 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07002343 __netif_tx_lock(txq, cpu); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002344 } \
2345}
2346
David S. Millerc773e842008-07-08 23:13:53 -07002347#define HARD_TX_UNLOCK(dev, txq) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002348 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07002349 __netif_tx_unlock(txq); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002350 } \
2351}
2352
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353static inline void netif_tx_disable(struct net_device *dev)
2354{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002355 unsigned int i;
David S. Millerc3f26a22008-07-31 16:58:50 -07002356 int cpu;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002357
David S. Millerc3f26a22008-07-31 16:58:50 -07002358 local_bh_disable();
2359 cpu = smp_processor_id();
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002360 for (i = 0; i < dev->num_tx_queues; i++) {
2361 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millerc3f26a22008-07-31 16:58:50 -07002362
2363 __netif_tx_lock(txq, cpu);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002364 netif_tx_stop_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07002365 __netif_tx_unlock(txq);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002366 }
David S. Millerc3f26a22008-07-31 16:58:50 -07002367 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368}
2369
David S. Millere308a5d2008-07-15 00:13:44 -07002370static inline void netif_addr_lock(struct net_device *dev)
2371{
2372 spin_lock(&dev->addr_list_lock);
2373}
2374
2375static inline void netif_addr_lock_bh(struct net_device *dev)
2376{
2377 spin_lock_bh(&dev->addr_list_lock);
2378}
2379
2380static inline void netif_addr_unlock(struct net_device *dev)
2381{
2382 spin_unlock(&dev->addr_list_lock);
2383}
2384
2385static inline void netif_addr_unlock_bh(struct net_device *dev)
2386{
2387 spin_unlock_bh(&dev->addr_list_lock);
2388}
2389
Jiri Pirkof001fde2009-05-05 02:48:28 +00002390/*
Jiri Pirko31278e72009-06-17 01:12:19 +00002391 * dev_addrs walker. Should be used only for read access. Call with
Jiri Pirkof001fde2009-05-05 02:48:28 +00002392 * rcu_read_lock held.
2393 */
2394#define for_each_dev_addr(dev, ha) \
Jiri Pirko31278e72009-06-17 01:12:19 +00002395 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
Jiri Pirkof001fde2009-05-05 02:48:28 +00002396
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397/* These functions live elsewhere (drivers/net/net_init.c, but related) */
2398
2399extern void ether_setup(struct net_device *dev);
2400
2401/* Support for loadable net-drivers */
Tom Herbert36909ea2011-01-09 19:36:31 +00002402extern struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002403 void (*setup)(struct net_device *),
Tom Herbert36909ea2011-01-09 19:36:31 +00002404 unsigned int txqs, unsigned int rxqs);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002405#define alloc_netdev(sizeof_priv, name, setup) \
Tom Herbert36909ea2011-01-09 19:36:31 +00002406 alloc_netdev_mqs(sizeof_priv, name, setup, 1, 1)
2407
2408#define alloc_netdev_mq(sizeof_priv, name, setup, count) \
2409 alloc_netdev_mqs(sizeof_priv, name, setup, count, count)
2410
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411extern int register_netdev(struct net_device *dev);
2412extern void unregister_netdev(struct net_device *dev);
Jiri Pirkof001fde2009-05-05 02:48:28 +00002413
Jiri Pirko22bedad32010-04-01 21:22:57 +00002414/* General hardware address lists handling functions */
2415extern int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
2416 struct netdev_hw_addr_list *from_list,
2417 int addr_len, unsigned char addr_type);
2418extern void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
2419 struct netdev_hw_addr_list *from_list,
2420 int addr_len, unsigned char addr_type);
2421extern int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
2422 struct netdev_hw_addr_list *from_list,
2423 int addr_len);
2424extern void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
2425 struct netdev_hw_addr_list *from_list,
2426 int addr_len);
2427extern void __hw_addr_flush(struct netdev_hw_addr_list *list);
2428extern void __hw_addr_init(struct netdev_hw_addr_list *list);
2429
Jiri Pirkof001fde2009-05-05 02:48:28 +00002430/* Functions used for device addresses handling */
2431extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
2432 unsigned char addr_type);
2433extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
2434 unsigned char addr_type);
2435extern int dev_addr_add_multiple(struct net_device *to_dev,
2436 struct net_device *from_dev,
2437 unsigned char addr_type);
2438extern int dev_addr_del_multiple(struct net_device *to_dev,
2439 struct net_device *from_dev,
2440 unsigned char addr_type);
Jiri Pirkoa748ee22010-04-01 21:22:09 +00002441extern void dev_addr_flush(struct net_device *dev);
2442extern int dev_addr_init(struct net_device *dev);
2443
2444/* Functions used for unicast addresses handling */
2445extern int dev_uc_add(struct net_device *dev, unsigned char *addr);
2446extern int dev_uc_del(struct net_device *dev, unsigned char *addr);
2447extern int dev_uc_sync(struct net_device *to, struct net_device *from);
2448extern void dev_uc_unsync(struct net_device *to, struct net_device *from);
2449extern void dev_uc_flush(struct net_device *dev);
2450extern void dev_uc_init(struct net_device *dev);
Jiri Pirkof001fde2009-05-05 02:48:28 +00002451
Jiri Pirko22bedad32010-04-01 21:22:57 +00002452/* Functions used for multicast addresses handling */
2453extern int dev_mc_add(struct net_device *dev, unsigned char *addr);
2454extern int dev_mc_add_global(struct net_device *dev, unsigned char *addr);
2455extern int dev_mc_del(struct net_device *dev, unsigned char *addr);
2456extern int dev_mc_del_global(struct net_device *dev, unsigned char *addr);
2457extern int dev_mc_sync(struct net_device *to, struct net_device *from);
2458extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
2459extern void dev_mc_flush(struct net_device *dev);
2460extern void dev_mc_init(struct net_device *dev);
Herbert Xufb286bb2005-11-10 13:01:24 -08002461
2462/* Functions used for secondary unicast and multicast support */
2463extern void dev_set_rx_mode(struct net_device *dev);
2464extern void __dev_set_rx_mode(struct net_device *dev);
Herbert Xufb286bb2005-11-10 13:01:24 -08002465extern int dev_set_promiscuity(struct net_device *dev, int inc);
2466extern int dev_set_allmulti(struct net_device *dev, int inc);
2467extern void netdev_state_change(struct net_device *dev);
Jiri Pirko3ca5b402010-03-10 10:29:35 +00002468extern int netdev_bonding_change(struct net_device *dev,
Moni Shoua75c78502009-09-15 02:37:40 -07002469 unsigned long event);
Herbert Xufb286bb2005-11-10 13:01:24 -08002470extern void netdev_features_change(struct net_device *dev);
2471/* Load a device via the kmod */
2472extern void dev_load(struct net *net, const char *name);
2473extern void dev_mcast_init(void);
Ben Hutchingsd7753512010-07-09 09:12:41 +00002474extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
2475 struct rtnl_link_stats64 *storage);
Herbert Xufb286bb2005-11-10 13:01:24 -08002476
2477extern int netdev_max_backlog;
Eric Dumazet3b098e22010-05-15 23:57:10 -07002478extern int netdev_tstamp_prequeue;
Herbert Xufb286bb2005-11-10 13:01:24 -08002479extern int weight_p;
Eric Dumazet0a148422011-04-20 09:27:32 +00002480extern int bpf_jit_enable;
Herbert Xufb286bb2005-11-10 13:01:24 -08002481extern int netdev_set_master(struct net_device *dev, struct net_device *master);
Jiri Pirko1765a572011-02-12 06:48:36 +00002482extern int netdev_set_bond_master(struct net_device *dev,
2483 struct net_device *master);
Herbert Xufb286bb2005-11-10 13:01:24 -08002484extern int skb_checksum_help(struct sk_buff *skb);
Michał Mirosław04ed3e72011-01-24 15:32:47 -08002485extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features);
Herbert Xufb286bb2005-11-10 13:01:24 -08002486#ifdef CONFIG_BUG
2487extern void netdev_rx_csum_fault(struct net_device *dev);
2488#else
2489static inline void netdev_rx_csum_fault(struct net_device *dev)
2490{
2491}
2492#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493/* rx skb timestamps */
2494extern void net_enable_timestamp(void);
2495extern void net_disable_timestamp(void);
2496
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002497#ifdef CONFIG_PROC_FS
2498extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
2499extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
2500extern void dev_seq_stop(struct seq_file *seq, void *v);
2501#endif
2502
Jay Vosburghb8a97872008-06-13 18:12:04 -07002503extern int netdev_class_create_file(struct class_attribute *class_attr);
2504extern void netdev_class_remove_file(struct class_attribute *class_attr);
2505
Johannes Berg04600792010-08-05 17:45:15 +02002506extern struct kobj_ns_type_operations net_ns_type_operations;
2507
David S. Miller3019de12011-06-06 16:41:33 -07002508extern const char *netdev_drivername(const struct net_device *dev);
Arjan van de Ven6579e572008-07-21 13:31:48 -07002509
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002510extern void linkwatch_run_queue(void);
2511
Michał Mirosław5455c692011-02-15 16:59:17 +00002512static inline u32 netdev_get_wanted_features(struct net_device *dev)
2513{
2514 return (dev->features & ~dev->hw_features) | dev->wanted_features;
2515}
Michał Mirosław04ed3e72011-01-24 15:32:47 -08002516u32 netdev_increment_features(u32 all, u32 one, u32 mask);
Michał Mirosław6cb6a272011-04-02 22:48:47 -07002517int __netdev_update_features(struct net_device *dev);
Michał Mirosław5455c692011-02-15 16:59:17 +00002518void netdev_update_features(struct net_device *dev);
Michał Mirosławafe12cc2011-05-07 03:22:17 +00002519void netdev_change_features(struct net_device *dev);
Herbert Xu7f353bf2007-08-10 15:47:58 -07002520
Patrick Mullaneyfc4a7482009-12-03 15:59:22 -08002521void netif_stacked_transfer_operstate(const struct net_device *rootdev,
2522 struct net_device *dev);
2523
Michał Mirosław04ed3e72011-01-24 15:32:47 -08002524u32 netif_skb_features(struct sk_buff *skb);
Jesse Gross58e998c2010-10-29 12:14:55 +00002525
Michał Mirosław04ed3e72011-01-24 15:32:47 -08002526static inline int net_gso_ok(u32 features, int gso_type)
Herbert Xubcd76112006-06-30 13:36:35 -07002527{
2528 int feature = gso_type << NETIF_F_GSO_SHIFT;
2529 return (features & feature) == feature;
2530}
2531
Michał Mirosław04ed3e72011-01-24 15:32:47 -08002532static inline int skb_gso_ok(struct sk_buff *skb, u32 features)
Herbert Xu576a30e2006-06-27 13:22:38 -07002533{
Herbert Xu278b2512009-06-03 21:20:51 -07002534 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
David S. Miller21dc3302010-08-23 00:13:46 -07002535 (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
Herbert Xu576a30e2006-06-27 13:22:38 -07002536}
2537
Jesse Grossfc741212011-01-09 06:23:32 +00002538static inline int netif_needs_gso(struct sk_buff *skb, int features)
Herbert Xu79671682006-06-22 02:40:14 -07002539{
Jesse Grossfc741212011-01-09 06:23:32 +00002540 return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
2541 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
Herbert Xu79671682006-06-22 02:40:14 -07002542}
2543
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07002544static inline void netif_set_gso_max_size(struct net_device *dev,
2545 unsigned int size)
2546{
2547 dev->gso_max_size = size;
2548}
2549
Jiri Pirko1765a572011-02-12 06:48:36 +00002550static inline int netif_is_bond_slave(struct net_device *dev)
2551{
2552 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
2553}
2554
Eric W. Biederman505d4f72008-11-07 22:54:20 -08002555extern struct pernet_operations __net_initdata loopback_net_ops;
Patrick McHardyb1b67dd2009-04-20 04:49:28 +00002556
David Decotigny8ae6daca2011-04-27 18:32:38 +00002557int dev_ethtool_get_settings(struct net_device *dev,
2558 struct ethtool_cmd *cmd);
Patrick McHardyb1b67dd2009-04-20 04:49:28 +00002559
2560static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
2561{
Michał Mirosław4dd5ffe2011-03-30 23:58:08 +00002562 if (dev->features & NETIF_F_RXCSUM)
2563 return 1;
Patrick McHardyb1b67dd2009-04-20 04:49:28 +00002564 if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
2565 return 0;
2566 return dev->ethtool_ops->get_rx_csum(dev);
2567}
2568
2569static inline u32 dev_ethtool_get_flags(struct net_device *dev)
2570{
2571 if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
2572 return 0;
2573 return dev->ethtool_ops->get_flags(dev);
2574}
Joe Perches571ba422010-02-09 11:49:47 +00002575
2576/* Logging, debugging and troubleshooting/diagnostic helpers. */
2577
2578/* netdev_printk helpers, similar to dev_printk */
2579
2580static inline const char *netdev_name(const struct net_device *dev)
2581{
2582 if (dev->reg_state != NETREG_REGISTERED)
2583 return "(unregistered net_device)";
2584 return dev->name;
2585}
2586
Joe Perches256df2f2010-06-27 01:02:35 +00002587extern int netdev_printk(const char *level, const struct net_device *dev,
2588 const char *format, ...)
2589 __attribute__ ((format (printf, 3, 4)));
2590extern int netdev_emerg(const struct net_device *dev, const char *format, ...)
2591 __attribute__ ((format (printf, 2, 3)));
2592extern int netdev_alert(const struct net_device *dev, const char *format, ...)
2593 __attribute__ ((format (printf, 2, 3)));
2594extern int netdev_crit(const struct net_device *dev, const char *format, ...)
2595 __attribute__ ((format (printf, 2, 3)));
2596extern int netdev_err(const struct net_device *dev, const char *format, ...)
2597 __attribute__ ((format (printf, 2, 3)));
2598extern int netdev_warn(const struct net_device *dev, const char *format, ...)
2599 __attribute__ ((format (printf, 2, 3)));
2600extern int netdev_notice(const struct net_device *dev, const char *format, ...)
2601 __attribute__ ((format (printf, 2, 3)));
2602extern int netdev_info(const struct net_device *dev, const char *format, ...)
2603 __attribute__ ((format (printf, 2, 3)));
Joe Perches571ba422010-02-09 11:49:47 +00002604
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +03002605#define MODULE_ALIAS_NETDEV(device) \
2606 MODULE_ALIAS("netdev-" device)
2607
Joe Perches571ba422010-02-09 11:49:47 +00002608#if defined(DEBUG)
2609#define netdev_dbg(__dev, format, args...) \
2610 netdev_printk(KERN_DEBUG, __dev, format, ##args)
2611#elif defined(CONFIG_DYNAMIC_DEBUG)
2612#define netdev_dbg(__dev, format, args...) \
2613do { \
2614 dynamic_dev_dbg((__dev)->dev.parent, "%s: " format, \
2615 netdev_name(__dev), ##args); \
2616} while (0)
2617#else
2618#define netdev_dbg(__dev, format, args...) \
2619({ \
2620 if (0) \
2621 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
2622 0; \
2623})
2624#endif
2625
2626#if defined(VERBOSE_DEBUG)
2627#define netdev_vdbg netdev_dbg
2628#else
2629
2630#define netdev_vdbg(dev, format, args...) \
2631({ \
2632 if (0) \
2633 netdev_printk(KERN_DEBUG, dev, format, ##args); \
2634 0; \
2635})
2636#endif
2637
2638/*
2639 * netdev_WARN() acts like dev_printk(), but with the key difference
2640 * of using a WARN/WARN_ON to get the message out, including the
2641 * file/line information and a backtrace.
2642 */
2643#define netdev_WARN(dev, format, args...) \
2644 WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
2645
Joe Perchesb3d95c52010-02-09 11:49:49 +00002646/* netif printk helpers, similar to netdev_printk */
2647
2648#define netif_printk(priv, type, level, dev, fmt, args...) \
2649do { \
2650 if (netif_msg_##type(priv)) \
2651 netdev_printk(level, (dev), fmt, ##args); \
2652} while (0)
2653
Joe Perchesf45f4322010-06-27 01:02:36 +00002654#define netif_level(level, priv, type, dev, fmt, args...) \
2655do { \
2656 if (netif_msg_##type(priv)) \
2657 netdev_##level(dev, fmt, ##args); \
2658} while (0)
2659
Joe Perchesb3d95c52010-02-09 11:49:49 +00002660#define netif_emerg(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002661 netif_level(emerg, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002662#define netif_alert(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002663 netif_level(alert, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002664#define netif_crit(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002665 netif_level(crit, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002666#define netif_err(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002667 netif_level(err, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002668#define netif_warn(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002669 netif_level(warn, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002670#define netif_notice(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002671 netif_level(notice, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002672#define netif_info(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002673 netif_level(info, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002674
2675#if defined(DEBUG)
2676#define netif_dbg(priv, type, dev, format, args...) \
2677 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
2678#elif defined(CONFIG_DYNAMIC_DEBUG)
2679#define netif_dbg(priv, type, netdev, format, args...) \
2680do { \
2681 if (netif_msg_##type(priv)) \
2682 dynamic_dev_dbg((netdev)->dev.parent, \
2683 "%s: " format, \
2684 netdev_name(netdev), ##args); \
2685} while (0)
2686#else
2687#define netif_dbg(priv, type, dev, format, args...) \
2688({ \
2689 if (0) \
2690 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
2691 0; \
2692})
2693#endif
2694
2695#if defined(VERBOSE_DEBUG)
Ben Hutchingsbcfcc452010-07-02 07:08:44 +00002696#define netif_vdbg netif_dbg
Joe Perchesb3d95c52010-02-09 11:49:49 +00002697#else
2698#define netif_vdbg(priv, type, dev, format, args...) \
2699({ \
2700 if (0) \
Ben Hutchingsa4ed89c2010-05-18 06:56:32 +00002701 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
Joe Perchesb3d95c52010-02-09 11:49:49 +00002702 0; \
2703})
2704#endif
Joe Perches571ba422010-02-09 11:49:47 +00002705
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706#endif /* __KERNEL__ */
2707
Jiri Pirko385a1542009-05-27 15:48:07 -07002708#endif /* _LINUX_NETDEVICE_H */