blob: 4d27368674db9bd5b706518f1fb6fc1ad680e46e [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>
Dmitri Vorobievcc0be322009-03-27 15:55:36 -070037#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <asm/atomic.h>
39#include <asm/cache.h>
40#include <asm/byteorder.h>
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/device.h>
43#include <linux/percpu.h>
David S. Miller4d5b78c2009-05-06 16:52:51 -070044#include <linux/rculist.h>
Chris Leechdb217332006-06-17 21:24:58 -070045#include <linux/dmaengine.h>
Stephen Hemmingerbea33482007-10-03 16:41:36 -070046#include <linux/workqueue.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Patrick McHardyb1b67dd2009-04-20 04:49:28 +000048#include <linux/ethtool.h>
Daniel Lezcanoa050c332007-09-12 14:57:09 +020049#include <net/net_namespace.h>
Lennert Buytenhekcf85d082008-10-07 13:45:02 +000050#include <net/dsa.h>
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -080051#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -080052#include <net/dcbnl.h>
53#endif
Daniel Lezcanoa050c332007-09-12 14:57:09 +020054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055struct vlan_group;
Jeff Moyer115c1d62005-06-22 22:05:31 -070056struct netpoll_info;
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
63#define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev
64 functions are available. */
65#define HAVE_FREE_NETDEV /* free_netdev() */
66#define HAVE_NETDEV_PRIV /* netdev_priv() */
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
Adrian Bunkc88e6f52008-06-27 19:54:54 -0700135#ifdef __KERNEL__
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136/*
137 * Compute the worst case header length according to the protocols
138 * used.
139 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800140
John W. Linvillecaf66e52010-02-25 12:02:45 -0500141#if defined(CONFIG_WLAN) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
David S. Miller8388e3d2008-05-12 20:17:33 -0700142# if defined(CONFIG_MAC80211_MESH)
143# define LL_MAX_HEADER 128
144# else
145# define LL_MAX_HEADER 96
146# endif
Adrian Bunkc759a6b2009-04-27 02:36:20 -0700147#elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
David S. Miller8388e3d2008-05-12 20:17:33 -0700148# define LL_MAX_HEADER 48
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#else
David S. Miller8388e3d2008-05-12 20:17:33 -0700150# define LL_MAX_HEADER 32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#endif
152
David S. Millere81c73592006-11-28 20:53:39 -0800153#if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
154 !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
155 !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
156 !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157#define MAX_HEADER LL_MAX_HEADER
158#else
159#define MAX_HEADER (LL_MAX_HEADER + 48)
160#endif
161
162/*
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000163 * Old network device statistics. Fields are native words
164 * (unsigned long) so they can be read and written atomically.
165 * Each field is padded to 64 bits for compatibility with
166 * rtnl_link_stats64.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800168
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000169#if BITS_PER_LONG == 64
170#define NET_DEVICE_STATS_DEFINE(name) unsigned long name
171#elif defined(__LITTLE_ENDIAN)
172#define NET_DEVICE_STATS_DEFINE(name) unsigned long name, pad_ ## name
173#else
174#define NET_DEVICE_STATS_DEFINE(name) unsigned long pad_ ## name, name
175#endif
176
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800177struct net_device_stats {
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000178 NET_DEVICE_STATS_DEFINE(rx_packets);
179 NET_DEVICE_STATS_DEFINE(tx_packets);
180 NET_DEVICE_STATS_DEFINE(rx_bytes);
181 NET_DEVICE_STATS_DEFINE(tx_bytes);
182 NET_DEVICE_STATS_DEFINE(rx_errors);
183 NET_DEVICE_STATS_DEFINE(tx_errors);
184 NET_DEVICE_STATS_DEFINE(rx_dropped);
185 NET_DEVICE_STATS_DEFINE(tx_dropped);
186 NET_DEVICE_STATS_DEFINE(multicast);
187 NET_DEVICE_STATS_DEFINE(collisions);
188 NET_DEVICE_STATS_DEFINE(rx_length_errors);
189 NET_DEVICE_STATS_DEFINE(rx_over_errors);
190 NET_DEVICE_STATS_DEFINE(rx_crc_errors);
191 NET_DEVICE_STATS_DEFINE(rx_frame_errors);
192 NET_DEVICE_STATS_DEFINE(rx_fifo_errors);
193 NET_DEVICE_STATS_DEFINE(rx_missed_errors);
194 NET_DEVICE_STATS_DEFINE(tx_aborted_errors);
195 NET_DEVICE_STATS_DEFINE(tx_carrier_errors);
196 NET_DEVICE_STATS_DEFINE(tx_fifo_errors);
197 NET_DEVICE_STATS_DEFINE(tx_heartbeat_errors);
198 NET_DEVICE_STATS_DEFINE(tx_window_errors);
199 NET_DEVICE_STATS_DEFINE(rx_compressed);
200 NET_DEVICE_STATS_DEFINE(tx_compressed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201};
202
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000203#endif /* __KERNEL__ */
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206/* Media selection options. */
207enum {
208 IF_PORT_UNKNOWN = 0,
209 IF_PORT_10BASE2,
210 IF_PORT_10BASET,
211 IF_PORT_AUI,
212 IF_PORT_100BASET,
213 IF_PORT_100BASETX,
214 IF_PORT_100BASEFX
215};
216
217#ifdef __KERNEL__
218
219#include <linux/cache.h>
220#include <linux/skbuff.h>
221
222struct neighbour;
223struct neigh_parms;
224struct sk_buff;
225
Jiri Pirkof001fde2009-05-05 02:48:28 +0000226struct netdev_hw_addr {
227 struct list_head list;
228 unsigned char addr[MAX_ADDR_LEN];
229 unsigned char type;
Jiri Pirkoccffad252009-05-22 23:22:17 +0000230#define NETDEV_HW_ADDR_T_LAN 1
231#define NETDEV_HW_ADDR_T_SAN 2
232#define NETDEV_HW_ADDR_T_SLAVE 3
233#define NETDEV_HW_ADDR_T_UNICAST 4
Jiri Pirko22bedad32010-04-01 21:22:57 +0000234#define NETDEV_HW_ADDR_T_MULTICAST 5
Jiri Pirkoccffad252009-05-22 23:22:17 +0000235 int refcount;
236 bool synced;
Jiri Pirko22bedad32010-04-01 21:22:57 +0000237 bool global_use;
Jiri Pirkof001fde2009-05-05 02:48:28 +0000238 struct rcu_head rcu_head;
239};
240
Jiri Pirko31278e72009-06-17 01:12:19 +0000241struct netdev_hw_addr_list {
242 struct list_head list;
243 int count;
244};
245
Jiri Pirko22bedad32010-04-01 21:22:57 +0000246#define netdev_hw_addr_list_count(l) ((l)->count)
247#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
248#define netdev_hw_addr_list_for_each(ha, l) \
249 list_for_each_entry(ha, &(l)->list, list)
250
251#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
252#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
Jiri Pirko32e7bfc2010-01-25 13:36:10 -0800253#define netdev_for_each_uc_addr(ha, dev) \
Jiri Pirko22bedad32010-04-01 21:22:57 +0000254 netdev_hw_addr_list_for_each(ha, &(dev)->uc)
Jiri Pirko32e7bfc2010-01-25 13:36:10 -0800255
Jiri Pirko22bedad32010-04-01 21:22:57 +0000256#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
257#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
Pavel Roskin18e225f2010-04-07 16:40:09 -0700258#define netdev_for_each_mc_addr(ha, dev) \
Jiri Pirko22bedad32010-04-01 21:22:57 +0000259 netdev_hw_addr_list_for_each(ha, &(dev)->mc)
Jiri Pirko6683ece2010-02-04 10:22:25 -0800260
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800261struct hh_cache {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 struct hh_cache *hh_next; /* Next entry */
263 atomic_t hh_refcnt; /* number of users */
Eric Dumazetf0490982006-12-08 00:08:43 -0800264/*
265 * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
266 * cache line on SMP.
267 * They are mostly read, but hh_refcnt may be changed quite frequently,
268 * incurring cache line ping pongs.
269 */
270 __be16 hh_type ____cacheline_aligned_in_smp;
271 /* protocol identifier, f.e ETH_P_IP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 * NOTE: For VLANs, this will be the
273 * encapuslated type. --BLG
274 */
Arnaldo Carvalho de Melod5c42c02006-11-27 17:58:02 -0200275 u16 hh_len; /* length of header */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 int (*hh_output)(struct sk_buff *skb);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800277 seqlock_t hh_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
279 /* cached hardware header; allow for machine alignment needs. */
280#define HH_DATA_MOD 16
281#define HH_DATA_OFF(__len) \
Jiri Benc5ba0eac2005-06-02 16:48:05 -0700282 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283#define HH_DATA_ALIGN(__len) \
284 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
285 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
286};
287
288/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
289 * Alternative is:
290 * dev->hard_header_len ? (dev->hard_header_len +
291 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
292 *
293 * We could use other alignment values, but we must maintain the
294 * relationship HH alignment <= LL alignment.
Johannes Bergf5184d22008-05-12 20:48:31 -0700295 *
296 * LL_ALLOCATED_SPACE also takes into account the tailroom the device
297 * may need.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 */
299#define LL_RESERVED_SPACE(dev) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700300 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700302 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
303#define LL_ALLOCATED_SPACE(dev) \
304 ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700306struct header_ops {
307 int (*create) (struct sk_buff *skb, struct net_device *dev,
308 unsigned short type, const void *daddr,
309 const void *saddr, unsigned len);
310 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
311 int (*rebuild)(struct sk_buff *skb);
312#define HAVE_HEADER_CACHE
313 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
314 void (*cache_update)(struct hh_cache *hh,
315 const struct net_device *dev,
316 const unsigned char *haddr);
317};
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319/* These flag bits are private to the generic network queueing
320 * layer, they may not be explicitly referenced by any other
321 * code.
322 */
323
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800324enum netdev_state_t {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 __LINK_STATE_START,
326 __LINK_STATE_PRESENT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 __LINK_STATE_NOCARRIER,
Stefan Rompfb00055a2006-03-20 17:09:11 -0800328 __LINK_STATE_LINKWATCH_PENDING,
329 __LINK_STATE_DORMANT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330};
331
332
333/*
334 * This structure holds at boot time configured netdevice settings. They
Graf Yangfe2918b2009-02-05 21:26:19 -0800335 * are then used in the device probing.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 */
337struct netdev_boot_setup {
338 char name[IFNAMSIZ];
339 struct ifmap map;
340};
341#define NETDEV_BOOT_SETUP_MAX 8
342
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -0300343extern int __init netdev_boot_setup(char *str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345/*
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700346 * Structure for NAPI scheduling similar to tasklet but with weighting
347 */
348struct napi_struct {
349 /* The poll_list must only be managed by the entity which
350 * changes the state of the NAPI_STATE_SCHED bit. This means
351 * whoever atomically sets that bit can add this napi_struct
352 * to the per-cpu poll_list, and whoever clears that bit
353 * can remove from the list right before clearing the bit.
354 */
355 struct list_head poll_list;
356
357 unsigned long state;
358 int weight;
359 int (*poll)(struct napi_struct *, int);
360#ifdef CONFIG_NETPOLL
361 spinlock_t poll_lock;
362 int poll_owner;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700363#endif
Herbert Xu4ae55442009-02-08 18:00:36 +0000364
365 unsigned int gro_count;
366
Herbert Xu5d38a072009-01-04 16:13:40 -0800367 struct net_device *dev;
Herbert Xud565b0a2008-12-15 23:38:52 -0800368 struct list_head dev_list;
369 struct sk_buff *gro_list;
Herbert Xu5d38a072009-01-04 16:13:40 -0800370 struct sk_buff *skb;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700371};
372
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800373enum {
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700374 NAPI_STATE_SCHED, /* Poll is scheduled */
David S. Millera0a46192008-01-07 20:35:07 -0800375 NAPI_STATE_DISABLE, /* Disable pending */
Neil Horman7b363e42008-12-09 23:22:26 -0800376 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700377};
378
Ben Hutchings5b252f02009-10-29 07:17:09 +0000379enum gro_result {
Herbert Xud1c76af2009-03-16 10:50:02 -0700380 GRO_MERGED,
381 GRO_MERGED_FREE,
382 GRO_HELD,
383 GRO_NORMAL,
384 GRO_DROP,
385};
Ben Hutchings5b252f02009-10-29 07:17:09 +0000386typedef enum gro_result gro_result_t;
Herbert Xud1c76af2009-03-16 10:50:02 -0700387
Jiri Pirkoab95bfe2010-06-01 21:52:08 +0000388typedef struct sk_buff *rx_handler_func_t(struct sk_buff *skb);
389
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800390extern void __napi_schedule(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700391
David S. Millera0a46192008-01-07 20:35:07 -0800392static inline int napi_disable_pending(struct napi_struct *n)
393{
394 return test_bit(NAPI_STATE_DISABLE, &n->state);
395}
396
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700397/**
398 * napi_schedule_prep - check if napi can be scheduled
399 * @n: napi context
400 *
401 * Test if NAPI routine is already running, and if not mark
402 * it as running. This is used as a condition variable
David S. Millera0a46192008-01-07 20:35:07 -0800403 * insure only one NAPI poll instance runs. We also make
404 * sure there is no pending NAPI disable.
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700405 */
406static inline int napi_schedule_prep(struct napi_struct *n)
407{
David S. Millera0a46192008-01-07 20:35:07 -0800408 return !napi_disable_pending(n) &&
409 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700410}
411
412/**
413 * napi_schedule - schedule NAPI poll
414 * @n: napi context
415 *
416 * Schedule NAPI poll routine to be called if it is not already
417 * running.
418 */
419static inline void napi_schedule(struct napi_struct *n)
420{
421 if (napi_schedule_prep(n))
422 __napi_schedule(n);
423}
424
Roland Dreierbfe13f52007-10-09 15:47:37 -0700425/* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
426static inline int napi_reschedule(struct napi_struct *napi)
427{
428 if (napi_schedule_prep(napi)) {
429 __napi_schedule(napi);
430 return 1;
431 }
432 return 0;
433}
434
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700435/**
436 * napi_complete - NAPI processing complete
437 * @n: napi context
438 *
439 * Mark NAPI processing as complete.
440 */
Herbert Xud565b0a2008-12-15 23:38:52 -0800441extern void __napi_complete(struct napi_struct *n);
442extern void napi_complete(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700443
444/**
445 * napi_disable - prevent NAPI from scheduling
446 * @n: napi context
447 *
448 * Stop NAPI from being scheduled on this context.
449 * Waits till any outstanding processing completes.
450 */
451static inline void napi_disable(struct napi_struct *n)
452{
David S. Millera0a46192008-01-07 20:35:07 -0800453 set_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700454 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
Benjamin Herrenschmidt43cc7382007-10-26 04:23:22 -0700455 msleep(1);
David S. Millera0a46192008-01-07 20:35:07 -0800456 clear_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700457}
458
459/**
460 * napi_enable - enable NAPI scheduling
461 * @n: napi context
462 *
463 * Resume NAPI from being scheduled on this context.
464 * Must be paired with napi_disable.
465 */
466static inline void napi_enable(struct napi_struct *n)
467{
468 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
469 smp_mb__before_clear_bit();
470 clear_bit(NAPI_STATE_SCHED, &n->state);
471}
472
Stephen Hemmingerc264c3d2007-10-17 13:26:41 -0700473#ifdef CONFIG_SMP
474/**
475 * napi_synchronize - wait until NAPI is not running
476 * @n: napi context
477 *
478 * Wait until NAPI is done being scheduled on this context.
479 * Waits till any outstanding processing completes but
480 * does not disable future activations.
481 */
482static inline void napi_synchronize(const struct napi_struct *n)
483{
484 while (test_bit(NAPI_STATE_SCHED, &n->state))
485 msleep(1);
486}
487#else
488# define napi_synchronize(n) barrier()
489#endif
490
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800491enum netdev_queue_state_t {
David S. Miller79d16382008-07-08 23:14:46 -0700492 __QUEUE_STATE_XOFF,
David S. Millerc3f26a22008-07-31 16:58:50 -0700493 __QUEUE_STATE_FROZEN,
David S. Miller79d16382008-07-08 23:14:46 -0700494};
495
David S. Millerbb949fb2008-07-08 16:55:56 -0700496struct netdev_queue {
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700497/*
498 * read mostly part
499 */
David S. Millerbb949fb2008-07-08 16:55:56 -0700500 struct net_device *dev;
David S. Millerb0e1e642008-07-08 17:42:10 -0700501 struct Qdisc *qdisc;
David S. Miller79d16382008-07-08 23:14:46 -0700502 unsigned long state;
David S. Millerb0e1e642008-07-08 17:42:10 -0700503 struct Qdisc *qdisc_sleeping;
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700504/*
505 * write mostly part
506 */
507 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
508 int xmit_lock_owner;
Eric Dumazet9d214932009-05-17 20:55:16 -0700509 /*
510 * please use this field instead of dev->trans_start
511 */
512 unsigned long trans_start;
Eric Dumazet7004bf22009-05-18 00:34:33 +0000513 unsigned long tx_bytes;
514 unsigned long tx_packets;
515 unsigned long tx_dropped;
David S. Millere8a04642008-07-17 00:34:19 -0700516} ____cacheline_aligned_in_smp;
David S. Millerbb949fb2008-07-08 16:55:56 -0700517
Eric Dumazetdf334542010-03-24 19:13:54 +0000518#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000519/*
520 * This structure holds an RPS map which can be of variable length. The
521 * map is an array of CPUs.
522 */
523struct rps_map {
524 unsigned int len;
525 struct rcu_head rcu;
526 u16 cpus[0];
527};
528#define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + (_num * sizeof(u16)))
529
Tom Herbertfec5e652010-04-16 16:01:27 -0700530/*
531 * The rps_dev_flow structure contains the mapping of a flow to a CPU and the
532 * tail pointer for that CPU's input queue at the time of last enqueue.
533 */
534struct rps_dev_flow {
535 u16 cpu;
536 u16 fill;
537 unsigned int last_qtail;
538};
539
540/*
541 * The rps_dev_flow_table structure contains a table of flow mappings.
542 */
543struct rps_dev_flow_table {
544 unsigned int mask;
545 struct rcu_head rcu;
546 struct work_struct free_work;
547 struct rps_dev_flow flows[0];
548};
549#define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
550 (_num * sizeof(struct rps_dev_flow)))
551
552/*
553 * The rps_sock_flow_table contains mappings of flows to the last CPU
554 * on which they were processed by the application (set in recvmsg).
555 */
556struct rps_sock_flow_table {
557 unsigned int mask;
558 u16 ents[0];
559};
560#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
561 (_num * sizeof(u16)))
562
563#define RPS_NO_CPU 0xffff
564
565static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
566 u32 hash)
567{
568 if (table && hash) {
569 unsigned int cpu, index = hash & table->mask;
570
571 /* We only give a hint, preemption can change cpu under us */
572 cpu = raw_smp_processor_id();
573
574 if (table->ents[index] != cpu)
575 table->ents[index] = cpu;
576 }
577}
578
579static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
580 u32 hash)
581{
582 if (table && hash)
583 table->ents[hash & table->mask] = RPS_NO_CPU;
584}
585
586extern struct rps_sock_flow_table *rps_sock_flow_table;
587
Tom Herbert0a9627f2010-03-16 08:03:29 +0000588/* This structure contains an instance of an RX queue. */
589struct netdev_rx_queue {
590 struct rps_map *rps_map;
Tom Herbertfec5e652010-04-16 16:01:27 -0700591 struct rps_dev_flow_table *rps_flow_table;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000592 struct kobject kobj;
593 struct netdev_rx_queue *first;
594 atomic_t count;
595} ____cacheline_aligned_in_smp;
Tom Herbertfec5e652010-04-16 16:01:27 -0700596#endif /* CONFIG_RPS */
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800597
598/*
599 * This structure defines the management hooks for network devices.
Stephen Hemminger00829822008-11-20 20:14:53 -0800600 * The following hooks can be defined; unless noted otherwise, they are
601 * optional and can be filled with a null pointer.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800602 *
603 * int (*ndo_init)(struct net_device *dev);
604 * This function is called once when network device is registered.
605 * The network device can use this to any late stage initializaton
606 * or semantic validattion. It can fail with an error code which will
607 * be propogated back to register_netdev
608 *
609 * void (*ndo_uninit)(struct net_device *dev);
610 * This function is called when device is unregistered or when registration
611 * fails. It is not called if init fails.
612 *
613 * int (*ndo_open)(struct net_device *dev);
614 * This function is called when network device transistions to the up
615 * state.
616 *
617 * int (*ndo_stop)(struct net_device *dev);
618 * This function is called when network device transistions to the down
619 * state.
620 *
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000621 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
622 * struct net_device *dev);
Stephen Hemminger00829822008-11-20 20:14:53 -0800623 * Called when a packet needs to be transmitted.
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000624 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
625 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
Stephen Hemminger00829822008-11-20 20:14:53 -0800626 * Required can not be NULL.
627 *
628 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
629 * Called to decide which queue to when device supports multiple
630 * transmit queues.
631 *
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800632 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
633 * This function is called to allow device receiver to make
634 * changes to configuration when multicast or promiscious is enabled.
635 *
636 * void (*ndo_set_rx_mode)(struct net_device *dev);
637 * This function is called device changes address list filtering.
638 *
639 * void (*ndo_set_multicast_list)(struct net_device *dev);
640 * This function is called when the multicast address list changes.
641 *
642 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
643 * This function is called when the Media Access Control address
Mike Rapoport37b607c2009-04-27 05:45:54 -0700644 * needs to be changed. If this interface is not defined, the
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800645 * mac address can not be changed.
646 *
647 * int (*ndo_validate_addr)(struct net_device *dev);
648 * Test if Media Access Control address is valid for the device.
649 *
650 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
651 * Called when a user request an ioctl which can't be handled by
652 * the generic interface code. If not defined ioctl's return
653 * not supported error code.
654 *
655 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
656 * Used to set network devices bus interface parameters. This interface
657 * is retained for legacy reason, new devices should use the bus
658 * interface (PCI) for low level management.
659 *
660 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
661 * Called when a user wants to change the Maximum Transfer Unit
662 * of a device. If not defined, any request to change MTU will
663 * will return an error.
664 *
Stephen Hemminger00829822008-11-20 20:14:53 -0800665 * void (*ndo_tx_timeout)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800666 * Callback uses when the transmitter has not made any progress
667 * for dev->watchdog ticks.
668 *
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000669 * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev);
Wolfram Sangd308e382009-10-07 13:53:11 -0700670 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800671 * Called when a user wants to get the network device usage
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000672 * statistics. Drivers must do one of the following:
673 * 1. Define @ndo_get_stats64 to update a rtnl_link_stats64 structure
674 * (which should normally be dev->stats64) and return a ponter to
675 * it. The structure must not be changed asynchronously.
Ben Hutchings82695d92010-06-15 15:08:48 -0700676 * 2. Define @ndo_get_stats to update a net_device_stats structure
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000677 * (which should normally be dev->stats) and return a pointer to
678 * it. The structure may be changed asynchronously only if each
679 * field is written atomically.
680 * 3. Update dev->stats asynchronously and atomically, and define
681 * neither operation.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800682 *
683 * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
684 * If device support VLAN receive accleration
685 * (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
686 * when vlan groups for the device changes. Note: grp is NULL
687 * if no vlan's groups are being used.
688 *
689 * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
690 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
691 * this function is called when a VLAN id is registered.
692 *
693 * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
694 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
695 * this function is called when a VLAN id is unregistered.
696 *
697 * void (*ndo_poll_controller)(struct net_device *dev);
Williams, Mitch A95c26df2010-02-10 01:43:46 +0000698 *
699 * SR-IOV management functions.
700 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
701 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
702 * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate);
703 * int (*ndo_get_vf_config)(struct net_device *dev,
704 * int vf, struct ifla_vf_info *ivf);
Scott Feldman57b61082010-05-17 22:49:55 -0700705 * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
706 * struct nlattr *port[]);
707 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800708 */
Stephen Hemminger47fd5b82008-11-25 00:20:43 -0800709#define HAVE_NET_DEVICE_OPS
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800710struct net_device_ops {
711 int (*ndo_init)(struct net_device *dev);
712 void (*ndo_uninit)(struct net_device *dev);
713 int (*ndo_open)(struct net_device *dev);
714 int (*ndo_stop)(struct net_device *dev);
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000715 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,
Stephen Hemminger00829822008-11-20 20:14:53 -0800716 struct net_device *dev);
717 u16 (*ndo_select_queue)(struct net_device *dev,
718 struct sk_buff *skb);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800719 void (*ndo_change_rx_flags)(struct net_device *dev,
720 int flags);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800721 void (*ndo_set_rx_mode)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800722 void (*ndo_set_multicast_list)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800723 int (*ndo_set_mac_address)(struct net_device *dev,
724 void *addr);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800725 int (*ndo_validate_addr)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800726 int (*ndo_do_ioctl)(struct net_device *dev,
727 struct ifreq *ifr, int cmd);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800728 int (*ndo_set_config)(struct net_device *dev,
729 struct ifmap *map);
Stephen Hemminger00829822008-11-20 20:14:53 -0800730 int (*ndo_change_mtu)(struct net_device *dev,
731 int new_mtu);
732 int (*ndo_neigh_setup)(struct net_device *dev,
733 struct neigh_parms *);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800734 void (*ndo_tx_timeout) (struct net_device *dev);
735
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000736 struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800737 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
738
739 void (*ndo_vlan_rx_register)(struct net_device *dev,
740 struct vlan_group *grp);
741 void (*ndo_vlan_rx_add_vid)(struct net_device *dev,
742 unsigned short vid);
743 void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
744 unsigned short vid);
745#ifdef CONFIG_NET_POLL_CONTROLLER
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800746 void (*ndo_poll_controller)(struct net_device *dev);
Herbert Xu4247e162010-06-10 16:12:47 +0000747 int (*ndo_netpoll_setup)(struct net_device *dev,
748 struct netpoll_info *info);
WANG Cong0e34e932010-05-06 00:47:21 -0700749 void (*ndo_netpoll_cleanup)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800750#endif
Williams, Mitch A95c26df2010-02-10 01:43:46 +0000751 int (*ndo_set_vf_mac)(struct net_device *dev,
752 int queue, u8 *mac);
753 int (*ndo_set_vf_vlan)(struct net_device *dev,
754 int queue, u16 vlan, u8 qos);
755 int (*ndo_set_vf_tx_rate)(struct net_device *dev,
756 int vf, int rate);
757 int (*ndo_get_vf_config)(struct net_device *dev,
758 int vf,
759 struct ifla_vf_info *ivf);
Scott Feldman57b61082010-05-17 22:49:55 -0700760 int (*ndo_set_vf_port)(struct net_device *dev,
761 int vf,
762 struct nlattr *port[]);
763 int (*ndo_get_vf_port)(struct net_device *dev,
764 int vf, struct sk_buff *skb);
Yi Zou4d288d52009-02-27 14:06:59 -0800765#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
Yi Zoucb454392009-08-31 12:31:36 +0000766 int (*ndo_fcoe_enable)(struct net_device *dev);
767 int (*ndo_fcoe_disable)(struct net_device *dev);
Yi Zou4d288d52009-02-27 14:06:59 -0800768 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
769 u16 xid,
770 struct scatterlist *sgl,
771 unsigned int sgc);
772 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
773 u16 xid);
Yi Zoudf5c7942009-10-28 18:24:35 +0000774#define NETDEV_FCOE_WWNN 0
775#define NETDEV_FCOE_WWPN 1
776 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
777 u64 *wwn, int type);
Yi Zou4d288d52009-02-27 14:06:59 -0800778#endif
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800779};
780
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700781/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 * The DEVICE structure.
783 * Actually, this whole structure is a big mistake. It mixes I/O
784 * data with strictly "high-level" data, and it has to know about
785 * almost every data structure used in the INET module.
786 *
787 * FIXME: cleanup struct net_device such that network protocol info
788 * moves out.
789 */
790
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800791struct net_device {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 /*
794 * This is the first field of the "visible" part of this structure
795 * (i.e. as seen by users in the "Space.c" file). It is the name
796 * the interface.
797 */
798 char name[IFNAMSIZ];
Mark Grossed771342010-05-06 01:59:26 +0200799
800 struct pm_qos_request_list *pm_qos_req;
801
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700802 /* device name hash chain */
803 struct hlist_node name_hlist;
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700804 /* snmp alias */
805 char *ifalias;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
807 /*
808 * I/O specific fields
809 * FIXME: Merge these and struct ifmap into one
810 */
811 unsigned long mem_end; /* shared mem end */
812 unsigned long mem_start; /* shared mem start */
813 unsigned long base_addr; /* device I/O address */
814 unsigned int irq; /* device IRQ number */
815
816 /*
817 * Some hardware also needs these fields, but they are not
818 * part of the usual set specified in Space.c.
819 */
820
821 unsigned char if_port; /* Selectable AUI, TP,..*/
822 unsigned char dma; /* DMA channel */
823
824 unsigned long state;
825
Pavel Emelianov7562f872007-05-03 15:13:45 -0700826 struct list_head dev_list;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700827 struct list_head napi_list;
Eric Dumazet44a08732009-10-27 07:03:04 +0000828 struct list_head unreg_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700830 /* Net device features */
831 unsigned long features;
832#define NETIF_F_SG 1 /* Scatter/gather IO. */
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700833#define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700834#define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
835#define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700836#define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700837#define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
838#define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
839#define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
840#define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
841#define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
842#define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
Herbert Xu37c31852006-06-22 03:07:29 -0700843#define NETIF_F_GSO 2048 /* Enable software GSO. */
Christian Borntraegere24eb522007-09-25 19:42:02 -0700844#define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */
845 /* do not use LLTX in new drivers */
Eric W. Biedermance286d32007-09-12 13:53:49 +0200846#define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */
Herbert Xud565b0a2008-12-15 23:38:52 -0800847#define NETIF_F_GRO 16384 /* Generic receive offload */
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700848#define NETIF_F_LRO 32768 /* large receive offload */
Herbert Xu79671682006-06-22 02:40:14 -0700849
Jesse Brandeburg8dc92f72009-04-27 22:35:52 +0000850/* the GSO_MASK reserves bits 16 through 23 */
Chris Leech01d5b2f2009-02-27 14:06:49 -0800851#define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */
Jesse Brandeburg8dc92f72009-04-27 22:35:52 +0000852#define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */
Yi Zoubb2af4f2009-08-14 12:41:57 +0000853#define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800854#define NETIF_F_NTUPLE (1 << 27) /* N-tuple filters supported */
stephen hemmingerb00fabb2010-03-29 14:47:27 +0000855#define NETIF_F_RXHASH (1 << 28) /* Receive hashing offload */
Chris Leech01d5b2f2009-02-27 14:06:49 -0800856
Herbert Xu79671682006-06-22 02:40:14 -0700857 /* Segmentation offload features */
Patrick McHardy289c79a2008-05-23 00:22:04 -0700858#define NETIF_F_GSO_SHIFT 16
Chris Leech43eb99c2009-02-27 14:06:43 -0800859#define NETIF_F_GSO_MASK 0x00ff0000
Herbert Xu79671682006-06-22 02:40:14 -0700860#define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700861#define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
Herbert Xu576a30e2006-06-27 13:22:38 -0700862#define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700863#define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
864#define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
Chris Leech01d5b2f2009-02-27 14:06:49 -0800865#define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700866
Herbert Xu78eb8872006-08-17 18:22:32 -0700867 /* List of features with software fallbacks. */
Herbert Xud29c0c52010-06-14 20:21:04 +0000868#define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | \
869 NETIF_F_TSO6 | NETIF_F_UFO)
Herbert Xu78eb8872006-08-17 18:22:32 -0700870
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700871
Herbert Xu8648b302006-06-17 22:06:05 -0700872#define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700873#define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
874#define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
875#define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
Herbert Xu8648b302006-06-17 22:06:05 -0700876
Herbert Xub63365a2008-10-23 01:11:29 -0700877 /*
878 * If one device supports one of these features, then enable them
879 * for all in netdev_increment_features.
880 */
881#define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800882 NETIF_F_SG | NETIF_F_HIGHDMA | \
Herbert Xub63365a2008-10-23 01:11:29 -0700883 NETIF_F_FRAGLIST)
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 /* Interface index. Unique device identifier */
886 int ifindex;
887 int iflink;
888
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000889 union {
890 struct rtnl_link_stats64 stats64;
891 struct net_device_stats stats;
892 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
Johannes Bergb86e0282007-04-26 20:48:23 -0700894#ifdef CONFIG_WIRELESS_EXT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 /* List of functions to handle Wireless Extensions (instead of ioctl).
896 * See <net/iw_handler.h> for details. Jean II */
897 const struct iw_handler_def * wireless_handlers;
898 /* Instance data managed by the core of Wireless Extensions. */
899 struct iw_public_data * wireless_data;
Johannes Bergb86e0282007-04-26 20:48:23 -0700900#endif
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800901 /* Management operations */
902 const struct net_device_ops *netdev_ops;
Stephen Hemminger76fd8592006-09-08 11:16:13 -0700903 const struct ethtool_ops *ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700905 /* Hardware header description */
906 const struct header_ops *header_ops;
907
Stefan Rompfb00055a2006-03-20 17:09:11 -0800908 unsigned int flags; /* interface flags (a la BSD) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 unsigned short gflags;
910 unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */
911 unsigned short padded; /* How much padding added by alloc_netdev() */
912
Stefan Rompfb00055a2006-03-20 17:09:11 -0800913 unsigned char operstate; /* RFC2863 operstate */
914 unsigned char link_mode; /* mapping policy to operstate */
915
David S. Millercd7b5392010-05-02 22:27:59 -0700916 unsigned int mtu; /* interface MTU value */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 unsigned short type; /* interface hardware type */
918 unsigned short hard_header_len; /* hardware hdr length */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
Johannes Bergf5184d22008-05-12 20:48:31 -0700920 /* extra head- and tailroom the hardware may need, but not in all cases
921 * can this be guaranteed, especially tailroom. Some cases also use
922 * LL_MAX_HEADER instead to allocate the skb.
923 */
924 unsigned short needed_headroom;
925 unsigned short needed_tailroom;
926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 struct net_device *master; /* Pointer to master device of a group,
928 * which this device is member of.
929 */
930
931 /* Interface address info. */
Jon Wetzela6f9a702005-08-20 17:15:54 -0700932 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 unsigned char addr_len; /* hardware address length */
934 unsigned short dev_id; /* for shared network cards */
935
Jiri Pirkoccffad252009-05-22 23:22:17 +0000936 spinlock_t addr_list_lock;
Jiri Pirko22bedad32010-04-01 21:22:57 +0000937 struct netdev_hw_addr_list uc; /* Unicast mac addresses */
938 struct netdev_hw_addr_list mc; /* Multicast mac addresses */
939 int uc_promisc;
Wang Chen9d45abe2008-06-17 21:12:48 -0700940 unsigned int promiscuity;
941 unsigned int allmulti;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
944 /* Protocol specific pointers */
945
Lennert Buytenhek91da11f2008-10-07 13:44:02 +0000946#ifdef CONFIG_NET_DSA
947 void *dsa_ptr; /* dsa specific data */
948#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 void *atalk_ptr; /* AppleTalk link */
Graf Yangfe2918b2009-02-05 21:26:19 -0800950 void *ip_ptr; /* IPv4 specific data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 void *dn_ptr; /* DECnet specific data */
952 void *ip6_ptr; /* IPv6 specific data */
953 void *ec_ptr; /* Econet specific data */
954 void *ax25_ptr; /* AX.25 specific data */
Johannes Berg704232c2007-04-23 12:20:05 -0700955 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
956 assign before registering */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700958/*
959 * Cache line mostly used on receive path (including eth_type_trans())
960 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700961 unsigned long last_rx; /* Time of last Rx */
962 /* Interface address info used in eth_type_trans() */
Jiri Pirkof001fde2009-05-05 02:48:28 +0000963 unsigned char *dev_addr; /* hw address, (before bcast
964 because most packets are
965 unicast) */
966
Jiri Pirko31278e72009-06-17 01:12:19 +0000967 struct netdev_hw_addr_list dev_addrs; /* list of device
968 hw addresses */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700970 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
971
Eric Dumazetdf334542010-03-24 19:13:54 +0000972#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000973 struct kset *queues_kset;
974
975 struct netdev_rx_queue *_rx;
976
977 /* Number of RX queues allocated at alloc_netdev_mq() time */
978 unsigned int num_rx_queues;
Eric Dumazetdf334542010-03-24 19:13:54 +0000979#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +0000980
David S. Millerbb949fb2008-07-08 16:55:56 -0700981 struct netdev_queue rx_queue;
Jiri Pirkoab95bfe2010-06-01 21:52:08 +0000982 rx_handler_func_t *rx_handler;
Jiri Pirko93e2c322010-06-10 03:34:59 +0000983 void *rx_handler_data;
David S. Millere8a04642008-07-17 00:34:19 -0700984
985 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700986
987 /* Number of TX queues allocated at alloc_netdev_mq() time */
David S. Millere8a04642008-07-17 00:34:19 -0700988 unsigned int num_tx_queues;
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700989
990 /* Number of TX queues currently active in device */
991 unsigned int real_num_tx_queues;
992
Patrick McHardyaf356af2009-09-04 06:41:18 +0000993 /* root qdisc from userspace point of view */
994 struct Qdisc *qdisc;
995
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 unsigned long tx_queue_len; /* Max frames per queue allowed */
David S. Millerc3f26a22008-07-31 16:58:50 -0700997 spinlock_t tx_global_lock;
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700998/*
999 * One part is mostly used on xmit path (device)
1000 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001001 /* These may be needed for future network-power-down code. */
Eric Dumazet9d214932009-05-17 20:55:16 -07001002
1003 /*
1004 * trans_start here is expensive for high speed devices on SMP,
1005 * please use netdev_queue->trans_start instead.
1006 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001007 unsigned long trans_start; /* Time (in jiffies) of last Tx */
1008
1009 int watchdog_timeo; /* used by dev_watchdog() */
1010 struct timer_list watchdog_timer;
1011
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 /* Number of references to this device */
Eric Dumazet9356b8f2005-09-27 15:23:16 -07001013 atomic_t refcnt ____cacheline_aligned_in_smp;
1014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 /* delayed register/unregister */
1016 struct list_head todo_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 /* device index hash chain */
1018 struct hlist_node index_hlist;
1019
Eric Dumazete014deb2009-11-17 05:59:21 +00001020 struct list_head link_watch_list;
Herbert Xu572a1032007-05-08 18:34:17 -07001021
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 /* register/unregister state machine */
1023 enum { NETREG_UNINITIALIZED=0,
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07001024 NETREG_REGISTERED, /* completed register_netdevice */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 NETREG_UNREGISTERING, /* called unregister_netdevice */
1026 NETREG_UNREGISTERED, /* completed unregister todo */
1027 NETREG_RELEASED, /* called free_netdev */
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001028 NETREG_DUMMY, /* dummy device for NAPI poll */
Patrick McHardya2835762010-02-26 06:34:51 +00001029 } reg_state:16;
1030
1031 enum {
1032 RTNL_LINK_INITIALIZED,
1033 RTNL_LINK_INITIALIZING,
1034 } rtnl_link_state:16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001036 /* Called from unregister, can be used to call free_netdev */
1037 void (*destructor)(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039#ifdef CONFIG_NETPOLL
Jeff Moyer115c1d62005-06-22 22:05:31 -07001040 struct netpoll_info *npinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041#endif
David S. Millereae792b2008-07-15 03:03:33 -07001042
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001043#ifdef CONFIG_NET_NS
Eric W. Biederman4a1c5372007-09-12 11:56:32 +02001044 /* Network namespace this network device is inside */
1045 struct net *nd_net;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001046#endif
Eric W. Biederman4a1c5372007-09-12 11:56:32 +02001047
David S. Miller49517042008-05-12 03:29:11 -07001048 /* mid-layer private */
1049 void *ml_priv;
1050
Patrick McHardyeca9eba2008-07-05 21:26:13 -07001051 /* GARP */
1052 struct garp_port *garp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 /* class/net/name entry */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001055 struct device dev;
Eric W. Biederman0c509a62009-10-29 14:18:21 +00001056 /* space for optional device, statistics, and wireless sysfs groups */
1057 const struct attribute_group *sysfs_groups[4];
Patrick McHardy38f7b872007-06-13 12:03:51 -07001058
1059 /* rtnetlink link ops */
1060 const struct rtnl_link_ops *rtnl_link_ops;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001061
Patrick McHardy289c79a2008-05-23 00:22:04 -07001062 /* VLAN feature mask */
1063 unsigned long vlan_features;
1064
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001065 /* for setting kernel sock attribute on TCP connection setup */
1066#define GSO_MAX_SIZE 65536
1067 unsigned int gso_max_size;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001068
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -08001069#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -08001070 /* Data Center Bridging netlink ops */
Stephen Hemminger32953542009-10-05 06:01:03 +00001071 const struct dcbnl_rtnl_ops *dcbnl_ops;
Alexander Duyck2f90b862008-11-20 20:52:10 -08001072#endif
1073
Yi Zou4d288d52009-02-27 14:06:59 -08001074#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
1075 /* max exchange id for FCoE LRO by ddp */
1076 unsigned int fcoe_ddp_xid;
1077#endif
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001078 /* n-tuple filter list attached to this device */
1079 struct ethtool_rx_ntuple_list ethtool_ntuple_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080};
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001081#define to_net_dev(d) container_of(d, struct net_device, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
1083#define NETDEV_ALIGN 32
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
David S. Millere8a04642008-07-17 00:34:19 -07001085static inline
1086struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
1087 unsigned int index)
1088{
1089 return &dev->_tx[index];
1090}
1091
1092static inline void netdev_for_each_tx_queue(struct net_device *dev,
1093 void (*f)(struct net_device *,
1094 struct netdev_queue *,
1095 void *),
1096 void *arg)
1097{
1098 unsigned int i;
1099
1100 for (i = 0; i < dev->num_tx_queues; i++)
1101 f(dev, &dev->_tx[i], arg);
1102}
1103
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001104/*
1105 * Net namespace inlines
1106 */
1107static inline
1108struct net *dev_net(const struct net_device *dev)
1109{
Eric Dumazetc2d9ba92010-06-01 06:51:19 +00001110 return read_pnet(&dev->nd_net);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001111}
1112
1113static inline
Denis V. Lunevf5aa23f2008-03-26 00:48:17 -07001114void dev_net_set(struct net_device *dev, struct net *net)
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001115{
1116#ifdef CONFIG_NET_NS
Denis V. Lunevf3005d72008-04-16 02:02:18 -07001117 release_net(dev->nd_net);
1118 dev->nd_net = hold_net(net);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001119#endif
1120}
1121
Lennert Buytenhekcf85d082008-10-07 13:45:02 +00001122static inline bool netdev_uses_dsa_tags(struct net_device *dev)
1123{
1124#ifdef CONFIG_NET_DSA_TAG_DSA
1125 if (dev->dsa_ptr != NULL)
1126 return dsa_uses_dsa_tags(dev->dsa_ptr);
1127#endif
1128
1129 return 0;
1130}
1131
Arnd Bergmann8a83a002010-01-30 12:23:03 +00001132#ifndef CONFIG_NET_NS
1133static inline void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
1134{
1135 skb->dev = dev;
1136}
1137#else /* CONFIG_NET_NS */
1138void skb_set_dev(struct sk_buff *skb, struct net_device *dev);
1139#endif
1140
Lennert Buytenhek396138f02008-10-07 13:46:07 +00001141static inline bool netdev_uses_trailer_tags(struct net_device *dev)
1142{
1143#ifdef CONFIG_NET_DSA_TAG_TRAILER
1144 if (dev->dsa_ptr != NULL)
1145 return dsa_uses_trailer_tags(dev->dsa_ptr);
1146#endif
1147
1148 return 0;
1149}
1150
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001151/**
1152 * netdev_priv - access network device private data
1153 * @dev: network device
1154 *
1155 * Get network device private data
1156 */
Patrick McHardy6472ce62007-06-13 12:03:21 -07001157static inline void *netdev_priv(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158{
Eric Dumazet1ce8e7b2009-05-27 04:42:37 +00001159 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160}
1161
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162/* Set the sysfs physical device reference for the network logical device
1163 * if set prior to registration will cause a symlink during initialization.
1164 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001165#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
Marcel Holtmann384912e2009-08-31 21:08:19 +00001167/* Set the sysfs device type for the network logical device to allow
1168 * fin grained indentification of different network device types. For
1169 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
1170 */
1171#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
1172
Stephen Hemminger3b582cc2007-11-01 02:21:47 -07001173/**
1174 * netif_napi_add - initialize a napi context
1175 * @dev: network device
1176 * @napi: napi context
1177 * @poll: polling function
1178 * @weight: default weight
1179 *
1180 * netif_napi_add() must be used to initialize a napi context prior to calling
1181 * *any* of the other napi related functions.
1182 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001183void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
1184 int (*poll)(struct napi_struct *, int), int weight);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001185
Alexander Duyckd8156532008-07-08 15:13:05 -07001186/**
1187 * netif_napi_del - remove a napi context
1188 * @napi: napi context
1189 *
1190 * netif_napi_del() removes a napi context from the network device napi list
1191 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001192void netif_napi_del(struct napi_struct *napi);
1193
1194struct napi_gro_cb {
Herbert Xu78a478d2009-05-26 18:50:21 +00001195 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
1196 void *frag0;
1197
Herbert Xu74895942009-05-26 18:50:27 +00001198 /* Length of frag0. */
1199 unsigned int frag0_len;
1200
Herbert Xu86911732009-01-29 14:19:50 +00001201 /* This indicates where we are processing relative to skb->data. */
1202 int data_offset;
1203
Herbert Xud565b0a2008-12-15 23:38:52 -08001204 /* This is non-zero if the packet may be of the same flow. */
1205 int same_flow;
1206
1207 /* This is non-zero if the packet cannot be merged with the new skb. */
1208 int flush;
1209
1210 /* Number of segments aggregated. */
1211 int count;
Herbert Xu5d38a072009-01-04 16:13:40 -08001212
1213 /* Free the skb? */
1214 int free;
Herbert Xud565b0a2008-12-15 23:38:52 -08001215};
1216
1217#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
Alexander Duyckd8156532008-07-08 15:13:05 -07001218
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219struct packet_type {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001220 __be16 type; /* This is really htons(ether_type). */
1221 struct net_device *dev; /* NULL is wildcarded here */
1222 int (*func) (struct sk_buff *,
1223 struct net_device *,
1224 struct packet_type *,
1225 struct net_device *);
Herbert Xu576a30e2006-06-27 13:22:38 -07001226 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
1227 int features);
Herbert Xua430a432006-07-08 13:34:56 -07001228 int (*gso_send_check)(struct sk_buff *skb);
Herbert Xud565b0a2008-12-15 23:38:52 -08001229 struct sk_buff **(*gro_receive)(struct sk_buff **head,
1230 struct sk_buff *skb);
1231 int (*gro_complete)(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 void *af_packet_priv;
1233 struct list_head list;
1234};
1235
1236#include <linux/interrupt.h>
1237#include <linux/notifier.h>
1238
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239extern rwlock_t dev_base_lock; /* Device list lock */
1240
Eric W. Biederman881d9662007-09-17 11:56:21 -07001241
1242#define for_each_netdev(net, d) \
1243 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
Eric W. Biedermandcbccbd42009-11-29 22:25:26 +00001244#define for_each_netdev_reverse(net, d) \
1245 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001246#define for_each_netdev_rcu(net, d) \
1247 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
Eric W. Biederman881d9662007-09-17 11:56:21 -07001248#define for_each_netdev_safe(net, d, n) \
1249 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
1250#define for_each_netdev_continue(net, d) \
1251 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
stephen hemminger254245d2009-11-10 07:54:47 +00001252#define for_each_netdev_continue_rcu(net, d) \
1253 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001254#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
1255
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001256static inline struct net_device *next_net_device(struct net_device *dev)
1257{
1258 struct list_head *lh;
1259 struct net *net;
Pavel Emelianov7562f872007-05-03 15:13:45 -07001260
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001261 net = dev_net(dev);
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001262 lh = dev->dev_list.next;
1263 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1264}
1265
Eric Dumazetce81b762009-11-11 17:34:30 +00001266static inline struct net_device *next_net_device_rcu(struct net_device *dev)
1267{
1268 struct list_head *lh;
1269 struct net *net;
1270
1271 net = dev_net(dev);
1272 lh = rcu_dereference(dev->dev_list.next);
1273 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1274}
1275
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001276static inline struct net_device *first_net_device(struct net *net)
1277{
1278 return list_empty(&net->dev_base_head) ? NULL :
1279 net_device_entry(net->dev_base_head.next);
1280}
Pavel Emelianov7562f872007-05-03 15:13:45 -07001281
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282extern int netdev_boot_setup_check(struct net_device *dev);
1283extern unsigned long netdev_boot_base(const char *prefix, int unit);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001284extern struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);
1285extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
1286extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287extern void dev_add_pack(struct packet_type *pt);
1288extern void dev_remove_pack(struct packet_type *pt);
1289extern void __dev_remove_pack(struct packet_type *pt);
1290
Eric Dumazetbb69ae02010-06-07 11:42:13 +00001291extern struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags,
1292 unsigned short mask);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001293extern struct net_device *dev_get_by_name(struct net *net, const char *name);
Eric Dumazet72c95282009-10-30 07:11:27 +00001294extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001295extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296extern int dev_alloc_name(struct net_device *dev, const char *name);
1297extern int dev_open(struct net_device *dev);
1298extern int dev_close(struct net_device *dev);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001299extern void dev_disable_lro(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300extern int dev_queue_xmit(struct sk_buff *skb);
1301extern int register_netdevice(struct net_device *dev);
Eric Dumazet44a08732009-10-27 07:03:04 +00001302extern void unregister_netdevice_queue(struct net_device *dev,
1303 struct list_head *head);
Eric Dumazet9b5e3832009-10-27 07:04:19 +00001304extern void unregister_netdevice_many(struct list_head *head);
Eric Dumazet44a08732009-10-27 07:03:04 +00001305static inline void unregister_netdevice(struct net_device *dev)
1306{
1307 unregister_netdevice_queue(dev, NULL);
1308}
1309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310extern void free_netdev(struct net_device *dev);
1311extern void synchronize_net(void);
1312extern int register_netdevice_notifier(struct notifier_block *nb);
1313extern int unregister_netdevice_notifier(struct notifier_block *nb);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001314extern int init_dummy_netdev(struct net_device *dev);
David S. Miller9d40bbd2009-03-04 23:46:25 -08001315extern void netdev_resync_ops(struct net_device *dev);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001316
Eric W. Biedermanad7379d2007-09-16 15:33:32 -07001317extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001318extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
1319extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
Eric Dumazetfb699dfd2009-10-19 19:18:49 +00001320extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321extern int dev_restart(struct net_device *dev);
1322#ifdef CONFIG_NETPOLL_TRAP
1323extern int netpoll_trap(void);
1324#endif
Herbert Xu86911732009-01-29 14:19:50 +00001325extern int skb_gro_receive(struct sk_buff **head,
1326 struct sk_buff *skb);
Herbert Xu78a478d2009-05-26 18:50:21 +00001327extern void skb_gro_reset_offset(struct sk_buff *skb);
Herbert Xu86911732009-01-29 14:19:50 +00001328
1329static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
1330{
1331 return NAPI_GRO_CB(skb)->data_offset;
1332}
1333
1334static inline unsigned int skb_gro_len(const struct sk_buff *skb)
1335{
1336 return skb->len - NAPI_GRO_CB(skb)->data_offset;
1337}
1338
1339static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
1340{
1341 NAPI_GRO_CB(skb)->data_offset += len;
1342}
1343
Herbert Xua5b1cf22009-05-26 18:50:28 +00001344static inline void *skb_gro_header_fast(struct sk_buff *skb,
1345 unsigned int offset)
Herbert Xu86911732009-01-29 14:19:50 +00001346{
Herbert Xu78a478d2009-05-26 18:50:21 +00001347 return NAPI_GRO_CB(skb)->frag0 + offset;
Herbert Xu86911732009-01-29 14:19:50 +00001348}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
Herbert Xua5b1cf22009-05-26 18:50:28 +00001350static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
1351{
1352 return NAPI_GRO_CB(skb)->frag0_len < hlen;
1353}
1354
1355static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
1356 unsigned int offset)
1357{
1358 NAPI_GRO_CB(skb)->frag0 = NULL;
1359 NAPI_GRO_CB(skb)->frag0_len = 0;
1360 return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
1361}
1362
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001363static inline void *skb_gro_mac_header(struct sk_buff *skb)
1364{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001365 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001366}
1367
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001368static inline void *skb_gro_network_header(struct sk_buff *skb)
1369{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001370 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
1371 skb_network_offset(skb);
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001372}
1373
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001374static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
1375 unsigned short type,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001376 const void *daddr, const void *saddr,
1377 unsigned len)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001378{
Ursula Braunf1ecfd52007-10-22 16:16:14 +02001379 if (!dev->header_ops || !dev->header_ops->create)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001380 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001381
1382 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001383}
1384
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001385static inline int dev_parse_header(const struct sk_buff *skb,
1386 unsigned char *haddr)
1387{
1388 const struct net_device *dev = skb->dev;
1389
Patrick McHardy1b833362007-10-18 05:09:28 -07001390 if (!dev->header_ops || !dev->header_ops->parse)
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001391 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001392 return dev->header_ops->parse(skb, haddr);
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001393}
1394
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
1396extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
1397static inline int unregister_gifconf(unsigned int family)
1398{
1399 return register_gifconf(family, NULL);
1400}
1401
1402/*
Eric Dumazet88751272010-04-19 05:07:33 +00001403 * Incoming packets are placed on per-cpu queues
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 */
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08001405struct softnet_data {
David S. Miller37437bb2008-07-16 02:15:04 -07001406 struct Qdisc *output_queue;
Changli Gaoa9cbd582010-04-26 23:06:24 +00001407 struct Qdisc **output_queue_tailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 struct list_head poll_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 struct sk_buff *completion_queue;
Changli Gao6e7676c2010-04-27 15:07:33 -07001410 struct sk_buff_head process_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411
Changli Gaodee42872010-05-02 05:42:16 +00001412 /* stats */
David S. Millercd7b5392010-05-02 22:27:59 -07001413 unsigned int processed;
1414 unsigned int time_squeeze;
1415 unsigned int cpu_collision;
1416 unsigned int received_rps;
Changli Gaodee42872010-05-02 05:42:16 +00001417
Changli Gaofd793d82010-04-15 00:16:59 -07001418#ifdef CONFIG_RPS
Eric Dumazet88751272010-04-19 05:07:33 +00001419 struct softnet_data *rps_ipi_list;
1420
1421 /* Elements below can be accessed between CPUs for RPS */
Tom Herbert0a9627f2010-03-16 08:03:29 +00001422 struct call_single_data csd ____cacheline_aligned_in_smp;
Eric Dumazet88751272010-04-19 05:07:33 +00001423 struct softnet_data *rps_ipi_next;
1424 unsigned int cpu;
Tom Herbertfec5e652010-04-16 16:01:27 -07001425 unsigned int input_queue_head;
Tom Herbert76cc8b12010-05-20 18:37:59 +00001426 unsigned int input_queue_tail;
Tom Herbert1e94d722010-03-18 17:45:44 -07001427#endif
Changli Gaodee42872010-05-02 05:42:16 +00001428 unsigned dropped;
Tom Herbert0a9627f2010-03-16 08:03:29 +00001429 struct sk_buff_head input_pkt_queue;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001430 struct napi_struct backlog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431};
1432
Tom Herbert76cc8b12010-05-20 18:37:59 +00001433static inline void input_queue_head_incr(struct softnet_data *sd)
Tom Herbertfec5e652010-04-16 16:01:27 -07001434{
1435#ifdef CONFIG_RPS
Tom Herbert76cc8b12010-05-20 18:37:59 +00001436 sd->input_queue_head++;
1437#endif
1438}
1439
1440static inline void input_queue_tail_incr_save(struct softnet_data *sd,
1441 unsigned int *qtail)
1442{
1443#ifdef CONFIG_RPS
1444 *qtail = ++sd->input_queue_tail;
Tom Herbertfec5e652010-04-16 16:01:27 -07001445#endif
1446}
1447
Tom Herbert0a9627f2010-03-16 08:03:29 +00001448DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449
1450#define HAVE_NETIF_QUEUE
1451
David S. Miller37437bb2008-07-16 02:15:04 -07001452extern void __netif_schedule(struct Qdisc *q);
David S. Miller86d804e2008-07-08 23:11:25 -07001453
1454static inline void netif_schedule_queue(struct netdev_queue *txq)
1455{
David S. Miller79d16382008-07-08 23:14:46 -07001456 if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001457 __netif_schedule(txq->qdisc);
David S. Miller86d804e2008-07-08 23:11:25 -07001458}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001460static inline void netif_tx_schedule_all(struct net_device *dev)
1461{
1462 unsigned int i;
1463
1464 for (i = 0; i < dev->num_tx_queues; i++)
1465 netif_schedule_queue(netdev_get_tx_queue(dev, i));
1466}
1467
Dave Jonesd29f7492008-07-22 14:09:06 -07001468static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
1469{
1470 clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1471}
1472
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001473/**
1474 * netif_start_queue - allow transmit
1475 * @dev: network device
1476 *
1477 * Allow upper layers to call the device hard_start_xmit routine.
1478 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479static inline void netif_start_queue(struct net_device *dev)
1480{
David S. Millere8a04642008-07-17 00:34:19 -07001481 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482}
1483
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001484static inline void netif_tx_start_all_queues(struct net_device *dev)
1485{
1486 unsigned int i;
1487
1488 for (i = 0; i < dev->num_tx_queues; i++) {
1489 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1490 netif_tx_start_queue(txq);
1491 }
1492}
1493
David S. Miller79d16382008-07-08 23:14:46 -07001494static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495{
1496#ifdef CONFIG_NETPOLL_TRAP
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001497 if (netpoll_trap()) {
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001498 netif_tx_start_queue(dev_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 return;
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001500 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501#endif
David S. Miller79d16382008-07-08 23:14:46 -07001502 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001503 __netif_schedule(dev_queue->qdisc);
David S. Miller79d16382008-07-08 23:14:46 -07001504}
1505
Dave Jonesd29f7492008-07-22 14:09:06 -07001506/**
1507 * netif_wake_queue - restart transmit
1508 * @dev: network device
1509 *
1510 * Allow upper layers to call the device hard_start_xmit routine.
1511 * Used for flow control when transmit resources are available.
1512 */
David S. Miller79d16382008-07-08 23:14:46 -07001513static inline void netif_wake_queue(struct net_device *dev)
1514{
David S. Millere8a04642008-07-17 00:34:19 -07001515 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516}
1517
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001518static inline void netif_tx_wake_all_queues(struct net_device *dev)
1519{
1520 unsigned int i;
1521
1522 for (i = 0; i < dev->num_tx_queues; i++) {
1523 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1524 netif_tx_wake_queue(txq);
1525 }
1526}
1527
Dave Jonesd29f7492008-07-22 14:09:06 -07001528static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
1529{
1530 set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1531}
1532
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001533/**
1534 * netif_stop_queue - stop transmitted packets
1535 * @dev: network device
1536 *
1537 * Stop upper layers calling the device hard_start_xmit routine.
1538 * Used for flow control when transmit resources are unavailable.
1539 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540static inline void netif_stop_queue(struct net_device *dev)
1541{
David S. Millere8a04642008-07-17 00:34:19 -07001542 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543}
1544
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001545static inline void netif_tx_stop_all_queues(struct net_device *dev)
1546{
1547 unsigned int i;
1548
1549 for (i = 0; i < dev->num_tx_queues; i++) {
1550 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1551 netif_tx_stop_queue(txq);
1552 }
1553}
1554
Dave Jonesd29f7492008-07-22 14:09:06 -07001555static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
1556{
1557 return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1558}
1559
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001560/**
1561 * netif_queue_stopped - test if transmit queue is flowblocked
1562 * @dev: network device
1563 *
1564 * Test if transmit queue on device is currently unable to send.
1565 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566static inline int netif_queue_stopped(const struct net_device *dev)
1567{
David S. Millere8a04642008-07-17 00:34:19 -07001568 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569}
1570
David S. Millerc3f26a22008-07-31 16:58:50 -07001571static inline int netif_tx_queue_frozen(const struct netdev_queue *dev_queue)
1572{
1573 return test_bit(__QUEUE_STATE_FROZEN, &dev_queue->state);
1574}
1575
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001576/**
1577 * netif_running - test if up
1578 * @dev: network device
1579 *
1580 * Test if the device has been brought up.
1581 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582static inline int netif_running(const struct net_device *dev)
1583{
1584 return test_bit(__LINK_STATE_START, &dev->state);
1585}
1586
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001587/*
1588 * Routines to manage the subqueues on a device. We only need start
1589 * stop, and a check if it's stopped. All other device management is
1590 * done at the overall netdevice level.
1591 * Also test the device if we're multiqueue.
1592 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001593
1594/**
1595 * netif_start_subqueue - allow sending packets on subqueue
1596 * @dev: network device
1597 * @queue_index: sub queue index
1598 *
1599 * Start individual transmit queue of a device with multiple transmit queues.
1600 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001601static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
1602{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001603 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001604
1605 netif_tx_start_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001606}
1607
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001608/**
1609 * netif_stop_subqueue - stop sending packets on subqueue
1610 * @dev: network device
1611 * @queue_index: sub queue index
1612 *
1613 * Stop individual transmit queue of a device with multiple transmit queues.
1614 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001615static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
1616{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001617 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001618#ifdef CONFIG_NETPOLL_TRAP
1619 if (netpoll_trap())
1620 return;
1621#endif
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001622 netif_tx_stop_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001623}
1624
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001625/**
1626 * netif_subqueue_stopped - test status of subqueue
1627 * @dev: network device
1628 * @queue_index: sub queue index
1629 *
1630 * Check individual transmit queue of a device with multiple transmit queues.
1631 */
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001632static inline int __netif_subqueue_stopped(const struct net_device *dev,
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001633 u16 queue_index)
1634{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001635 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001636
1637 return netif_tx_queue_stopped(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001638}
1639
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001640static inline int netif_subqueue_stopped(const struct net_device *dev,
1641 struct sk_buff *skb)
1642{
1643 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
1644}
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001645
1646/**
1647 * netif_wake_subqueue - allow sending packets on subqueue
1648 * @dev: network device
1649 * @queue_index: sub queue index
1650 *
1651 * Resume individual transmit queue of a device with multiple transmit queues.
1652 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001653static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
1654{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001655 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001656#ifdef CONFIG_NETPOLL_TRAP
1657 if (netpoll_trap())
1658 return;
1659#endif
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001660 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001661 __netif_schedule(txq->qdisc);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001662}
1663
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001664/**
1665 * netif_is_multiqueue - test if device has multiple transmit queues
1666 * @dev: network device
1667 *
1668 * Check if device has multiple transmit queues
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001669 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001670static inline int netif_is_multiqueue(const struct net_device *dev)
1671{
David S. Miller09e83b52008-07-17 01:52:12 -07001672 return (dev->num_tx_queues > 1);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001673}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674
1675/* Use this variant when it is known for sure that it
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07001676 * is executing from hardware interrupt context or with hardware interrupts
1677 * disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001679extern void dev_kfree_skb_irq(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680
1681/* Use this variant in places where it could be invoked
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07001682 * from either hardware interrupt or other context, with hardware interrupts
1683 * either disabled or enabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 */
Denis Vlasenko56079432006-03-29 15:57:29 -08001685extern void dev_kfree_skb_any(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
1687#define HAVE_NETIF_RX 1
1688extern int netif_rx(struct sk_buff *skb);
1689extern int netif_rx_ni(struct sk_buff *skb);
1690#define HAVE_NETIF_RECEIVE_SKB 1
1691extern int netif_receive_skb(struct sk_buff *skb);
Ben Hutchings5b252f02009-10-29 07:17:09 +00001692extern gro_result_t dev_gro_receive(struct napi_struct *napi,
Herbert Xu96e93ea2009-01-06 10:49:34 -08001693 struct sk_buff *skb);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07001694extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb);
1695extern gro_result_t napi_gro_receive(struct napi_struct *napi,
Herbert Xud565b0a2008-12-15 23:38:52 -08001696 struct sk_buff *skb);
Herbert Xu96e93ea2009-01-06 10:49:34 -08001697extern void napi_reuse_skb(struct napi_struct *napi,
1698 struct sk_buff *skb);
Herbert Xu76620aa2009-04-16 02:02:07 -07001699extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07001700extern gro_result_t napi_frags_finish(struct napi_struct *napi,
Ben Hutchings5b252f02009-10-29 07:17:09 +00001701 struct sk_buff *skb,
1702 gro_result_t ret);
Herbert Xu76620aa2009-04-16 02:02:07 -07001703extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07001704extern gro_result_t napi_gro_frags(struct napi_struct *napi);
Herbert Xu76620aa2009-04-16 02:02:07 -07001705
1706static inline void napi_free_frags(struct napi_struct *napi)
1707{
1708 kfree_skb(napi->skb);
1709 napi->skb = NULL;
1710}
1711
Jiri Pirkoab95bfe2010-06-01 21:52:08 +00001712extern int netdev_rx_handler_register(struct net_device *dev,
Jiri Pirko93e2c322010-06-10 03:34:59 +00001713 rx_handler_func_t *rx_handler,
1714 void *rx_handler_data);
Jiri Pirkoab95bfe2010-06-01 21:52:08 +00001715extern void netdev_rx_handler_unregister(struct net_device *dev);
1716
Patrick McHardybc1d0412008-07-14 22:49:30 -07001717extern void netif_nit_deliver(struct sk_buff *skb);
Mitch Williamsc2373ee2005-11-09 10:34:45 -08001718extern int dev_valid_name(const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001719extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
1720extern int dev_ethtool(struct net *net, struct ifreq *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721extern unsigned dev_get_flags(const struct net_device *);
Patrick McHardybd380812010-02-26 06:34:53 +00001722extern int __dev_change_flags(struct net_device *, unsigned int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723extern int dev_change_flags(struct net_device *, unsigned);
Patrick McHardybd380812010-02-26 06:34:53 +00001724extern void __dev_notify_flags(struct net_device *, unsigned int old_flags);
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -07001725extern int dev_change_name(struct net_device *, const char *);
Stephen Hemminger0b815a12008-09-22 21:28:11 -07001726extern int dev_set_alias(struct net_device *, const char *, size_t);
Eric W. Biedermance286d32007-09-12 13:53:49 +02001727extern int dev_change_net_namespace(struct net_device *,
1728 struct net *, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729extern int dev_set_mtu(struct net_device *, int);
1730extern int dev_set_mac_address(struct net_device *,
1731 struct sockaddr *);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001732extern int dev_hard_start_xmit(struct sk_buff *skb,
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001733 struct net_device *dev,
1734 struct netdev_queue *txq);
Arnd Bergmann44540962009-11-26 06:07:08 +00001735extern int dev_forward_skb(struct net_device *dev,
1736 struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001738extern int netdev_budget;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739
1740/* Called by rtnetlink.c:rtnl_unlock() */
1741extern void netdev_run_todo(void);
1742
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001743/**
1744 * dev_put - release reference to device
1745 * @dev: network device
1746 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07001747 * Release reference to device to allow it to be freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001748 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749static inline void dev_put(struct net_device *dev)
1750{
1751 atomic_dec(&dev->refcnt);
1752}
1753
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001754/**
1755 * dev_hold - get reference to device
1756 * @dev: network device
1757 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07001758 * Hold reference to device to keep it from being freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001759 */
Stephen Hemminger15333062006-03-20 22:32:28 -08001760static inline void dev_hold(struct net_device *dev)
1761{
1762 atomic_inc(&dev->refcnt);
1763}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
1765/* Carrier loss detection, dial on demand. The functions netif_carrier_on
1766 * and _off may be called from IRQ context, but it is caller
1767 * who is responsible for serialization of these calls.
Stefan Rompfb00055a2006-03-20 17:09:11 -08001768 *
1769 * The name carrier is inappropriate, these functions should really be
1770 * called netif_lowerlayer_*() because they represent the state of any
1771 * kind of lower layer not just hardware media.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 */
1773
1774extern void linkwatch_fire_event(struct net_device *dev);
Eric Dumazete014deb2009-11-17 05:59:21 +00001775extern void linkwatch_forget_dev(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001777/**
1778 * netif_carrier_ok - test if carrier present
1779 * @dev: network device
1780 *
1781 * Check if carrier is present on device
1782 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783static inline int netif_carrier_ok(const struct net_device *dev)
1784{
1785 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
1786}
1787
Eric Dumazet9d214932009-05-17 20:55:16 -07001788extern unsigned long dev_trans_start(struct net_device *dev);
1789
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790extern void __netdev_watchdog_up(struct net_device *dev);
1791
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07001792extern void netif_carrier_on(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07001794extern void netif_carrier_off(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795
Ian Campbell06c46482010-05-26 00:09:42 +00001796extern void netif_notify_peers(struct net_device *dev);
1797
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001798/**
1799 * netif_dormant_on - mark device as dormant.
1800 * @dev: network device
1801 *
1802 * Mark device as dormant (as per RFC2863).
1803 *
1804 * The dormant state indicates that the relevant interface is not
1805 * actually in a condition to pass packets (i.e., it is not 'up') but is
1806 * in a "pending" state, waiting for some external event. For "on-
1807 * demand" interfaces, this new state identifies the situation where the
1808 * interface is waiting for events to place it in the up state.
1809 *
1810 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001811static inline void netif_dormant_on(struct net_device *dev)
1812{
1813 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
1814 linkwatch_fire_event(dev);
1815}
1816
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001817/**
1818 * netif_dormant_off - set device as not dormant.
1819 * @dev: network device
1820 *
1821 * Device is not in dormant state.
1822 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001823static inline void netif_dormant_off(struct net_device *dev)
1824{
1825 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
1826 linkwatch_fire_event(dev);
1827}
1828
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001829/**
1830 * netif_dormant - test if carrier present
1831 * @dev: network device
1832 *
1833 * Check if carrier is present on device
1834 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001835static inline int netif_dormant(const struct net_device *dev)
1836{
1837 return test_bit(__LINK_STATE_DORMANT, &dev->state);
1838}
1839
1840
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001841/**
1842 * netif_oper_up - test if device is operational
1843 * @dev: network device
1844 *
1845 * Check if carrier is operational
1846 */
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08001847static inline int netif_oper_up(const struct net_device *dev)
1848{
Stefan Rompfb00055a2006-03-20 17:09:11 -08001849 return (dev->operstate == IF_OPER_UP ||
1850 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
1851}
1852
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001853/**
1854 * netif_device_present - is device available or removed
1855 * @dev: network device
1856 *
1857 * Check if device has not been removed from system.
1858 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859static inline int netif_device_present(struct net_device *dev)
1860{
1861 return test_bit(__LINK_STATE_PRESENT, &dev->state);
1862}
1863
Denis Vlasenko56079432006-03-29 15:57:29 -08001864extern void netif_device_detach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
Denis Vlasenko56079432006-03-29 15:57:29 -08001866extern void netif_device_attach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867
1868/*
1869 * Network interface message level settings
1870 */
1871#define HAVE_NETIF_MSG 1
1872
1873enum {
1874 NETIF_MSG_DRV = 0x0001,
1875 NETIF_MSG_PROBE = 0x0002,
1876 NETIF_MSG_LINK = 0x0004,
1877 NETIF_MSG_TIMER = 0x0008,
1878 NETIF_MSG_IFDOWN = 0x0010,
1879 NETIF_MSG_IFUP = 0x0020,
1880 NETIF_MSG_RX_ERR = 0x0040,
1881 NETIF_MSG_TX_ERR = 0x0080,
1882 NETIF_MSG_TX_QUEUED = 0x0100,
1883 NETIF_MSG_INTR = 0x0200,
1884 NETIF_MSG_TX_DONE = 0x0400,
1885 NETIF_MSG_RX_STATUS = 0x0800,
1886 NETIF_MSG_PKTDATA = 0x1000,
1887 NETIF_MSG_HW = 0x2000,
1888 NETIF_MSG_WOL = 0x4000,
1889};
1890
1891#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
1892#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
1893#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
1894#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
1895#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
1896#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
1897#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
1898#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
1899#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
1900#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
1901#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
1902#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
1903#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
1904#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
1905#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
1906
1907static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
1908{
1909 /* use default */
1910 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
1911 return default_msg_enable_bits;
1912 if (debug_value == 0) /* no output */
1913 return 0;
1914 /* set low N bits */
1915 return (1 << debug_value) - 1;
1916}
1917
David S. Millerc773e842008-07-08 23:13:53 -07001918static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
Herbert Xu932ff272006-06-09 12:20:56 -07001919{
David S. Millerc773e842008-07-08 23:13:53 -07001920 spin_lock(&txq->_xmit_lock);
1921 txq->xmit_lock_owner = cpu;
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001922}
1923
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001924static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
1925{
1926 spin_lock_bh(&txq->_xmit_lock);
1927 txq->xmit_lock_owner = smp_processor_id();
1928}
1929
David S. Millerc773e842008-07-08 23:13:53 -07001930static inline int __netif_tx_trylock(struct netdev_queue *txq)
1931{
1932 int ok = spin_trylock(&txq->_xmit_lock);
1933 if (likely(ok))
1934 txq->xmit_lock_owner = smp_processor_id();
1935 return ok;
Herbert Xu932ff272006-06-09 12:20:56 -07001936}
1937
David S. Millerc773e842008-07-08 23:13:53 -07001938static inline void __netif_tx_unlock(struct netdev_queue *txq)
1939{
1940 txq->xmit_lock_owner = -1;
1941 spin_unlock(&txq->_xmit_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07001942}
1943
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001944static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
1945{
1946 txq->xmit_lock_owner = -1;
1947 spin_unlock_bh(&txq->_xmit_lock);
1948}
1949
Eric Dumazet08baf562009-05-25 22:58:01 -07001950static inline void txq_trans_update(struct netdev_queue *txq)
1951{
1952 if (txq->xmit_lock_owner != -1)
1953 txq->trans_start = jiffies;
1954}
1955
David S. Millerc3f26a22008-07-31 16:58:50 -07001956/**
1957 * netif_tx_lock - grab network device transmit lock
1958 * @dev: network device
David S. Millerc3f26a22008-07-31 16:58:50 -07001959 *
1960 * Get network device transmit lock
1961 */
1962static inline void netif_tx_lock(struct net_device *dev)
1963{
1964 unsigned int i;
1965 int cpu;
1966
1967 spin_lock(&dev->tx_global_lock);
1968 cpu = smp_processor_id();
1969 for (i = 0; i < dev->num_tx_queues; i++) {
1970 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1971
1972 /* We are the only thread of execution doing a
1973 * freeze, but we have to grab the _xmit_lock in
1974 * order to synchronize with threads which are in
1975 * the ->hard_start_xmit() handler and already
1976 * checked the frozen bit.
1977 */
1978 __netif_tx_lock(txq, cpu);
1979 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
1980 __netif_tx_unlock(txq);
1981 }
1982}
1983
1984static inline void netif_tx_lock_bh(struct net_device *dev)
1985{
1986 local_bh_disable();
1987 netif_tx_lock(dev);
1988}
1989
Herbert Xu932ff272006-06-09 12:20:56 -07001990static inline void netif_tx_unlock(struct net_device *dev)
1991{
David S. Millere8a04642008-07-17 00:34:19 -07001992 unsigned int i;
David S. Millerc773e842008-07-08 23:13:53 -07001993
David S. Millere8a04642008-07-17 00:34:19 -07001994 for (i = 0; i < dev->num_tx_queues; i++) {
1995 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millere8a04642008-07-17 00:34:19 -07001996
David S. Millerc3f26a22008-07-31 16:58:50 -07001997 /* No need to grab the _xmit_lock here. If the
1998 * queue is not stopped for another reason, we
1999 * force a schedule.
2000 */
2001 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00002002 netif_schedule_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07002003 }
2004 spin_unlock(&dev->tx_global_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07002005}
2006
2007static inline void netif_tx_unlock_bh(struct net_device *dev)
2008{
David S. Millere8a04642008-07-17 00:34:19 -07002009 netif_tx_unlock(dev);
2010 local_bh_enable();
Herbert Xu932ff272006-06-09 12:20:56 -07002011}
2012
David S. Millerc773e842008-07-08 23:13:53 -07002013#define HARD_TX_LOCK(dev, txq, cpu) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002014 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07002015 __netif_tx_lock(txq, cpu); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002016 } \
2017}
2018
David S. Millerc773e842008-07-08 23:13:53 -07002019#define HARD_TX_UNLOCK(dev, txq) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002020 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07002021 __netif_tx_unlock(txq); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07002022 } \
2023}
2024
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025static inline void netif_tx_disable(struct net_device *dev)
2026{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002027 unsigned int i;
David S. Millerc3f26a22008-07-31 16:58:50 -07002028 int cpu;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002029
David S. Millerc3f26a22008-07-31 16:58:50 -07002030 local_bh_disable();
2031 cpu = smp_processor_id();
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002032 for (i = 0; i < dev->num_tx_queues; i++) {
2033 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millerc3f26a22008-07-31 16:58:50 -07002034
2035 __netif_tx_lock(txq, cpu);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002036 netif_tx_stop_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07002037 __netif_tx_unlock(txq);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07002038 }
David S. Millerc3f26a22008-07-31 16:58:50 -07002039 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040}
2041
David S. Millere308a5d2008-07-15 00:13:44 -07002042static inline void netif_addr_lock(struct net_device *dev)
2043{
2044 spin_lock(&dev->addr_list_lock);
2045}
2046
2047static inline void netif_addr_lock_bh(struct net_device *dev)
2048{
2049 spin_lock_bh(&dev->addr_list_lock);
2050}
2051
2052static inline void netif_addr_unlock(struct net_device *dev)
2053{
2054 spin_unlock(&dev->addr_list_lock);
2055}
2056
2057static inline void netif_addr_unlock_bh(struct net_device *dev)
2058{
2059 spin_unlock_bh(&dev->addr_list_lock);
2060}
2061
Jiri Pirkof001fde2009-05-05 02:48:28 +00002062/*
Jiri Pirko31278e72009-06-17 01:12:19 +00002063 * dev_addrs walker. Should be used only for read access. Call with
Jiri Pirkof001fde2009-05-05 02:48:28 +00002064 * rcu_read_lock held.
2065 */
2066#define for_each_dev_addr(dev, ha) \
Jiri Pirko31278e72009-06-17 01:12:19 +00002067 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
Jiri Pirkof001fde2009-05-05 02:48:28 +00002068
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069/* These functions live elsewhere (drivers/net/net_init.c, but related) */
2070
2071extern void ether_setup(struct net_device *dev);
2072
2073/* Support for loadable net-drivers */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002074extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
2075 void (*setup)(struct net_device *),
2076 unsigned int queue_count);
2077#define alloc_netdev(sizeof_priv, name, setup) \
2078 alloc_netdev_mq(sizeof_priv, name, setup, 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079extern int register_netdev(struct net_device *dev);
2080extern void unregister_netdev(struct net_device *dev);
Jiri Pirkof001fde2009-05-05 02:48:28 +00002081
Jiri Pirko22bedad32010-04-01 21:22:57 +00002082/* General hardware address lists handling functions */
2083extern int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
2084 struct netdev_hw_addr_list *from_list,
2085 int addr_len, unsigned char addr_type);
2086extern void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
2087 struct netdev_hw_addr_list *from_list,
2088 int addr_len, unsigned char addr_type);
2089extern int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
2090 struct netdev_hw_addr_list *from_list,
2091 int addr_len);
2092extern void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
2093 struct netdev_hw_addr_list *from_list,
2094 int addr_len);
2095extern void __hw_addr_flush(struct netdev_hw_addr_list *list);
2096extern void __hw_addr_init(struct netdev_hw_addr_list *list);
2097
Jiri Pirkof001fde2009-05-05 02:48:28 +00002098/* Functions used for device addresses handling */
2099extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
2100 unsigned char addr_type);
2101extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
2102 unsigned char addr_type);
2103extern int dev_addr_add_multiple(struct net_device *to_dev,
2104 struct net_device *from_dev,
2105 unsigned char addr_type);
2106extern int dev_addr_del_multiple(struct net_device *to_dev,
2107 struct net_device *from_dev,
2108 unsigned char addr_type);
Jiri Pirkoa748ee22010-04-01 21:22:09 +00002109extern void dev_addr_flush(struct net_device *dev);
2110extern int dev_addr_init(struct net_device *dev);
2111
2112/* Functions used for unicast addresses handling */
2113extern int dev_uc_add(struct net_device *dev, unsigned char *addr);
2114extern int dev_uc_del(struct net_device *dev, unsigned char *addr);
2115extern int dev_uc_sync(struct net_device *to, struct net_device *from);
2116extern void dev_uc_unsync(struct net_device *to, struct net_device *from);
2117extern void dev_uc_flush(struct net_device *dev);
2118extern void dev_uc_init(struct net_device *dev);
Jiri Pirkof001fde2009-05-05 02:48:28 +00002119
Jiri Pirko22bedad32010-04-01 21:22:57 +00002120/* Functions used for multicast addresses handling */
2121extern int dev_mc_add(struct net_device *dev, unsigned char *addr);
2122extern int dev_mc_add_global(struct net_device *dev, unsigned char *addr);
2123extern int dev_mc_del(struct net_device *dev, unsigned char *addr);
2124extern int dev_mc_del_global(struct net_device *dev, unsigned char *addr);
2125extern int dev_mc_sync(struct net_device *to, struct net_device *from);
2126extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
2127extern void dev_mc_flush(struct net_device *dev);
2128extern void dev_mc_init(struct net_device *dev);
Herbert Xufb286bb2005-11-10 13:01:24 -08002129
2130/* Functions used for secondary unicast and multicast support */
2131extern void dev_set_rx_mode(struct net_device *dev);
2132extern void __dev_set_rx_mode(struct net_device *dev);
Herbert Xufb286bb2005-11-10 13:01:24 -08002133extern int dev_set_promiscuity(struct net_device *dev, int inc);
2134extern int dev_set_allmulti(struct net_device *dev, int inc);
2135extern void netdev_state_change(struct net_device *dev);
Jiri Pirko3ca5b402010-03-10 10:29:35 +00002136extern int netdev_bonding_change(struct net_device *dev,
Moni Shoua75c78502009-09-15 02:37:40 -07002137 unsigned long event);
Herbert Xufb286bb2005-11-10 13:01:24 -08002138extern void netdev_features_change(struct net_device *dev);
2139/* Load a device via the kmod */
2140extern void dev_load(struct net *net, const char *name);
2141extern void dev_mcast_init(void);
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +00002142extern const struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev);
Eric Dumazetd83345a2009-11-16 03:36:51 +00002143extern void dev_txq_stats_fold(const struct net_device *dev, struct net_device_stats *stats);
Herbert Xufb286bb2005-11-10 13:01:24 -08002144
2145extern int netdev_max_backlog;
Eric Dumazet3b098e22010-05-15 23:57:10 -07002146extern int netdev_tstamp_prequeue;
Herbert Xufb286bb2005-11-10 13:01:24 -08002147extern int weight_p;
2148extern int netdev_set_master(struct net_device *dev, struct net_device *master);
2149extern int skb_checksum_help(struct sk_buff *skb);
2150extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
2151#ifdef CONFIG_BUG
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152extern void netdev_rx_csum_fault(struct net_device *dev);
2153#else
2154static inline void netdev_rx_csum_fault(struct net_device *dev)
2155{
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002156}
2157#endif
2158/* rx skb timestamps */
2159extern void net_enable_timestamp(void);
2160extern void net_disable_timestamp(void);
2161
2162#ifdef CONFIG_PROC_FS
2163extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
Herbert Xu79671682006-06-22 02:40:14 -07002164extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
2165extern void dev_seq_stop(struct seq_file *seq, void *v);
2166#endif
2167
Jay Vosburghb8a97872008-06-13 18:12:04 -07002168extern int netdev_class_create_file(struct class_attribute *class_attr);
2169extern void netdev_class_remove_file(struct class_attribute *class_attr);
2170
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -07002171extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);
Arjan van de Ven6579e572008-07-21 13:31:48 -07002172
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173extern void linkwatch_run_queue(void);
2174
Herbert Xub63365a2008-10-23 01:11:29 -07002175unsigned long netdev_increment_features(unsigned long all, unsigned long one,
2176 unsigned long mask);
2177unsigned long netdev_fix_features(unsigned long features, const char *name);
Herbert Xu7f353bf2007-08-10 15:47:58 -07002178
Patrick Mullaneyfc4a7482009-12-03 15:59:22 -08002179void netif_stacked_transfer_operstate(const struct net_device *rootdev,
2180 struct net_device *dev);
2181
Herbert Xubcd76112006-06-30 13:36:35 -07002182static inline int net_gso_ok(int features, int gso_type)
2183{
2184 int feature = gso_type << NETIF_F_GSO_SHIFT;
2185 return (features & feature) == feature;
2186}
2187
Herbert Xu576a30e2006-06-27 13:22:38 -07002188static inline int skb_gso_ok(struct sk_buff *skb, int features)
2189{
Herbert Xu278b2512009-06-03 21:20:51 -07002190 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
David S. Millera5bd8a12009-06-09 00:17:27 -07002191 (!skb_has_frags(skb) || (features & NETIF_F_FRAGLIST));
Herbert Xu576a30e2006-06-27 13:22:38 -07002192}
2193
Herbert Xu79671682006-06-22 02:40:14 -07002194static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
2195{
Herbert Xua430a432006-07-08 13:34:56 -07002196 return skb_is_gso(skb) &&
2197 (!skb_gso_ok(skb, dev->features) ||
Patrick McHardy84fa7932006-08-29 16:44:56 -07002198 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
Herbert Xu79671682006-06-22 02:40:14 -07002199}
2200
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07002201static inline void netif_set_gso_max_size(struct net_device *dev,
2202 unsigned int size)
2203{
2204 dev->gso_max_size = size;
2205}
2206
Eric Dumazetacbbc072010-04-11 06:56:11 +00002207extern int __skb_bond_should_drop(struct sk_buff *skb,
2208 struct net_device *master);
Jiri Pirko5d4e0392009-05-28 01:05:00 +00002209
Eric Dumazet0641e4f2010-03-18 21:16:45 -07002210static inline int skb_bond_should_drop(struct sk_buff *skb,
2211 struct net_device *master)
David S. Miller7ea49ed2006-08-14 17:08:36 -07002212{
Eric Dumazetacbbc072010-04-11 06:56:11 +00002213 if (master)
2214 return __skb_bond_should_drop(skb, master);
David S. Miller7ea49ed2006-08-14 17:08:36 -07002215 return 0;
2216}
2217
Eric W. Biederman505d4f72008-11-07 22:54:20 -08002218extern struct pernet_operations __net_initdata loopback_net_ops;
Patrick McHardyb1b67dd2009-04-20 04:49:28 +00002219
2220static inline int dev_ethtool_get_settings(struct net_device *dev,
2221 struct ethtool_cmd *cmd)
2222{
2223 if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
2224 return -EOPNOTSUPP;
2225 return dev->ethtool_ops->get_settings(dev, cmd);
2226}
2227
2228static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
2229{
2230 if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
2231 return 0;
2232 return dev->ethtool_ops->get_rx_csum(dev);
2233}
2234
2235static inline u32 dev_ethtool_get_flags(struct net_device *dev)
2236{
2237 if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
2238 return 0;
2239 return dev->ethtool_ops->get_flags(dev);
2240}
Joe Perches571ba422010-02-09 11:49:47 +00002241
2242/* Logging, debugging and troubleshooting/diagnostic helpers. */
2243
2244/* netdev_printk helpers, similar to dev_printk */
2245
2246static inline const char *netdev_name(const struct net_device *dev)
2247{
2248 if (dev->reg_state != NETREG_REGISTERED)
2249 return "(unregistered net_device)";
2250 return dev->name;
2251}
2252
Joe Perches256df2f2010-06-27 01:02:35 +00002253extern int netdev_printk(const char *level, const struct net_device *dev,
2254 const char *format, ...)
2255 __attribute__ ((format (printf, 3, 4)));
2256extern int netdev_emerg(const struct net_device *dev, const char *format, ...)
2257 __attribute__ ((format (printf, 2, 3)));
2258extern int netdev_alert(const struct net_device *dev, const char *format, ...)
2259 __attribute__ ((format (printf, 2, 3)));
2260extern int netdev_crit(const struct net_device *dev, const char *format, ...)
2261 __attribute__ ((format (printf, 2, 3)));
2262extern int netdev_err(const struct net_device *dev, const char *format, ...)
2263 __attribute__ ((format (printf, 2, 3)));
2264extern int netdev_warn(const struct net_device *dev, const char *format, ...)
2265 __attribute__ ((format (printf, 2, 3)));
2266extern int netdev_notice(const struct net_device *dev, const char *format, ...)
2267 __attribute__ ((format (printf, 2, 3)));
2268extern int netdev_info(const struct net_device *dev, const char *format, ...)
2269 __attribute__ ((format (printf, 2, 3)));
Joe Perches571ba422010-02-09 11:49:47 +00002270
2271#if defined(DEBUG)
2272#define netdev_dbg(__dev, format, args...) \
2273 netdev_printk(KERN_DEBUG, __dev, format, ##args)
2274#elif defined(CONFIG_DYNAMIC_DEBUG)
2275#define netdev_dbg(__dev, format, args...) \
2276do { \
2277 dynamic_dev_dbg((__dev)->dev.parent, "%s: " format, \
2278 netdev_name(__dev), ##args); \
2279} while (0)
2280#else
2281#define netdev_dbg(__dev, format, args...) \
2282({ \
2283 if (0) \
2284 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
2285 0; \
2286})
2287#endif
2288
2289#if defined(VERBOSE_DEBUG)
2290#define netdev_vdbg netdev_dbg
2291#else
2292
2293#define netdev_vdbg(dev, format, args...) \
2294({ \
2295 if (0) \
2296 netdev_printk(KERN_DEBUG, dev, format, ##args); \
2297 0; \
2298})
2299#endif
2300
2301/*
2302 * netdev_WARN() acts like dev_printk(), but with the key difference
2303 * of using a WARN/WARN_ON to get the message out, including the
2304 * file/line information and a backtrace.
2305 */
2306#define netdev_WARN(dev, format, args...) \
2307 WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
2308
Joe Perchesb3d95c52010-02-09 11:49:49 +00002309/* netif printk helpers, similar to netdev_printk */
2310
2311#define netif_printk(priv, type, level, dev, fmt, args...) \
2312do { \
2313 if (netif_msg_##type(priv)) \
2314 netdev_printk(level, (dev), fmt, ##args); \
2315} while (0)
2316
Joe Perchesf45f4322010-06-27 01:02:36 +00002317#define netif_level(level, priv, type, dev, fmt, args...) \
2318do { \
2319 if (netif_msg_##type(priv)) \
2320 netdev_##level(dev, fmt, ##args); \
2321} while (0)
2322
Joe Perchesb3d95c52010-02-09 11:49:49 +00002323#define netif_emerg(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002324 netif_level(emerg, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002325#define netif_alert(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002326 netif_level(alert, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002327#define netif_crit(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002328 netif_level(crit, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002329#define netif_err(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002330 netif_level(err, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002331#define netif_warn(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002332 netif_level(warn, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002333#define netif_notice(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002334 netif_level(notice, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002335#define netif_info(priv, type, dev, fmt, args...) \
Joe Perchesf45f4322010-06-27 01:02:36 +00002336 netif_level(info, priv, type, dev, fmt, ##args)
Joe Perchesb3d95c52010-02-09 11:49:49 +00002337
2338#if defined(DEBUG)
2339#define netif_dbg(priv, type, dev, format, args...) \
2340 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
2341#elif defined(CONFIG_DYNAMIC_DEBUG)
2342#define netif_dbg(priv, type, netdev, format, args...) \
2343do { \
2344 if (netif_msg_##type(priv)) \
2345 dynamic_dev_dbg((netdev)->dev.parent, \
2346 "%s: " format, \
2347 netdev_name(netdev), ##args); \
2348} while (0)
2349#else
2350#define netif_dbg(priv, type, dev, format, args...) \
2351({ \
2352 if (0) \
2353 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
2354 0; \
2355})
2356#endif
2357
2358#if defined(VERBOSE_DEBUG)
2359#define netif_vdbg netdev_dbg
2360#else
2361#define netif_vdbg(priv, type, dev, format, args...) \
2362({ \
2363 if (0) \
Ben Hutchingsa4ed89c2010-05-18 06:56:32 +00002364 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
Joe Perchesb3d95c52010-02-09 11:49:49 +00002365 0; \
2366})
2367#endif
Joe Perches571ba422010-02-09 11:49:47 +00002368
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369#endif /* __KERNEL__ */
2370
Jiri Pirko385a1542009-05-27 15:48:07 -07002371#endif /* _LINUX_NETDEVICE_H */