blob: a3fccc85b1a0ef1732abd892963d639d8c9d93ad [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>
31
32#ifdef __KERNEL__
Al Virod7fe0f22006-12-03 23:15:30 -050033#include <linux/timer.h>
Stephen Hemmingerbea33482007-10-03 16:41:36 -070034#include <linux/delay.h>
Dmitri Vorobievcc0be322009-03-27 15:55:36 -070035#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/atomic.h>
37#include <asm/cache.h>
38#include <asm/byteorder.h>
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/device.h>
41#include <linux/percpu.h>
David S. Miller4d5b78c2009-05-06 16:52:51 -070042#include <linux/rculist.h>
Chris Leechdb217332006-06-17 21:24:58 -070043#include <linux/dmaengine.h>
Stephen Hemmingerbea33482007-10-03 16:41:36 -070044#include <linux/workqueue.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Patrick McHardyb1b67dd2009-04-20 04:49:28 +000046#include <linux/ethtool.h>
Daniel Lezcanoa050c332007-09-12 14:57:09 +020047#include <net/net_namespace.h>
Lennert Buytenhekcf85d082008-10-07 13:45:02 +000048#include <net/dsa.h>
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -080049#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -080050#include <net/dcbnl.h>
51#endif
Daniel Lezcanoa050c332007-09-12 14:57:09 +020052
Linus Torvalds1da177e2005-04-16 15:20:36 -070053struct vlan_group;
Jeff Moyer115c1d62005-06-22 22:05:31 -070054struct netpoll_info;
Johannes Berg704232c2007-04-23 12:20:05 -070055/* 802.11 specific */
56struct wireless_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 /* source back-compat hooks */
58#define SET_ETHTOOL_OPS(netdev,ops) \
59 ( (netdev)->ethtool_ops = (ops) )
60
61#define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev
62 functions are available. */
63#define HAVE_FREE_NETDEV /* free_netdev() */
64#define HAVE_NETDEV_PRIV /* netdev_priv() */
65
Jarek Poplawski9a1654b2009-11-15 07:20:12 +000066/* Backlog congestion levels */
67#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
68#define NET_RX_DROP 1 /* packet dropped */
69
Patrick McHardy572a9d72009-11-10 06:14:14 +000070/*
71 * Transmit return codes: transmit return codes originate from three different
72 * namespaces:
73 *
74 * - qdisc return codes
75 * - driver transmit return codes
76 * - errno values
77 *
78 * Drivers are allowed to return any one of those in their hard_start_xmit()
79 * function. Real network devices commonly used with qdiscs should only return
80 * the driver transmit return codes though - when qdiscs are used, the actual
81 * transmission happens asynchronously, so the value is not propagated to
82 * higher layers. Virtual network devices transmit synchronously, in this case
83 * the driver transmit return codes are consumed by dev_queue_xmit(), all
84 * others are propagated to higher layers.
85 */
86
87/* qdisc ->enqueue() return codes. */
88#define NET_XMIT_SUCCESS 0x00
Jarek Poplawski9a1654b2009-11-15 07:20:12 +000089#define NET_XMIT_DROP 0x01 /* skb dropped */
90#define NET_XMIT_CN 0x02 /* congestion notification */
91#define NET_XMIT_POLICED 0x03 /* skb is shot by police */
92#define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -020094/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
95 * indicates that the device will soon be dropping packets, or already drops
96 * some packets of the same priority; prompting us to send less aggressively. */
Patrick McHardy572a9d72009-11-10 06:14:14 +000097#define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
Linus Torvalds1da177e2005-04-16 15:20:36 -070098#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
99
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000100/* Driver transmit return codes */
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000101#define NETDEV_TX_MASK 0xf0
Patrick McHardy572a9d72009-11-10 06:14:14 +0000102
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000103enum netdev_tx {
Patrick McHardy572a9d72009-11-10 06:14:14 +0000104 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000105 NETDEV_TX_OK = 0x00, /* driver took care of packet */
106 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
107 NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000108};
109typedef enum netdev_tx netdev_tx_t;
110
Jarek Poplawski9a1654b2009-11-15 07:20:12 +0000111/*
112 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
113 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
114 */
115static inline bool dev_xmit_complete(int rc)
116{
117 /*
118 * Positive cases with an skb consumed by a driver:
119 * - successful transmission (rc == NETDEV_TX_OK)
120 * - error while transmitting (rc < 0)
121 * - error while queueing to a different device (rc & NET_XMIT_MASK)
122 */
123 if (likely(rc < NET_XMIT_MASK))
124 return true;
125
126 return false;
127}
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129#endif
130
131#define MAX_ADDR_LEN 32 /* Largest hardware address length */
132
Adrian Bunkc88e6f52008-06-27 19:54:54 -0700133#ifdef __KERNEL__
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134/*
135 * Compute the worst case header length according to the protocols
136 * used.
137 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800138
David S. Miller8388e3d2008-05-12 20:17:33 -0700139#if defined(CONFIG_WLAN_80211) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
140# if defined(CONFIG_MAC80211_MESH)
141# define LL_MAX_HEADER 128
142# else
143# define LL_MAX_HEADER 96
144# endif
Adrian Bunkc759a6b2009-04-27 02:36:20 -0700145#elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
David S. Miller8388e3d2008-05-12 20:17:33 -0700146# define LL_MAX_HEADER 48
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147#else
David S. Miller8388e3d2008-05-12 20:17:33 -0700148# define LL_MAX_HEADER 32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#endif
150
David S. Millere81c7352006-11-28 20:53:39 -0800151#if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
152 !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
153 !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
154 !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155#define MAX_HEADER LL_MAX_HEADER
156#else
157#define MAX_HEADER (LL_MAX_HEADER + 48)
158#endif
159
Adrian Bunkc88e6f52008-06-27 19:54:54 -0700160#endif /* __KERNEL__ */
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162/*
163 * Network device statistics. Akin to the 2.0 ether stats but
164 * with byte counters.
165 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800166
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800167struct net_device_stats {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 unsigned long rx_packets; /* total packets received */
169 unsigned long tx_packets; /* total packets transmitted */
170 unsigned long rx_bytes; /* total bytes received */
171 unsigned long tx_bytes; /* total bytes transmitted */
172 unsigned long rx_errors; /* bad packets received */
173 unsigned long tx_errors; /* packet transmit problems */
174 unsigned long rx_dropped; /* no space in linux buffers */
175 unsigned long tx_dropped; /* no space available in linux */
176 unsigned long multicast; /* multicast packets received */
177 unsigned long collisions;
178
179 /* detailed rx_errors: */
180 unsigned long rx_length_errors;
181 unsigned long rx_over_errors; /* receiver ring buff overflow */
182 unsigned long rx_crc_errors; /* recved pkt with crc error */
183 unsigned long rx_frame_errors; /* recv'd frame alignment error */
184 unsigned long rx_fifo_errors; /* recv'r fifo overrun */
185 unsigned long rx_missed_errors; /* receiver missed packet */
186
187 /* detailed tx_errors */
188 unsigned long tx_aborted_errors;
189 unsigned long tx_carrier_errors;
190 unsigned long tx_fifo_errors;
191 unsigned long tx_heartbeat_errors;
192 unsigned long tx_window_errors;
193
194 /* for cslip etc */
195 unsigned long rx_compressed;
196 unsigned long tx_compressed;
197};
198
199
200/* Media selection options. */
201enum {
202 IF_PORT_UNKNOWN = 0,
203 IF_PORT_10BASE2,
204 IF_PORT_10BASET,
205 IF_PORT_AUI,
206 IF_PORT_100BASET,
207 IF_PORT_100BASETX,
208 IF_PORT_100BASEFX
209};
210
211#ifdef __KERNEL__
212
213#include <linux/cache.h>
214#include <linux/skbuff.h>
215
216struct neighbour;
217struct neigh_parms;
218struct sk_buff;
219
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800220struct netif_rx_stats {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 unsigned total;
222 unsigned dropped;
223 unsigned time_squeeze;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 unsigned cpu_collision;
225};
226
227DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
228
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800229struct dev_addr_list {
Patrick McHardybf742482007-06-27 01:26:19 -0700230 struct dev_addr_list *next;
231 u8 da_addr[MAX_ADDR_LEN];
232 u8 da_addrlen;
Patrick McHardya0a400d2007-07-14 18:52:02 -0700233 u8 da_synced;
Patrick McHardybf742482007-06-27 01:26:19 -0700234 int da_users;
235 int da_gusers;
236};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238/*
239 * We tag multicasts with these structures.
240 */
Patrick McHardy3fba5a82007-06-27 01:26:58 -0700241
242#define dev_mc_list dev_addr_list
243#define dmi_addr da_addr
244#define dmi_addrlen da_addrlen
245#define dmi_users da_users
246#define dmi_gusers da_gusers
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Jiri Pirkof001fde2009-05-05 02:48:28 +0000248struct netdev_hw_addr {
249 struct list_head list;
250 unsigned char addr[MAX_ADDR_LEN];
251 unsigned char type;
Jiri Pirkoccffad22009-05-22 23:22:17 +0000252#define NETDEV_HW_ADDR_T_LAN 1
253#define NETDEV_HW_ADDR_T_SAN 2
254#define NETDEV_HW_ADDR_T_SLAVE 3
255#define NETDEV_HW_ADDR_T_UNICAST 4
256 int refcount;
257 bool synced;
Jiri Pirkof001fde2009-05-05 02:48:28 +0000258 struct rcu_head rcu_head;
259};
260
Jiri Pirko31278e72009-06-17 01:12:19 +0000261struct netdev_hw_addr_list {
262 struct list_head list;
263 int count;
264};
265
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800266struct hh_cache {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 struct hh_cache *hh_next; /* Next entry */
268 atomic_t hh_refcnt; /* number of users */
Eric Dumazetf0490982006-12-08 00:08:43 -0800269/*
270 * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
271 * cache line on SMP.
272 * They are mostly read, but hh_refcnt may be changed quite frequently,
273 * incurring cache line ping pongs.
274 */
275 __be16 hh_type ____cacheline_aligned_in_smp;
276 /* protocol identifier, f.e ETH_P_IP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 * NOTE: For VLANs, this will be the
278 * encapuslated type. --BLG
279 */
Arnaldo Carvalho de Melod5c42c02006-11-27 17:58:02 -0200280 u16 hh_len; /* length of header */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 int (*hh_output)(struct sk_buff *skb);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800282 seqlock_t hh_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
284 /* cached hardware header; allow for machine alignment needs. */
285#define HH_DATA_MOD 16
286#define HH_DATA_OFF(__len) \
Jiri Benc5ba0eac2005-06-02 16:48:05 -0700287 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288#define HH_DATA_ALIGN(__len) \
289 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
290 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
291};
292
293/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
294 * Alternative is:
295 * dev->hard_header_len ? (dev->hard_header_len +
296 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
297 *
298 * We could use other alignment values, but we must maintain the
299 * relationship HH alignment <= LL alignment.
Johannes Bergf5184d22008-05-12 20:48:31 -0700300 *
301 * LL_ALLOCATED_SPACE also takes into account the tailroom the device
302 * may need.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 */
304#define LL_RESERVED_SPACE(dev) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700305 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700307 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
308#define LL_ALLOCATED_SPACE(dev) \
309 ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700311struct header_ops {
312 int (*create) (struct sk_buff *skb, struct net_device *dev,
313 unsigned short type, const void *daddr,
314 const void *saddr, unsigned len);
315 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
316 int (*rebuild)(struct sk_buff *skb);
317#define HAVE_HEADER_CACHE
318 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
319 void (*cache_update)(struct hh_cache *hh,
320 const struct net_device *dev,
321 const unsigned char *haddr);
322};
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324/* These flag bits are private to the generic network queueing
325 * layer, they may not be explicitly referenced by any other
326 * code.
327 */
328
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800329enum netdev_state_t {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 __LINK_STATE_START,
331 __LINK_STATE_PRESENT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 __LINK_STATE_NOCARRIER,
Stefan Rompfb00055a2006-03-20 17:09:11 -0800333 __LINK_STATE_LINKWATCH_PENDING,
334 __LINK_STATE_DORMANT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335};
336
337
338/*
339 * This structure holds at boot time configured netdevice settings. They
Graf Yangfe2918b2009-02-05 21:26:19 -0800340 * are then used in the device probing.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 */
342struct netdev_boot_setup {
343 char name[IFNAMSIZ];
344 struct ifmap map;
345};
346#define NETDEV_BOOT_SETUP_MAX 8
347
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -0300348extern int __init netdev_boot_setup(char *str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350/*
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700351 * Structure for NAPI scheduling similar to tasklet but with weighting
352 */
353struct napi_struct {
354 /* The poll_list must only be managed by the entity which
355 * changes the state of the NAPI_STATE_SCHED bit. This means
356 * whoever atomically sets that bit can add this napi_struct
357 * to the per-cpu poll_list, and whoever clears that bit
358 * can remove from the list right before clearing the bit.
359 */
360 struct list_head poll_list;
361
362 unsigned long state;
363 int weight;
364 int (*poll)(struct napi_struct *, int);
365#ifdef CONFIG_NETPOLL
366 spinlock_t poll_lock;
367 int poll_owner;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700368#endif
Herbert Xu4ae55442009-02-08 18:00:36 +0000369
370 unsigned int gro_count;
371
Herbert Xu5d38a072009-01-04 16:13:40 -0800372 struct net_device *dev;
Herbert Xud565b0a2008-12-15 23:38:52 -0800373 struct list_head dev_list;
374 struct sk_buff *gro_list;
Herbert Xu5d38a072009-01-04 16:13:40 -0800375 struct sk_buff *skb;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700376};
377
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800378enum {
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700379 NAPI_STATE_SCHED, /* Poll is scheduled */
David S. Millera0a46192008-01-07 20:35:07 -0800380 NAPI_STATE_DISABLE, /* Disable pending */
Neil Horman7b363e42008-12-09 23:22:26 -0800381 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700382};
383
Ben Hutchings5b252f02009-10-29 07:17:09 +0000384enum gro_result {
Herbert Xud1c76af2009-03-16 10:50:02 -0700385 GRO_MERGED,
386 GRO_MERGED_FREE,
387 GRO_HELD,
388 GRO_NORMAL,
389 GRO_DROP,
390};
Ben Hutchings5b252f02009-10-29 07:17:09 +0000391typedef enum gro_result gro_result_t;
Herbert Xud1c76af2009-03-16 10:50:02 -0700392
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800393extern void __napi_schedule(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700394
David S. Millera0a46192008-01-07 20:35:07 -0800395static inline int napi_disable_pending(struct napi_struct *n)
396{
397 return test_bit(NAPI_STATE_DISABLE, &n->state);
398}
399
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700400/**
401 * napi_schedule_prep - check if napi can be scheduled
402 * @n: napi context
403 *
404 * Test if NAPI routine is already running, and if not mark
405 * it as running. This is used as a condition variable
David S. Millera0a46192008-01-07 20:35:07 -0800406 * insure only one NAPI poll instance runs. We also make
407 * sure there is no pending NAPI disable.
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700408 */
409static inline int napi_schedule_prep(struct napi_struct *n)
410{
David S. Millera0a46192008-01-07 20:35:07 -0800411 return !napi_disable_pending(n) &&
412 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700413}
414
415/**
416 * napi_schedule - schedule NAPI poll
417 * @n: napi context
418 *
419 * Schedule NAPI poll routine to be called if it is not already
420 * running.
421 */
422static inline void napi_schedule(struct napi_struct *n)
423{
424 if (napi_schedule_prep(n))
425 __napi_schedule(n);
426}
427
Roland Dreierbfe13f52007-10-09 15:47:37 -0700428/* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
429static inline int napi_reschedule(struct napi_struct *napi)
430{
431 if (napi_schedule_prep(napi)) {
432 __napi_schedule(napi);
433 return 1;
434 }
435 return 0;
436}
437
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700438/**
439 * napi_complete - NAPI processing complete
440 * @n: napi context
441 *
442 * Mark NAPI processing as complete.
443 */
Herbert Xud565b0a2008-12-15 23:38:52 -0800444extern void __napi_complete(struct napi_struct *n);
445extern void napi_complete(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700446
447/**
448 * napi_disable - prevent NAPI from scheduling
449 * @n: napi context
450 *
451 * Stop NAPI from being scheduled on this context.
452 * Waits till any outstanding processing completes.
453 */
454static inline void napi_disable(struct napi_struct *n)
455{
David S. Millera0a46192008-01-07 20:35:07 -0800456 set_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700457 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
Benjamin Herrenschmidt43cc7382007-10-26 04:23:22 -0700458 msleep(1);
David S. Millera0a46192008-01-07 20:35:07 -0800459 clear_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700460}
461
462/**
463 * napi_enable - enable NAPI scheduling
464 * @n: napi context
465 *
466 * Resume NAPI from being scheduled on this context.
467 * Must be paired with napi_disable.
468 */
469static inline void napi_enable(struct napi_struct *n)
470{
471 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
472 smp_mb__before_clear_bit();
473 clear_bit(NAPI_STATE_SCHED, &n->state);
474}
475
Stephen Hemmingerc264c3d2007-10-17 13:26:41 -0700476#ifdef CONFIG_SMP
477/**
478 * napi_synchronize - wait until NAPI is not running
479 * @n: napi context
480 *
481 * Wait until NAPI is done being scheduled on this context.
482 * Waits till any outstanding processing completes but
483 * does not disable future activations.
484 */
485static inline void napi_synchronize(const struct napi_struct *n)
486{
487 while (test_bit(NAPI_STATE_SCHED, &n->state))
488 msleep(1);
489}
490#else
491# define napi_synchronize(n) barrier()
492#endif
493
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800494enum netdev_queue_state_t {
David S. Miller79d16382008-07-08 23:14:46 -0700495 __QUEUE_STATE_XOFF,
David S. Millerc3f26a22008-07-31 16:58:50 -0700496 __QUEUE_STATE_FROZEN,
David S. Miller79d16382008-07-08 23:14:46 -0700497};
498
David S. Millerbb949fb2008-07-08 16:55:56 -0700499struct netdev_queue {
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700500/*
501 * read mostly part
502 */
David S. Millerbb949fb2008-07-08 16:55:56 -0700503 struct net_device *dev;
David S. Millerb0e1e642008-07-08 17:42:10 -0700504 struct Qdisc *qdisc;
David S. Miller79d16382008-07-08 23:14:46 -0700505 unsigned long state;
David S. Millerb0e1e642008-07-08 17:42:10 -0700506 struct Qdisc *qdisc_sleeping;
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700507/*
508 * write mostly part
509 */
510 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
511 int xmit_lock_owner;
Eric Dumazet9d214932009-05-17 20:55:16 -0700512 /*
513 * please use this field instead of dev->trans_start
514 */
515 unsigned long trans_start;
Eric Dumazet7004bf22009-05-18 00:34:33 +0000516 unsigned long tx_bytes;
517 unsigned long tx_packets;
518 unsigned long tx_dropped;
David S. Millere8a04642008-07-17 00:34:19 -0700519} ____cacheline_aligned_in_smp;
David S. Millerbb949fb2008-07-08 16:55:56 -0700520
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800521
522/*
523 * This structure defines the management hooks for network devices.
Stephen Hemminger00829822008-11-20 20:14:53 -0800524 * The following hooks can be defined; unless noted otherwise, they are
525 * optional and can be filled with a null pointer.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800526 *
527 * int (*ndo_init)(struct net_device *dev);
528 * This function is called once when network device is registered.
529 * The network device can use this to any late stage initializaton
530 * or semantic validattion. It can fail with an error code which will
531 * be propogated back to register_netdev
532 *
533 * void (*ndo_uninit)(struct net_device *dev);
534 * This function is called when device is unregistered or when registration
535 * fails. It is not called if init fails.
536 *
537 * int (*ndo_open)(struct net_device *dev);
538 * This function is called when network device transistions to the up
539 * state.
540 *
541 * int (*ndo_stop)(struct net_device *dev);
542 * This function is called when network device transistions to the down
543 * state.
544 *
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000545 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
546 * struct net_device *dev);
Stephen Hemminger00829822008-11-20 20:14:53 -0800547 * Called when a packet needs to be transmitted.
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000548 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
549 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
Stephen Hemminger00829822008-11-20 20:14:53 -0800550 * Required can not be NULL.
551 *
552 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
553 * Called to decide which queue to when device supports multiple
554 * transmit queues.
555 *
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800556 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
557 * This function is called to allow device receiver to make
558 * changes to configuration when multicast or promiscious is enabled.
559 *
560 * void (*ndo_set_rx_mode)(struct net_device *dev);
561 * This function is called device changes address list filtering.
562 *
563 * void (*ndo_set_multicast_list)(struct net_device *dev);
564 * This function is called when the multicast address list changes.
565 *
566 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
567 * This function is called when the Media Access Control address
Mike Rapoport37b607c2009-04-27 05:45:54 -0700568 * needs to be changed. If this interface is not defined, the
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800569 * mac address can not be changed.
570 *
571 * int (*ndo_validate_addr)(struct net_device *dev);
572 * Test if Media Access Control address is valid for the device.
573 *
574 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
575 * Called when a user request an ioctl which can't be handled by
576 * the generic interface code. If not defined ioctl's return
577 * not supported error code.
578 *
579 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
580 * Used to set network devices bus interface parameters. This interface
581 * is retained for legacy reason, new devices should use the bus
582 * interface (PCI) for low level management.
583 *
584 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
585 * Called when a user wants to change the Maximum Transfer Unit
586 * of a device. If not defined, any request to change MTU will
587 * will return an error.
588 *
Stephen Hemminger00829822008-11-20 20:14:53 -0800589 * void (*ndo_tx_timeout)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800590 * Callback uses when the transmitter has not made any progress
591 * for dev->watchdog ticks.
592 *
Wolfram Sangd308e382009-10-07 13:53:11 -0700593 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800594 * Called when a user wants to get the network device usage
595 * statistics. If not defined, the counters in dev->stats will
596 * be used.
597 *
598 * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
599 * If device support VLAN receive accleration
600 * (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
601 * when vlan groups for the device changes. Note: grp is NULL
602 * if no vlan's groups are being used.
603 *
604 * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
605 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
606 * this function is called when a VLAN id is registered.
607 *
608 * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
609 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
610 * this function is called when a VLAN id is unregistered.
611 *
612 * void (*ndo_poll_controller)(struct net_device *dev);
613 */
Stephen Hemminger47fd5b82008-11-25 00:20:43 -0800614#define HAVE_NET_DEVICE_OPS
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800615struct net_device_ops {
616 int (*ndo_init)(struct net_device *dev);
617 void (*ndo_uninit)(struct net_device *dev);
618 int (*ndo_open)(struct net_device *dev);
619 int (*ndo_stop)(struct net_device *dev);
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000620 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,
Stephen Hemminger00829822008-11-20 20:14:53 -0800621 struct net_device *dev);
622 u16 (*ndo_select_queue)(struct net_device *dev,
623 struct sk_buff *skb);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800624#define HAVE_CHANGE_RX_FLAGS
625 void (*ndo_change_rx_flags)(struct net_device *dev,
626 int flags);
627#define HAVE_SET_RX_MODE
628 void (*ndo_set_rx_mode)(struct net_device *dev);
629#define HAVE_MULTICAST
630 void (*ndo_set_multicast_list)(struct net_device *dev);
631#define HAVE_SET_MAC_ADDR
632 int (*ndo_set_mac_address)(struct net_device *dev,
633 void *addr);
634#define HAVE_VALIDATE_ADDR
635 int (*ndo_validate_addr)(struct net_device *dev);
636#define HAVE_PRIVATE_IOCTL
637 int (*ndo_do_ioctl)(struct net_device *dev,
638 struct ifreq *ifr, int cmd);
639#define HAVE_SET_CONFIG
640 int (*ndo_set_config)(struct net_device *dev,
641 struct ifmap *map);
642#define HAVE_CHANGE_MTU
Stephen Hemminger00829822008-11-20 20:14:53 -0800643 int (*ndo_change_mtu)(struct net_device *dev,
644 int new_mtu);
645 int (*ndo_neigh_setup)(struct net_device *dev,
646 struct neigh_parms *);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800647#define HAVE_TX_TIMEOUT
648 void (*ndo_tx_timeout) (struct net_device *dev);
649
650 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
651
652 void (*ndo_vlan_rx_register)(struct net_device *dev,
653 struct vlan_group *grp);
654 void (*ndo_vlan_rx_add_vid)(struct net_device *dev,
655 unsigned short vid);
656 void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
657 unsigned short vid);
658#ifdef CONFIG_NET_POLL_CONTROLLER
659#define HAVE_NETDEV_POLL
660 void (*ndo_poll_controller)(struct net_device *dev);
661#endif
Yi Zou4d288d52009-02-27 14:06:59 -0800662#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
Yi Zoucb454392009-08-31 12:31:36 +0000663 int (*ndo_fcoe_enable)(struct net_device *dev);
664 int (*ndo_fcoe_disable)(struct net_device *dev);
Yi Zou4d288d52009-02-27 14:06:59 -0800665 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
666 u16 xid,
667 struct scatterlist *sgl,
668 unsigned int sgc);
669 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
670 u16 xid);
Yi Zoudf5c7942009-10-28 18:24:35 +0000671#define NETDEV_FCOE_WWNN 0
672#define NETDEV_FCOE_WWPN 1
673 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
674 u64 *wwn, int type);
Yi Zou4d288d52009-02-27 14:06:59 -0800675#endif
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800676};
677
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700678/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 * The DEVICE structure.
680 * Actually, this whole structure is a big mistake. It mixes I/O
681 * data with strictly "high-level" data, and it has to know about
682 * almost every data structure used in the INET module.
683 *
684 * FIXME: cleanup struct net_device such that network protocol info
685 * moves out.
686 */
687
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800688struct net_device {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 /*
691 * This is the first field of the "visible" part of this structure
692 * (i.e. as seen by users in the "Space.c" file). It is the name
693 * the interface.
694 */
695 char name[IFNAMSIZ];
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700696 /* device name hash chain */
697 struct hlist_node name_hlist;
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700698 /* snmp alias */
699 char *ifalias;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
701 /*
702 * I/O specific fields
703 * FIXME: Merge these and struct ifmap into one
704 */
705 unsigned long mem_end; /* shared mem end */
706 unsigned long mem_start; /* shared mem start */
707 unsigned long base_addr; /* device I/O address */
708 unsigned int irq; /* device IRQ number */
709
710 /*
711 * Some hardware also needs these fields, but they are not
712 * part of the usual set specified in Space.c.
713 */
714
715 unsigned char if_port; /* Selectable AUI, TP,..*/
716 unsigned char dma; /* DMA channel */
717
718 unsigned long state;
719
Pavel Emelianov7562f872007-05-03 15:13:45 -0700720 struct list_head dev_list;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700721 struct list_head napi_list;
Eric Dumazet44a08732009-10-27 07:03:04 +0000722 struct list_head unreg_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700724 /* Net device features */
725 unsigned long features;
726#define NETIF_F_SG 1 /* Scatter/gather IO. */
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700727#define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700728#define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
729#define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700730#define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700731#define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
732#define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
733#define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
734#define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
735#define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
736#define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
Herbert Xu37c31852006-06-22 03:07:29 -0700737#define NETIF_F_GSO 2048 /* Enable software GSO. */
Christian Borntraegere24eb522007-09-25 19:42:02 -0700738#define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */
739 /* do not use LLTX in new drivers */
Eric W. Biedermance286d32007-09-12 13:53:49 +0200740#define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */
Herbert Xud565b0a2008-12-15 23:38:52 -0800741#define NETIF_F_GRO 16384 /* Generic receive offload */
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700742#define NETIF_F_LRO 32768 /* large receive offload */
Herbert Xu79671682006-06-22 02:40:14 -0700743
Jesse Brandeburg8dc92f72009-04-27 22:35:52 +0000744/* the GSO_MASK reserves bits 16 through 23 */
Chris Leech01d5b2f2009-02-27 14:06:49 -0800745#define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */
Jesse Brandeburg8dc92f72009-04-27 22:35:52 +0000746#define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */
Yi Zoubb2af4f2009-08-14 12:41:57 +0000747#define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
Chris Leech01d5b2f2009-02-27 14:06:49 -0800748
Herbert Xu79671682006-06-22 02:40:14 -0700749 /* Segmentation offload features */
Patrick McHardy289c79a2008-05-23 00:22:04 -0700750#define NETIF_F_GSO_SHIFT 16
Chris Leech43eb99c2009-02-27 14:06:43 -0800751#define NETIF_F_GSO_MASK 0x00ff0000
Herbert Xu79671682006-06-22 02:40:14 -0700752#define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700753#define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
Herbert Xu576a30e2006-06-27 13:22:38 -0700754#define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700755#define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
756#define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
Chris Leech01d5b2f2009-02-27 14:06:49 -0800757#define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700758
Herbert Xu78eb8872006-08-17 18:22:32 -0700759 /* List of features with software fallbacks. */
760#define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)
761
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700762
Herbert Xu8648b302006-06-17 22:06:05 -0700763#define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700764#define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
765#define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
766#define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
Herbert Xu8648b302006-06-17 22:06:05 -0700767
Herbert Xub63365a2008-10-23 01:11:29 -0700768 /*
769 * If one device supports one of these features, then enable them
770 * for all in netdev_increment_features.
771 */
772#define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800773 NETIF_F_SG | NETIF_F_HIGHDMA | \
Herbert Xub63365a2008-10-23 01:11:29 -0700774 NETIF_F_FRAGLIST)
775
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 /* Interface index. Unique device identifier */
777 int ifindex;
778 int iflink;
779
Rusty Russellc45d2862007-03-28 14:29:08 -0700780 struct net_device_stats stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781
Johannes Bergb86e0282007-04-26 20:48:23 -0700782#ifdef CONFIG_WIRELESS_EXT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 /* List of functions to handle Wireless Extensions (instead of ioctl).
784 * See <net/iw_handler.h> for details. Jean II */
785 const struct iw_handler_def * wireless_handlers;
786 /* Instance data managed by the core of Wireless Extensions. */
787 struct iw_public_data * wireless_data;
Johannes Bergb86e0282007-04-26 20:48:23 -0700788#endif
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800789 /* Management operations */
790 const struct net_device_ops *netdev_ops;
Stephen Hemminger76fd8592006-09-08 11:16:13 -0700791 const struct ethtool_ops *ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700793 /* Hardware header description */
794 const struct header_ops *header_ops;
795
Stefan Rompfb00055a2006-03-20 17:09:11 -0800796 unsigned int flags; /* interface flags (a la BSD) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 unsigned short gflags;
798 unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */
799 unsigned short padded; /* How much padding added by alloc_netdev() */
800
Stefan Rompfb00055a2006-03-20 17:09:11 -0800801 unsigned char operstate; /* RFC2863 operstate */
802 unsigned char link_mode; /* mapping policy to operstate */
803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 unsigned mtu; /* interface MTU value */
805 unsigned short type; /* interface hardware type */
806 unsigned short hard_header_len; /* hardware hdr length */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
Johannes Bergf5184d22008-05-12 20:48:31 -0700808 /* extra head- and tailroom the hardware may need, but not in all cases
809 * can this be guaranteed, especially tailroom. Some cases also use
810 * LL_MAX_HEADER instead to allocate the skb.
811 */
812 unsigned short needed_headroom;
813 unsigned short needed_tailroom;
814
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 struct net_device *master; /* Pointer to master device of a group,
816 * which this device is member of.
817 */
818
819 /* Interface address info. */
Jon Wetzela6f9a702005-08-20 17:15:54 -0700820 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 unsigned char addr_len; /* hardware address length */
822 unsigned short dev_id; /* for shared network cards */
823
Jiri Pirko31278e72009-06-17 01:12:19 +0000824 struct netdev_hw_addr_list uc; /* Secondary unicast
825 mac addresses */
Patrick McHardy4417da62007-06-27 01:28:10 -0700826 int uc_promisc;
Jiri Pirkoccffad22009-05-22 23:22:17 +0000827 spinlock_t addr_list_lock;
Patrick McHardy3fba5a82007-06-27 01:26:58 -0700828 struct dev_addr_list *mc_list; /* Multicast mac addresses */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 int mc_count; /* Number of installed mcasts */
Wang Chen9d45abe2008-06-17 21:12:48 -0700830 unsigned int promiscuity;
831 unsigned int allmulti;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 /* Protocol specific pointers */
835
Lennert Buytenhek91da11f2008-10-07 13:44:02 +0000836#ifdef CONFIG_NET_DSA
837 void *dsa_ptr; /* dsa specific data */
838#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 void *atalk_ptr; /* AppleTalk link */
Graf Yangfe2918b2009-02-05 21:26:19 -0800840 void *ip_ptr; /* IPv4 specific data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 void *dn_ptr; /* DECnet specific data */
842 void *ip6_ptr; /* IPv6 specific data */
843 void *ec_ptr; /* Econet specific data */
844 void *ax25_ptr; /* AX.25 specific data */
Johannes Berg704232c2007-04-23 12:20:05 -0700845 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
846 assign before registering */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700848/*
849 * Cache line mostly used on receive path (including eth_type_trans())
850 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700851 unsigned long last_rx; /* Time of last Rx */
852 /* Interface address info used in eth_type_trans() */
Jiri Pirkof001fde2009-05-05 02:48:28 +0000853 unsigned char *dev_addr; /* hw address, (before bcast
854 because most packets are
855 unicast) */
856
Jiri Pirko31278e72009-06-17 01:12:19 +0000857 struct netdev_hw_addr_list dev_addrs; /* list of device
858 hw addresses */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700860 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
861
David S. Millerbb949fb2008-07-08 16:55:56 -0700862 struct netdev_queue rx_queue;
David S. Millere8a04642008-07-17 00:34:19 -0700863
864 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700865
866 /* Number of TX queues allocated at alloc_netdev_mq() time */
David S. Millere8a04642008-07-17 00:34:19 -0700867 unsigned int num_tx_queues;
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700868
869 /* Number of TX queues currently active in device */
870 unsigned int real_num_tx_queues;
871
Patrick McHardyaf356af2009-09-04 06:41:18 +0000872 /* root qdisc from userspace point of view */
873 struct Qdisc *qdisc;
874
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 unsigned long tx_queue_len; /* Max frames per queue allowed */
David S. Millerc3f26a22008-07-31 16:58:50 -0700876 spinlock_t tx_global_lock;
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700877/*
878 * One part is mostly used on xmit path (device)
879 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700880 /* These may be needed for future network-power-down code. */
Eric Dumazet9d214932009-05-17 20:55:16 -0700881
882 /*
883 * trans_start here is expensive for high speed devices on SMP,
884 * please use netdev_queue->trans_start instead.
885 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700886 unsigned long trans_start; /* Time (in jiffies) of last Tx */
887
888 int watchdog_timeo; /* used by dev_watchdog() */
889 struct timer_list watchdog_timer;
890
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 /* Number of references to this device */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700892 atomic_t refcnt ____cacheline_aligned_in_smp;
893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 /* delayed register/unregister */
895 struct list_head todo_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 /* device index hash chain */
897 struct hlist_node index_hlist;
898
Eric Dumazete014deb2009-11-17 05:59:21 +0000899 struct list_head link_watch_list;
Herbert Xu572a1032007-05-08 18:34:17 -0700900
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 /* register/unregister state machine */
902 enum { NETREG_UNINITIALIZED=0,
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -0700903 NETREG_REGISTERED, /* completed register_netdevice */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 NETREG_UNREGISTERING, /* called unregister_netdevice */
905 NETREG_UNREGISTERED, /* completed unregister todo */
906 NETREG_RELEASED, /* called free_netdev */
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -0800907 NETREG_DUMMY, /* dummy device for NAPI poll */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 } reg_state;
909
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800910 /* Called from unregister, can be used to call free_netdev */
911 void (*destructor)(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913#ifdef CONFIG_NETPOLL
Jeff Moyer115c1d62005-06-22 22:05:31 -0700914 struct netpoll_info *npinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915#endif
David S. Millereae792b2008-07-15 03:03:33 -0700916
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900917#ifdef CONFIG_NET_NS
Eric W. Biederman4a1c5372007-09-12 11:56:32 +0200918 /* Network namespace this network device is inside */
919 struct net *nd_net;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900920#endif
Eric W. Biederman4a1c5372007-09-12 11:56:32 +0200921
David S. Miller49517042008-05-12 03:29:11 -0700922 /* mid-layer private */
923 void *ml_priv;
924
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 /* bridge stuff */
926 struct net_bridge_port *br_port;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700927 /* macvlan */
928 struct macvlan_port *macvlan_port;
Patrick McHardyeca9eba2008-07-05 21:26:13 -0700929 /* GARP */
930 struct garp_port *garp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 /* class/net/name entry */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700933 struct device dev;
Eric W. Biederman0c509a62009-10-29 14:18:21 +0000934 /* space for optional device, statistics, and wireless sysfs groups */
935 const struct attribute_group *sysfs_groups[4];
Patrick McHardy38f7b872007-06-13 12:03:51 -0700936
937 /* rtnetlink link ops */
938 const struct rtnl_link_ops *rtnl_link_ops;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700939
Patrick McHardy289c79a2008-05-23 00:22:04 -0700940 /* VLAN feature mask */
941 unsigned long vlan_features;
942
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -0700943 /* for setting kernel sock attribute on TCP connection setup */
944#define GSO_MAX_SIZE 65536
945 unsigned int gso_max_size;
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800946
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -0800947#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -0800948 /* Data Center Bridging netlink ops */
Stephen Hemminger32953542009-10-05 06:01:03 +0000949 const struct dcbnl_rtnl_ops *dcbnl_ops;
Alexander Duyck2f90b862008-11-20 20:52:10 -0800950#endif
951
Yi Zou4d288d52009-02-27 14:06:59 -0800952#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
953 /* max exchange id for FCoE LRO by ddp */
954 unsigned int fcoe_ddp_xid;
955#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956};
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700957#define to_net_dev(d) container_of(d, struct net_device, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
959#define NETDEV_ALIGN 32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960
David S. Millere8a04642008-07-17 00:34:19 -0700961static inline
962struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
963 unsigned int index)
964{
965 return &dev->_tx[index];
966}
967
968static inline void netdev_for_each_tx_queue(struct net_device *dev,
969 void (*f)(struct net_device *,
970 struct netdev_queue *,
971 void *),
972 void *arg)
973{
974 unsigned int i;
975
976 for (i = 0; i < dev->num_tx_queues; i++)
977 f(dev, &dev->_tx[i], arg);
978}
979
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900980/*
981 * Net namespace inlines
982 */
983static inline
984struct net *dev_net(const struct net_device *dev)
985{
986#ifdef CONFIG_NET_NS
987 return dev->nd_net;
988#else
989 return &init_net;
990#endif
991}
992
993static inline
Denis V. Lunevf5aa23f2008-03-26 00:48:17 -0700994void dev_net_set(struct net_device *dev, struct net *net)
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900995{
996#ifdef CONFIG_NET_NS
Denis V. Lunevf3005d72008-04-16 02:02:18 -0700997 release_net(dev->nd_net);
998 dev->nd_net = hold_net(net);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900999#endif
1000}
1001
Lennert Buytenhekcf85d082008-10-07 13:45:02 +00001002static inline bool netdev_uses_dsa_tags(struct net_device *dev)
1003{
1004#ifdef CONFIG_NET_DSA_TAG_DSA
1005 if (dev->dsa_ptr != NULL)
1006 return dsa_uses_dsa_tags(dev->dsa_ptr);
1007#endif
1008
1009 return 0;
1010}
1011
Lennert Buytenhek396138f2008-10-07 13:46:07 +00001012static inline bool netdev_uses_trailer_tags(struct net_device *dev)
1013{
1014#ifdef CONFIG_NET_DSA_TAG_TRAILER
1015 if (dev->dsa_ptr != NULL)
1016 return dsa_uses_trailer_tags(dev->dsa_ptr);
1017#endif
1018
1019 return 0;
1020}
1021
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001022/**
1023 * netdev_priv - access network device private data
1024 * @dev: network device
1025 *
1026 * Get network device private data
1027 */
Patrick McHardy6472ce62007-06-13 12:03:21 -07001028static inline void *netdev_priv(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029{
Eric Dumazet1ce8e7b2009-05-27 04:42:37 +00001030 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031}
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033/* Set the sysfs physical device reference for the network logical device
1034 * if set prior to registration will cause a symlink during initialization.
1035 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001036#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
Marcel Holtmann384912e2009-08-31 21:08:19 +00001038/* Set the sysfs device type for the network logical device to allow
1039 * fin grained indentification of different network device types. For
1040 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
1041 */
1042#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
1043
Stephen Hemminger3b582cc2007-11-01 02:21:47 -07001044/**
1045 * netif_napi_add - initialize a napi context
1046 * @dev: network device
1047 * @napi: napi context
1048 * @poll: polling function
1049 * @weight: default weight
1050 *
1051 * netif_napi_add() must be used to initialize a napi context prior to calling
1052 * *any* of the other napi related functions.
1053 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001054void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
1055 int (*poll)(struct napi_struct *, int), int weight);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001056
Alexander Duyckd8156532008-07-08 15:13:05 -07001057/**
1058 * netif_napi_del - remove a napi context
1059 * @napi: napi context
1060 *
1061 * netif_napi_del() removes a napi context from the network device napi list
1062 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001063void netif_napi_del(struct napi_struct *napi);
1064
1065struct napi_gro_cb {
Herbert Xu78a478d2009-05-26 18:50:21 +00001066 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
1067 void *frag0;
1068
Herbert Xu74895942009-05-26 18:50:27 +00001069 /* Length of frag0. */
1070 unsigned int frag0_len;
1071
Herbert Xu86911732009-01-29 14:19:50 +00001072 /* This indicates where we are processing relative to skb->data. */
1073 int data_offset;
1074
Herbert Xud565b0a2008-12-15 23:38:52 -08001075 /* This is non-zero if the packet may be of the same flow. */
1076 int same_flow;
1077
1078 /* This is non-zero if the packet cannot be merged with the new skb. */
1079 int flush;
1080
1081 /* Number of segments aggregated. */
1082 int count;
Herbert Xu5d38a072009-01-04 16:13:40 -08001083
1084 /* Free the skb? */
1085 int free;
Herbert Xud565b0a2008-12-15 23:38:52 -08001086};
1087
1088#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
Alexander Duyckd8156532008-07-08 15:13:05 -07001089
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090struct packet_type {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001091 __be16 type; /* This is really htons(ether_type). */
1092 struct net_device *dev; /* NULL is wildcarded here */
1093 int (*func) (struct sk_buff *,
1094 struct net_device *,
1095 struct packet_type *,
1096 struct net_device *);
Herbert Xu576a30e2006-06-27 13:22:38 -07001097 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
1098 int features);
Herbert Xua430a432006-07-08 13:34:56 -07001099 int (*gso_send_check)(struct sk_buff *skb);
Herbert Xud565b0a2008-12-15 23:38:52 -08001100 struct sk_buff **(*gro_receive)(struct sk_buff **head,
1101 struct sk_buff *skb);
1102 int (*gro_complete)(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 void *af_packet_priv;
1104 struct list_head list;
1105};
1106
1107#include <linux/interrupt.h>
1108#include <linux/notifier.h>
1109
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110extern rwlock_t dev_base_lock; /* Device list lock */
1111
Eric W. Biederman881d9662007-09-17 11:56:21 -07001112
1113#define for_each_netdev(net, d) \
1114 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
Eric W. Biedermandcbccbd42009-11-29 22:25:26 +00001115#define for_each_netdev_reverse(net, d) \
1116 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001117#define for_each_netdev_rcu(net, d) \
1118 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
Eric W. Biederman881d9662007-09-17 11:56:21 -07001119#define for_each_netdev_safe(net, d, n) \
1120 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
1121#define for_each_netdev_continue(net, d) \
1122 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
stephen hemminger254245d2009-11-10 07:54:47 +00001123#define for_each_netdev_continue_rcu(net, d) \
1124 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001125#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
1126
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001127static inline struct net_device *next_net_device(struct net_device *dev)
1128{
1129 struct list_head *lh;
1130 struct net *net;
Pavel Emelianov7562f872007-05-03 15:13:45 -07001131
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001132 net = dev_net(dev);
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001133 lh = dev->dev_list.next;
1134 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1135}
1136
Eric Dumazetce81b762009-11-11 17:34:30 +00001137static inline struct net_device *next_net_device_rcu(struct net_device *dev)
1138{
1139 struct list_head *lh;
1140 struct net *net;
1141
1142 net = dev_net(dev);
1143 lh = rcu_dereference(dev->dev_list.next);
1144 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1145}
1146
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001147static inline struct net_device *first_net_device(struct net *net)
1148{
1149 return list_empty(&net->dev_base_head) ? NULL :
1150 net_device_entry(net->dev_base_head.next);
1151}
Pavel Emelianov7562f872007-05-03 15:13:45 -07001152
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153extern int netdev_boot_setup_check(struct net_device *dev);
1154extern unsigned long netdev_boot_base(const char *prefix, int unit);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001155extern struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);
1156extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
1157extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158extern void dev_add_pack(struct packet_type *pt);
1159extern void dev_remove_pack(struct packet_type *pt);
1160extern void __dev_remove_pack(struct packet_type *pt);
1161
Eric W. Biederman881d9662007-09-17 11:56:21 -07001162extern struct net_device *dev_get_by_flags(struct net *net, unsigned short flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 unsigned short mask);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001164extern struct net_device *dev_get_by_name(struct net *net, const char *name);
Eric Dumazet72c95282009-10-30 07:11:27 +00001165extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001166extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167extern int dev_alloc_name(struct net_device *dev, const char *name);
1168extern int dev_open(struct net_device *dev);
1169extern int dev_close(struct net_device *dev);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001170extern void dev_disable_lro(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171extern int dev_queue_xmit(struct sk_buff *skb);
1172extern int register_netdevice(struct net_device *dev);
Eric Dumazet44a08732009-10-27 07:03:04 +00001173extern void unregister_netdevice_queue(struct net_device *dev,
1174 struct list_head *head);
Eric Dumazet9b5e3832009-10-27 07:04:19 +00001175extern void unregister_netdevice_many(struct list_head *head);
Eric Dumazet44a08732009-10-27 07:03:04 +00001176static inline void unregister_netdevice(struct net_device *dev)
1177{
1178 unregister_netdevice_queue(dev, NULL);
1179}
1180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181extern void free_netdev(struct net_device *dev);
1182extern void synchronize_net(void);
1183extern int register_netdevice_notifier(struct notifier_block *nb);
1184extern int unregister_netdevice_notifier(struct notifier_block *nb);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001185extern int init_dummy_netdev(struct net_device *dev);
David S. Miller9d40bbd2009-03-04 23:46:25 -08001186extern void netdev_resync_ops(struct net_device *dev);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001187
Eric W. Biedermanad7379d2007-09-16 15:33:32 -07001188extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001189extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
1190extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
Eric Dumazetfb699dfd2009-10-19 19:18:49 +00001191extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192extern int dev_restart(struct net_device *dev);
1193#ifdef CONFIG_NETPOLL_TRAP
1194extern int netpoll_trap(void);
1195#endif
Herbert Xu86911732009-01-29 14:19:50 +00001196extern int skb_gro_receive(struct sk_buff **head,
1197 struct sk_buff *skb);
Herbert Xu78a478d2009-05-26 18:50:21 +00001198extern void skb_gro_reset_offset(struct sk_buff *skb);
Herbert Xu86911732009-01-29 14:19:50 +00001199
1200static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
1201{
1202 return NAPI_GRO_CB(skb)->data_offset;
1203}
1204
1205static inline unsigned int skb_gro_len(const struct sk_buff *skb)
1206{
1207 return skb->len - NAPI_GRO_CB(skb)->data_offset;
1208}
1209
1210static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
1211{
1212 NAPI_GRO_CB(skb)->data_offset += len;
1213}
1214
Herbert Xua5b1cf22009-05-26 18:50:28 +00001215static inline void *skb_gro_header_fast(struct sk_buff *skb,
1216 unsigned int offset)
Herbert Xu86911732009-01-29 14:19:50 +00001217{
Herbert Xu78a478d2009-05-26 18:50:21 +00001218 return NAPI_GRO_CB(skb)->frag0 + offset;
Herbert Xu86911732009-01-29 14:19:50 +00001219}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
Herbert Xua5b1cf22009-05-26 18:50:28 +00001221static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
1222{
1223 return NAPI_GRO_CB(skb)->frag0_len < hlen;
1224}
1225
1226static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
1227 unsigned int offset)
1228{
1229 NAPI_GRO_CB(skb)->frag0 = NULL;
1230 NAPI_GRO_CB(skb)->frag0_len = 0;
1231 return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
1232}
1233
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001234static inline void *skb_gro_mac_header(struct sk_buff *skb)
1235{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001236 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001237}
1238
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001239static inline void *skb_gro_network_header(struct sk_buff *skb)
1240{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001241 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
1242 skb_network_offset(skb);
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001243}
1244
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001245static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
1246 unsigned short type,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001247 const void *daddr, const void *saddr,
1248 unsigned len)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001249{
Ursula Braunf1ecfd52007-10-22 16:16:14 +02001250 if (!dev->header_ops || !dev->header_ops->create)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001251 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001252
1253 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001254}
1255
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001256static inline int dev_parse_header(const struct sk_buff *skb,
1257 unsigned char *haddr)
1258{
1259 const struct net_device *dev = skb->dev;
1260
Patrick McHardy1b833362007-10-18 05:09:28 -07001261 if (!dev->header_ops || !dev->header_ops->parse)
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001262 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001263 return dev->header_ops->parse(skb, haddr);
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001264}
1265
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
1267extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
1268static inline int unregister_gifconf(unsigned int family)
1269{
1270 return register_gifconf(family, NULL);
1271}
1272
1273/*
1274 * Incoming packets are placed on per-cpu queues so that
1275 * no locking is needed.
1276 */
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08001277struct softnet_data {
David S. Miller37437bb2008-07-16 02:15:04 -07001278 struct Qdisc *output_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 struct sk_buff_head input_pkt_queue;
1280 struct list_head poll_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 struct sk_buff *completion_queue;
1282
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001283 struct napi_struct backlog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284};
1285
1286DECLARE_PER_CPU(struct softnet_data,softnet_data);
1287
1288#define HAVE_NETIF_QUEUE
1289
David S. Miller37437bb2008-07-16 02:15:04 -07001290extern void __netif_schedule(struct Qdisc *q);
David S. Miller86d804e2008-07-08 23:11:25 -07001291
1292static inline void netif_schedule_queue(struct netdev_queue *txq)
1293{
David S. Miller79d16382008-07-08 23:14:46 -07001294 if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001295 __netif_schedule(txq->qdisc);
David S. Miller86d804e2008-07-08 23:11:25 -07001296}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001298static inline void netif_tx_schedule_all(struct net_device *dev)
1299{
1300 unsigned int i;
1301
1302 for (i = 0; i < dev->num_tx_queues; i++)
1303 netif_schedule_queue(netdev_get_tx_queue(dev, i));
1304}
1305
Dave Jonesd29f7492008-07-22 14:09:06 -07001306static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
1307{
1308 clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1309}
1310
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001311/**
1312 * netif_start_queue - allow transmit
1313 * @dev: network device
1314 *
1315 * Allow upper layers to call the device hard_start_xmit routine.
1316 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317static inline void netif_start_queue(struct net_device *dev)
1318{
David S. Millere8a04642008-07-17 00:34:19 -07001319 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320}
1321
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001322static inline void netif_tx_start_all_queues(struct net_device *dev)
1323{
1324 unsigned int i;
1325
1326 for (i = 0; i < dev->num_tx_queues; i++) {
1327 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1328 netif_tx_start_queue(txq);
1329 }
1330}
1331
David S. Miller79d16382008-07-08 23:14:46 -07001332static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333{
1334#ifdef CONFIG_NETPOLL_TRAP
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001335 if (netpoll_trap()) {
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001336 netif_tx_start_queue(dev_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 return;
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339#endif
David S. Miller79d16382008-07-08 23:14:46 -07001340 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001341 __netif_schedule(dev_queue->qdisc);
David S. Miller79d16382008-07-08 23:14:46 -07001342}
1343
Dave Jonesd29f7492008-07-22 14:09:06 -07001344/**
1345 * netif_wake_queue - restart transmit
1346 * @dev: network device
1347 *
1348 * Allow upper layers to call the device hard_start_xmit routine.
1349 * Used for flow control when transmit resources are available.
1350 */
David S. Miller79d16382008-07-08 23:14:46 -07001351static inline void netif_wake_queue(struct net_device *dev)
1352{
David S. Millere8a04642008-07-17 00:34:19 -07001353 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354}
1355
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001356static inline void netif_tx_wake_all_queues(struct net_device *dev)
1357{
1358 unsigned int i;
1359
1360 for (i = 0; i < dev->num_tx_queues; i++) {
1361 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1362 netif_tx_wake_queue(txq);
1363 }
1364}
1365
Dave Jonesd29f7492008-07-22 14:09:06 -07001366static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
1367{
1368 set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1369}
1370
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001371/**
1372 * netif_stop_queue - stop transmitted packets
1373 * @dev: network device
1374 *
1375 * Stop upper layers calling the device hard_start_xmit routine.
1376 * Used for flow control when transmit resources are unavailable.
1377 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378static inline void netif_stop_queue(struct net_device *dev)
1379{
David S. Millere8a04642008-07-17 00:34:19 -07001380 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381}
1382
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001383static inline void netif_tx_stop_all_queues(struct net_device *dev)
1384{
1385 unsigned int i;
1386
1387 for (i = 0; i < dev->num_tx_queues; i++) {
1388 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1389 netif_tx_stop_queue(txq);
1390 }
1391}
1392
Dave Jonesd29f7492008-07-22 14:09:06 -07001393static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
1394{
1395 return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1396}
1397
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001398/**
1399 * netif_queue_stopped - test if transmit queue is flowblocked
1400 * @dev: network device
1401 *
1402 * Test if transmit queue on device is currently unable to send.
1403 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404static inline int netif_queue_stopped(const struct net_device *dev)
1405{
David S. Millere8a04642008-07-17 00:34:19 -07001406 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407}
1408
David S. Millerc3f26a22008-07-31 16:58:50 -07001409static inline int netif_tx_queue_frozen(const struct netdev_queue *dev_queue)
1410{
1411 return test_bit(__QUEUE_STATE_FROZEN, &dev_queue->state);
1412}
1413
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001414/**
1415 * netif_running - test if up
1416 * @dev: network device
1417 *
1418 * Test if the device has been brought up.
1419 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420static inline int netif_running(const struct net_device *dev)
1421{
1422 return test_bit(__LINK_STATE_START, &dev->state);
1423}
1424
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001425/*
1426 * Routines to manage the subqueues on a device. We only need start
1427 * stop, and a check if it's stopped. All other device management is
1428 * done at the overall netdevice level.
1429 * Also test the device if we're multiqueue.
1430 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001431
1432/**
1433 * netif_start_subqueue - allow sending packets on subqueue
1434 * @dev: network device
1435 * @queue_index: sub queue index
1436 *
1437 * Start individual transmit queue of a device with multiple transmit queues.
1438 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001439static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
1440{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001441 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001442
1443 netif_tx_start_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001444}
1445
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001446/**
1447 * netif_stop_subqueue - stop sending packets on subqueue
1448 * @dev: network device
1449 * @queue_index: sub queue index
1450 *
1451 * Stop individual transmit queue of a device with multiple transmit queues.
1452 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001453static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
1454{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001455 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001456#ifdef CONFIG_NETPOLL_TRAP
1457 if (netpoll_trap())
1458 return;
1459#endif
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001460 netif_tx_stop_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001461}
1462
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001463/**
1464 * netif_subqueue_stopped - test status of subqueue
1465 * @dev: network device
1466 * @queue_index: sub queue index
1467 *
1468 * Check individual transmit queue of a device with multiple transmit queues.
1469 */
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001470static inline int __netif_subqueue_stopped(const struct net_device *dev,
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001471 u16 queue_index)
1472{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001473 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001474
1475 return netif_tx_queue_stopped(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001476}
1477
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001478static inline int netif_subqueue_stopped(const struct net_device *dev,
1479 struct sk_buff *skb)
1480{
1481 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
1482}
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001483
1484/**
1485 * netif_wake_subqueue - allow sending packets on subqueue
1486 * @dev: network device
1487 * @queue_index: sub queue index
1488 *
1489 * Resume individual transmit queue of a device with multiple transmit queues.
1490 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001491static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
1492{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001493 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001494#ifdef CONFIG_NETPOLL_TRAP
1495 if (netpoll_trap())
1496 return;
1497#endif
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001498 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001499 __netif_schedule(txq->qdisc);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001500}
1501
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001502/**
1503 * netif_is_multiqueue - test if device has multiple transmit queues
1504 * @dev: network device
1505 *
1506 * Check if device has multiple transmit queues
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001507 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001508static inline int netif_is_multiqueue(const struct net_device *dev)
1509{
David S. Miller09e83b52008-07-17 01:52:12 -07001510 return (dev->num_tx_queues > 1);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001511}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512
1513/* Use this variant when it is known for sure that it
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07001514 * is executing from hardware interrupt context or with hardware interrupts
1515 * disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001517extern void dev_kfree_skb_irq(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
1519/* Use this variant in places where it could be invoked
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07001520 * from either hardware interrupt or other context, with hardware interrupts
1521 * either disabled or enabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 */
Denis Vlasenko56079432006-03-29 15:57:29 -08001523extern void dev_kfree_skb_any(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
1525#define HAVE_NETIF_RX 1
1526extern int netif_rx(struct sk_buff *skb);
1527extern int netif_rx_ni(struct sk_buff *skb);
1528#define HAVE_NETIF_RECEIVE_SKB 1
1529extern int netif_receive_skb(struct sk_buff *skb);
Herbert Xud565b0a2008-12-15 23:38:52 -08001530extern void napi_gro_flush(struct napi_struct *napi);
Ben Hutchings5b252f02009-10-29 07:17:09 +00001531extern gro_result_t dev_gro_receive(struct napi_struct *napi,
Herbert Xu96e93ea2009-01-06 10:49:34 -08001532 struct sk_buff *skb);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07001533extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb);
1534extern gro_result_t napi_gro_receive(struct napi_struct *napi,
Herbert Xud565b0a2008-12-15 23:38:52 -08001535 struct sk_buff *skb);
Herbert Xu96e93ea2009-01-06 10:49:34 -08001536extern void napi_reuse_skb(struct napi_struct *napi,
1537 struct sk_buff *skb);
Herbert Xu76620aa2009-04-16 02:02:07 -07001538extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07001539extern gro_result_t napi_frags_finish(struct napi_struct *napi,
Ben Hutchings5b252f02009-10-29 07:17:09 +00001540 struct sk_buff *skb,
1541 gro_result_t ret);
Herbert Xu76620aa2009-04-16 02:02:07 -07001542extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
Ben Hutchingsc7c4b3b2009-10-29 21:36:53 -07001543extern gro_result_t napi_gro_frags(struct napi_struct *napi);
Herbert Xu76620aa2009-04-16 02:02:07 -07001544
1545static inline void napi_free_frags(struct napi_struct *napi)
1546{
1547 kfree_skb(napi->skb);
1548 napi->skb = NULL;
1549}
1550
Patrick McHardybc1d0412008-07-14 22:49:30 -07001551extern void netif_nit_deliver(struct sk_buff *skb);
Mitch Williamsc2373ee2005-11-09 10:34:45 -08001552extern int dev_valid_name(const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001553extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
1554extern int dev_ethtool(struct net *net, struct ifreq *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555extern unsigned dev_get_flags(const struct net_device *);
1556extern int dev_change_flags(struct net_device *, unsigned);
Stephen Hemmingercf04a4c2008-09-30 02:22:14 -07001557extern int dev_change_name(struct net_device *, const char *);
Stephen Hemminger0b815a12008-09-22 21:28:11 -07001558extern int dev_set_alias(struct net_device *, const char *, size_t);
Eric W. Biedermance286d32007-09-12 13:53:49 +02001559extern int dev_change_net_namespace(struct net_device *,
1560 struct net *, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561extern int dev_set_mtu(struct net_device *, int);
1562extern int dev_set_mac_address(struct net_device *,
1563 struct sockaddr *);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001564extern int dev_hard_start_xmit(struct sk_buff *skb,
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001565 struct net_device *dev,
1566 struct netdev_queue *txq);
Arnd Bergmann44540962009-11-26 06:07:08 +00001567extern int dev_forward_skb(struct net_device *dev,
1568 struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001570extern int netdev_budget;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571
1572/* Called by rtnetlink.c:rtnl_unlock() */
1573extern void netdev_run_todo(void);
1574
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001575/**
1576 * dev_put - release reference to device
1577 * @dev: network device
1578 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07001579 * Release reference to device to allow it to be freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001580 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581static inline void dev_put(struct net_device *dev)
1582{
1583 atomic_dec(&dev->refcnt);
1584}
1585
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001586/**
1587 * dev_hold - get reference to device
1588 * @dev: network device
1589 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07001590 * Hold reference to device to keep it from being freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001591 */
Stephen Hemminger15333062006-03-20 22:32:28 -08001592static inline void dev_hold(struct net_device *dev)
1593{
1594 atomic_inc(&dev->refcnt);
1595}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
1597/* Carrier loss detection, dial on demand. The functions netif_carrier_on
1598 * and _off may be called from IRQ context, but it is caller
1599 * who is responsible for serialization of these calls.
Stefan Rompfb00055a2006-03-20 17:09:11 -08001600 *
1601 * The name carrier is inappropriate, these functions should really be
1602 * called netif_lowerlayer_*() because they represent the state of any
1603 * kind of lower layer not just hardware media.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 */
1605
1606extern void linkwatch_fire_event(struct net_device *dev);
Eric Dumazete014deb2009-11-17 05:59:21 +00001607extern void linkwatch_forget_dev(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001609/**
1610 * netif_carrier_ok - test if carrier present
1611 * @dev: network device
1612 *
1613 * Check if carrier is present on device
1614 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615static inline int netif_carrier_ok(const struct net_device *dev)
1616{
1617 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
1618}
1619
Eric Dumazet9d214932009-05-17 20:55:16 -07001620extern unsigned long dev_trans_start(struct net_device *dev);
1621
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622extern void __netdev_watchdog_up(struct net_device *dev);
1623
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07001624extern void netif_carrier_on(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07001626extern void netif_carrier_off(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001628/**
1629 * netif_dormant_on - mark device as dormant.
1630 * @dev: network device
1631 *
1632 * Mark device as dormant (as per RFC2863).
1633 *
1634 * The dormant state indicates that the relevant interface is not
1635 * actually in a condition to pass packets (i.e., it is not 'up') but is
1636 * in a "pending" state, waiting for some external event. For "on-
1637 * demand" interfaces, this new state identifies the situation where the
1638 * interface is waiting for events to place it in the up state.
1639 *
1640 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001641static inline void netif_dormant_on(struct net_device *dev)
1642{
1643 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
1644 linkwatch_fire_event(dev);
1645}
1646
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001647/**
1648 * netif_dormant_off - set device as not dormant.
1649 * @dev: network device
1650 *
1651 * Device is not in dormant state.
1652 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001653static inline void netif_dormant_off(struct net_device *dev)
1654{
1655 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
1656 linkwatch_fire_event(dev);
1657}
1658
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001659/**
1660 * netif_dormant - test if carrier present
1661 * @dev: network device
1662 *
1663 * Check if carrier is present on device
1664 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001665static inline int netif_dormant(const struct net_device *dev)
1666{
1667 return test_bit(__LINK_STATE_DORMANT, &dev->state);
1668}
1669
1670
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001671/**
1672 * netif_oper_up - test if device is operational
1673 * @dev: network device
1674 *
1675 * Check if carrier is operational
1676 */
Eric Dumazetd94d9fe2009-11-04 09:50:58 -08001677static inline int netif_oper_up(const struct net_device *dev)
1678{
Stefan Rompfb00055a2006-03-20 17:09:11 -08001679 return (dev->operstate == IF_OPER_UP ||
1680 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
1681}
1682
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001683/**
1684 * netif_device_present - is device available or removed
1685 * @dev: network device
1686 *
1687 * Check if device has not been removed from system.
1688 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689static inline int netif_device_present(struct net_device *dev)
1690{
1691 return test_bit(__LINK_STATE_PRESENT, &dev->state);
1692}
1693
Denis Vlasenko56079432006-03-29 15:57:29 -08001694extern void netif_device_detach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
Denis Vlasenko56079432006-03-29 15:57:29 -08001696extern void netif_device_attach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697
1698/*
1699 * Network interface message level settings
1700 */
1701#define HAVE_NETIF_MSG 1
1702
1703enum {
1704 NETIF_MSG_DRV = 0x0001,
1705 NETIF_MSG_PROBE = 0x0002,
1706 NETIF_MSG_LINK = 0x0004,
1707 NETIF_MSG_TIMER = 0x0008,
1708 NETIF_MSG_IFDOWN = 0x0010,
1709 NETIF_MSG_IFUP = 0x0020,
1710 NETIF_MSG_RX_ERR = 0x0040,
1711 NETIF_MSG_TX_ERR = 0x0080,
1712 NETIF_MSG_TX_QUEUED = 0x0100,
1713 NETIF_MSG_INTR = 0x0200,
1714 NETIF_MSG_TX_DONE = 0x0400,
1715 NETIF_MSG_RX_STATUS = 0x0800,
1716 NETIF_MSG_PKTDATA = 0x1000,
1717 NETIF_MSG_HW = 0x2000,
1718 NETIF_MSG_WOL = 0x4000,
1719};
1720
1721#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
1722#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
1723#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
1724#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
1725#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
1726#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
1727#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
1728#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
1729#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
1730#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
1731#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
1732#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
1733#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
1734#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
1735#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
1736
1737static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
1738{
1739 /* use default */
1740 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
1741 return default_msg_enable_bits;
1742 if (debug_value == 0) /* no output */
1743 return 0;
1744 /* set low N bits */
1745 return (1 << debug_value) - 1;
1746}
1747
David S. Millerc773e842008-07-08 23:13:53 -07001748static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
Herbert Xu932ff272006-06-09 12:20:56 -07001749{
David S. Millerc773e842008-07-08 23:13:53 -07001750 spin_lock(&txq->_xmit_lock);
1751 txq->xmit_lock_owner = cpu;
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001752}
1753
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001754static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
1755{
1756 spin_lock_bh(&txq->_xmit_lock);
1757 txq->xmit_lock_owner = smp_processor_id();
1758}
1759
David S. Millerc773e842008-07-08 23:13:53 -07001760static inline int __netif_tx_trylock(struct netdev_queue *txq)
1761{
1762 int ok = spin_trylock(&txq->_xmit_lock);
1763 if (likely(ok))
1764 txq->xmit_lock_owner = smp_processor_id();
1765 return ok;
Herbert Xu932ff272006-06-09 12:20:56 -07001766}
1767
David S. Millerc773e842008-07-08 23:13:53 -07001768static inline void __netif_tx_unlock(struct netdev_queue *txq)
1769{
1770 txq->xmit_lock_owner = -1;
1771 spin_unlock(&txq->_xmit_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07001772}
1773
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001774static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
1775{
1776 txq->xmit_lock_owner = -1;
1777 spin_unlock_bh(&txq->_xmit_lock);
1778}
1779
Eric Dumazet08baf562009-05-25 22:58:01 -07001780static inline void txq_trans_update(struct netdev_queue *txq)
1781{
1782 if (txq->xmit_lock_owner != -1)
1783 txq->trans_start = jiffies;
1784}
1785
David S. Millerc3f26a22008-07-31 16:58:50 -07001786/**
1787 * netif_tx_lock - grab network device transmit lock
1788 * @dev: network device
David S. Millerc3f26a22008-07-31 16:58:50 -07001789 *
1790 * Get network device transmit lock
1791 */
1792static inline void netif_tx_lock(struct net_device *dev)
1793{
1794 unsigned int i;
1795 int cpu;
1796
1797 spin_lock(&dev->tx_global_lock);
1798 cpu = smp_processor_id();
1799 for (i = 0; i < dev->num_tx_queues; i++) {
1800 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1801
1802 /* We are the only thread of execution doing a
1803 * freeze, but we have to grab the _xmit_lock in
1804 * order to synchronize with threads which are in
1805 * the ->hard_start_xmit() handler and already
1806 * checked the frozen bit.
1807 */
1808 __netif_tx_lock(txq, cpu);
1809 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
1810 __netif_tx_unlock(txq);
1811 }
1812}
1813
1814static inline void netif_tx_lock_bh(struct net_device *dev)
1815{
1816 local_bh_disable();
1817 netif_tx_lock(dev);
1818}
1819
Herbert Xu932ff272006-06-09 12:20:56 -07001820static inline void netif_tx_unlock(struct net_device *dev)
1821{
David S. Millere8a04642008-07-17 00:34:19 -07001822 unsigned int i;
David S. Millerc773e842008-07-08 23:13:53 -07001823
David S. Millere8a04642008-07-17 00:34:19 -07001824 for (i = 0; i < dev->num_tx_queues; i++) {
1825 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millere8a04642008-07-17 00:34:19 -07001826
David S. Millerc3f26a22008-07-31 16:58:50 -07001827 /* No need to grab the _xmit_lock here. If the
1828 * queue is not stopped for another reason, we
1829 * force a schedule.
1830 */
1831 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001832 netif_schedule_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07001833 }
1834 spin_unlock(&dev->tx_global_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07001835}
1836
1837static inline void netif_tx_unlock_bh(struct net_device *dev)
1838{
David S. Millere8a04642008-07-17 00:34:19 -07001839 netif_tx_unlock(dev);
1840 local_bh_enable();
Herbert Xu932ff272006-06-09 12:20:56 -07001841}
1842
David S. Millerc773e842008-07-08 23:13:53 -07001843#define HARD_TX_LOCK(dev, txq, cpu) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001844 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07001845 __netif_tx_lock(txq, cpu); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001846 } \
1847}
1848
David S. Millerc773e842008-07-08 23:13:53 -07001849#define HARD_TX_UNLOCK(dev, txq) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001850 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07001851 __netif_tx_unlock(txq); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001852 } \
1853}
1854
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855static inline void netif_tx_disable(struct net_device *dev)
1856{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001857 unsigned int i;
David S. Millerc3f26a22008-07-31 16:58:50 -07001858 int cpu;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001859
David S. Millerc3f26a22008-07-31 16:58:50 -07001860 local_bh_disable();
1861 cpu = smp_processor_id();
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001862 for (i = 0; i < dev->num_tx_queues; i++) {
1863 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millerc3f26a22008-07-31 16:58:50 -07001864
1865 __netif_tx_lock(txq, cpu);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001866 netif_tx_stop_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07001867 __netif_tx_unlock(txq);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001868 }
David S. Millerc3f26a22008-07-31 16:58:50 -07001869 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870}
1871
David S. Millere308a5d2008-07-15 00:13:44 -07001872static inline void netif_addr_lock(struct net_device *dev)
1873{
1874 spin_lock(&dev->addr_list_lock);
1875}
1876
1877static inline void netif_addr_lock_bh(struct net_device *dev)
1878{
1879 spin_lock_bh(&dev->addr_list_lock);
1880}
1881
1882static inline void netif_addr_unlock(struct net_device *dev)
1883{
1884 spin_unlock(&dev->addr_list_lock);
1885}
1886
1887static inline void netif_addr_unlock_bh(struct net_device *dev)
1888{
1889 spin_unlock_bh(&dev->addr_list_lock);
1890}
1891
Jiri Pirkof001fde2009-05-05 02:48:28 +00001892/*
Jiri Pirko31278e72009-06-17 01:12:19 +00001893 * dev_addrs walker. Should be used only for read access. Call with
Jiri Pirkof001fde2009-05-05 02:48:28 +00001894 * rcu_read_lock held.
1895 */
1896#define for_each_dev_addr(dev, ha) \
Jiri Pirko31278e72009-06-17 01:12:19 +00001897 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
Jiri Pirkof001fde2009-05-05 02:48:28 +00001898
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899/* These functions live elsewhere (drivers/net/net_init.c, but related) */
1900
1901extern void ether_setup(struct net_device *dev);
1902
1903/* Support for loadable net-drivers */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001904extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
1905 void (*setup)(struct net_device *),
1906 unsigned int queue_count);
1907#define alloc_netdev(sizeof_priv, name, setup) \
1908 alloc_netdev_mq(sizeof_priv, name, setup, 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909extern int register_netdev(struct net_device *dev);
1910extern void unregister_netdev(struct net_device *dev);
Jiri Pirkof001fde2009-05-05 02:48:28 +00001911
1912/* Functions used for device addresses handling */
1913extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
1914 unsigned char addr_type);
1915extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
1916 unsigned char addr_type);
1917extern int dev_addr_add_multiple(struct net_device *to_dev,
1918 struct net_device *from_dev,
1919 unsigned char addr_type);
1920extern int dev_addr_del_multiple(struct net_device *to_dev,
1921 struct net_device *from_dev,
1922 unsigned char addr_type);
1923
Patrick McHardy4417da62007-06-27 01:28:10 -07001924/* Functions used for secondary unicast and multicast support */
1925extern void dev_set_rx_mode(struct net_device *dev);
1926extern void __dev_set_rx_mode(struct net_device *dev);
Jiri Pirkoccffad22009-05-22 23:22:17 +00001927extern int dev_unicast_delete(struct net_device *dev, void *addr);
1928extern int dev_unicast_add(struct net_device *dev, void *addr);
Chris Leeche83a2ea2008-01-31 16:53:23 -08001929extern int dev_unicast_sync(struct net_device *to, struct net_device *from);
1930extern void dev_unicast_unsync(struct net_device *to, struct net_device *from);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
1932extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
Patrick McHardya0a400d2007-07-14 18:52:02 -07001933extern int dev_mc_sync(struct net_device *to, struct net_device *from);
1934extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07001935extern int __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);
1936extern int __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);
Chris Leeche83a2ea2008-01-31 16:53:23 -08001937extern int __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
1938extern void __dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
Wang Chendad9b332008-06-18 01:48:28 -07001939extern int dev_set_promiscuity(struct net_device *dev, int inc);
1940extern int dev_set_allmulti(struct net_device *dev, int inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941extern void netdev_state_change(struct net_device *dev);
Moni Shoua75c78502009-09-15 02:37:40 -07001942extern void netdev_bonding_change(struct net_device *dev,
1943 unsigned long event);
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -07001944extern void netdev_features_change(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945/* Load a device via the kmod */
Eric W. Biederman881d9662007-09-17 11:56:21 -07001946extern void dev_load(struct net *net, const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947extern void dev_mcast_init(void);
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -08001948extern const struct net_device_stats *dev_get_stats(struct net_device *dev);
Eric Dumazetd83345a2009-11-16 03:36:51 +00001949extern void dev_txq_stats_fold(const struct net_device *dev, struct net_device_stats *stats);
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -08001950
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951extern int netdev_max_backlog;
1952extern int weight_p;
1953extern int netdev_set_master(struct net_device *dev, struct net_device *master);
Patrick McHardy84fa7932006-08-29 16:44:56 -07001954extern int skb_checksum_help(struct sk_buff *skb);
Herbert Xu576a30e2006-06-27 13:22:38 -07001955extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
Herbert Xufb286bb2005-11-10 13:01:24 -08001956#ifdef CONFIG_BUG
1957extern void netdev_rx_csum_fault(struct net_device *dev);
1958#else
1959static inline void netdev_rx_csum_fault(struct net_device *dev)
1960{
1961}
1962#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963/* rx skb timestamps */
1964extern void net_enable_timestamp(void);
1965extern void net_disable_timestamp(void);
1966
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001967#ifdef CONFIG_PROC_FS
1968extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
1969extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
1970extern void dev_seq_stop(struct seq_file *seq, void *v);
1971#endif
1972
Jay Vosburghb8a97872008-06-13 18:12:04 -07001973extern int netdev_class_create_file(struct class_attribute *class_attr);
1974extern void netdev_class_remove_file(struct class_attribute *class_attr);
1975
Stephen Hemmingercf04a4c2008-09-30 02:22:14 -07001976extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);
Arjan van de Ven6579e572008-07-21 13:31:48 -07001977
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001978extern void linkwatch_run_queue(void);
1979
Herbert Xub63365a2008-10-23 01:11:29 -07001980unsigned long netdev_increment_features(unsigned long all, unsigned long one,
1981 unsigned long mask);
1982unsigned long netdev_fix_features(unsigned long features, const char *name);
Herbert Xu7f353bf2007-08-10 15:47:58 -07001983
Patrick Mullaneyfc4a7482009-12-03 15:59:22 -08001984void netif_stacked_transfer_operstate(const struct net_device *rootdev,
1985 struct net_device *dev);
1986
Herbert Xubcd76112006-06-30 13:36:35 -07001987static inline int net_gso_ok(int features, int gso_type)
1988{
1989 int feature = gso_type << NETIF_F_GSO_SHIFT;
1990 return (features & feature) == feature;
1991}
1992
Herbert Xu576a30e2006-06-27 13:22:38 -07001993static inline int skb_gso_ok(struct sk_buff *skb, int features)
1994{
Herbert Xu278b2512009-06-03 21:20:51 -07001995 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
David S. Millera5bd8a12009-06-09 00:17:27 -07001996 (!skb_has_frags(skb) || (features & NETIF_F_FRAGLIST));
Herbert Xu576a30e2006-06-27 13:22:38 -07001997}
1998
Herbert Xu79671682006-06-22 02:40:14 -07001999static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
2000{
Herbert Xua430a432006-07-08 13:34:56 -07002001 return skb_is_gso(skb) &&
2002 (!skb_gso_ok(skb, dev->features) ||
Patrick McHardy84fa7932006-08-29 16:44:56 -07002003 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
Herbert Xu79671682006-06-22 02:40:14 -07002004}
2005
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07002006static inline void netif_set_gso_max_size(struct net_device *dev,
2007 unsigned int size)
2008{
2009 dev->gso_max_size = size;
2010}
2011
Jiri Pirko5d4e0392009-05-28 01:05:00 +00002012static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
2013 struct net_device *master)
2014{
2015 if (skb->pkt_type == PACKET_HOST) {
2016 u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
2017
2018 memcpy(dest, master->dev_addr, ETH_ALEN);
2019 }
2020}
2021
David S. Miller7ea49ed2006-08-14 17:08:36 -07002022/* On bonding slaves other than the currently active slave, suppress
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002023 * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
2024 * ARP on active-backup slaves with arp_validate enabled.
David S. Miller7ea49ed2006-08-14 17:08:36 -07002025 */
2026static inline int skb_bond_should_drop(struct sk_buff *skb)
2027{
2028 struct net_device *dev = skb->dev;
2029 struct net_device *master = dev->master;
2030
Jay Vosburgh6cf3f412008-11-03 18:16:50 -08002031 if (master) {
2032 if (master->priv_flags & IFF_MASTER_ARPMON)
2033 dev->last_rx = jiffies;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002034
Jiri Pirko5d4e0392009-05-28 01:05:00 +00002035 if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {
2036 /* Do address unmangle. The local destination address
2037 * will be always the one master has. Provides the right
2038 * functionality in a bridge.
2039 */
2040 skb_bond_set_mac_by_master(skb, master);
2041 }
2042
Jay Vosburgh6cf3f412008-11-03 18:16:50 -08002043 if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
2044 if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
Harvey Harrisonf3a7c662009-02-14 22:58:35 -08002045 skb->protocol == __cpu_to_be16(ETH_P_ARP))
David S. Miller7ea49ed2006-08-14 17:08:36 -07002046 return 0;
David S. Miller7ea49ed2006-08-14 17:08:36 -07002047
Jay Vosburgh6cf3f412008-11-03 18:16:50 -08002048 if (master->priv_flags & IFF_MASTER_ALB) {
2049 if (skb->pkt_type != PACKET_BROADCAST &&
2050 skb->pkt_type != PACKET_MULTICAST)
2051 return 0;
2052 }
2053 if (master->priv_flags & IFF_MASTER_8023AD &&
Harvey Harrisonf3a7c662009-02-14 22:58:35 -08002054 skb->protocol == __cpu_to_be16(ETH_P_SLOW))
Jay Vosburgh6cf3f412008-11-03 18:16:50 -08002055 return 0;
2056
2057 return 1;
2058 }
David S. Miller7ea49ed2006-08-14 17:08:36 -07002059 }
2060 return 0;
2061}
2062
Eric W. Biederman505d4f72008-11-07 22:54:20 -08002063extern struct pernet_operations __net_initdata loopback_net_ops;
Patrick McHardyb1b67dd2009-04-20 04:49:28 +00002064
2065static inline int dev_ethtool_get_settings(struct net_device *dev,
2066 struct ethtool_cmd *cmd)
2067{
2068 if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
2069 return -EOPNOTSUPP;
2070 return dev->ethtool_ops->get_settings(dev, cmd);
2071}
2072
2073static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
2074{
2075 if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
2076 return 0;
2077 return dev->ethtool_ops->get_rx_csum(dev);
2078}
2079
2080static inline u32 dev_ethtool_get_flags(struct net_device *dev)
2081{
2082 if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
2083 return 0;
2084 return dev->ethtool_ops->get_flags(dev);
2085}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086#endif /* __KERNEL__ */
2087
Jiri Pirko385a1542009-05-27 15:48:07 -07002088#endif /* _LINUX_NETDEVICE_H */