blob: e7c227d7cb988d6dc75493c3234ba7a96ddfb1e7 [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
66#define NET_XMIT_SUCCESS 0
67#define NET_XMIT_DROP 1 /* skb dropped */
68#define NET_XMIT_CN 2 /* congestion notification */
69#define NET_XMIT_POLICED 3 /* skb is shot by police */
Jarek Poplawski378a2f02008-08-04 22:31:03 -070070#define NET_XMIT_MASK 0xFFFF /* qdisc flags in net/sch_generic.h */
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
72/* Backlog congestion levels */
73#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
74#define NET_RX_DROP 1 /* packet dropped */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -020076/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
77 * indicates that the device will soon be dropping packets, or already drops
78 * some packets of the same priority; prompting us to send less aggressively. */
79#define net_xmit_eval(e) ((e) == NET_XMIT_CN? 0 : (e))
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
81
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +000082/* Driver transmit return codes */
83enum netdev_tx {
84 NETDEV_TX_OK = 0, /* driver took care of packet */
85 NETDEV_TX_BUSY, /* driver tx path was busy*/
86 NETDEV_TX_LOCKED = -1, /* driver tx lock was already taken */
87};
88typedef enum netdev_tx netdev_tx_t;
89
Linus Torvalds1da177e2005-04-16 15:20:36 -070090#endif
91
92#define MAX_ADDR_LEN 32 /* Largest hardware address length */
93
Adrian Bunkc88e6f52008-06-27 19:54:54 -070094#ifdef __KERNEL__
Linus Torvalds1da177e2005-04-16 15:20:36 -070095/*
96 * Compute the worst case header length according to the protocols
97 * used.
98 */
Graf Yangfe2918b2009-02-05 21:26:19 -080099
David S. Miller8388e3d2008-05-12 20:17:33 -0700100#if defined(CONFIG_WLAN_80211) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
101# if defined(CONFIG_MAC80211_MESH)
102# define LL_MAX_HEADER 128
103# else
104# define LL_MAX_HEADER 96
105# endif
Adrian Bunkc759a6b2009-04-27 02:36:20 -0700106#elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
David S. Miller8388e3d2008-05-12 20:17:33 -0700107# define LL_MAX_HEADER 48
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108#else
David S. Miller8388e3d2008-05-12 20:17:33 -0700109# define LL_MAX_HEADER 32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110#endif
111
David S. Millere81c73592006-11-28 20:53:39 -0800112#if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
113 !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
114 !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
115 !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116#define MAX_HEADER LL_MAX_HEADER
117#else
118#define MAX_HEADER (LL_MAX_HEADER + 48)
119#endif
120
Adrian Bunkc88e6f52008-06-27 19:54:54 -0700121#endif /* __KERNEL__ */
122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123/*
124 * Network device statistics. Akin to the 2.0 ether stats but
125 * with byte counters.
126 */
Graf Yangfe2918b2009-02-05 21:26:19 -0800127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128struct net_device_stats
129{
130 unsigned long rx_packets; /* total packets received */
131 unsigned long tx_packets; /* total packets transmitted */
132 unsigned long rx_bytes; /* total bytes received */
133 unsigned long tx_bytes; /* total bytes transmitted */
134 unsigned long rx_errors; /* bad packets received */
135 unsigned long tx_errors; /* packet transmit problems */
136 unsigned long rx_dropped; /* no space in linux buffers */
137 unsigned long tx_dropped; /* no space available in linux */
138 unsigned long multicast; /* multicast packets received */
139 unsigned long collisions;
140
141 /* detailed rx_errors: */
142 unsigned long rx_length_errors;
143 unsigned long rx_over_errors; /* receiver ring buff overflow */
144 unsigned long rx_crc_errors; /* recved pkt with crc error */
145 unsigned long rx_frame_errors; /* recv'd frame alignment error */
146 unsigned long rx_fifo_errors; /* recv'r fifo overrun */
147 unsigned long rx_missed_errors; /* receiver missed packet */
148
149 /* detailed tx_errors */
150 unsigned long tx_aborted_errors;
151 unsigned long tx_carrier_errors;
152 unsigned long tx_fifo_errors;
153 unsigned long tx_heartbeat_errors;
154 unsigned long tx_window_errors;
155
156 /* for cslip etc */
157 unsigned long rx_compressed;
158 unsigned long tx_compressed;
159};
160
161
162/* Media selection options. */
163enum {
164 IF_PORT_UNKNOWN = 0,
165 IF_PORT_10BASE2,
166 IF_PORT_10BASET,
167 IF_PORT_AUI,
168 IF_PORT_100BASET,
169 IF_PORT_100BASETX,
170 IF_PORT_100BASEFX
171};
172
173#ifdef __KERNEL__
174
175#include <linux/cache.h>
176#include <linux/skbuff.h>
177
178struct neighbour;
179struct neigh_parms;
180struct sk_buff;
181
182struct netif_rx_stats
183{
184 unsigned total;
185 unsigned dropped;
186 unsigned time_squeeze;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 unsigned cpu_collision;
188};
189
190DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
191
Patrick McHardybf742482007-06-27 01:26:19 -0700192struct dev_addr_list
193{
194 struct dev_addr_list *next;
195 u8 da_addr[MAX_ADDR_LEN];
196 u8 da_addrlen;
Patrick McHardya0a400d2007-07-14 18:52:02 -0700197 u8 da_synced;
Patrick McHardybf742482007-06-27 01:26:19 -0700198 int da_users;
199 int da_gusers;
200};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
202/*
203 * We tag multicasts with these structures.
204 */
Patrick McHardy3fba5a82007-06-27 01:26:58 -0700205
206#define dev_mc_list dev_addr_list
207#define dmi_addr da_addr
208#define dmi_addrlen da_addrlen
209#define dmi_users da_users
210#define dmi_gusers da_gusers
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
Jiri Pirkof001fde2009-05-05 02:48:28 +0000212struct netdev_hw_addr {
213 struct list_head list;
214 unsigned char addr[MAX_ADDR_LEN];
215 unsigned char type;
Jiri Pirkoccffad252009-05-22 23:22:17 +0000216#define NETDEV_HW_ADDR_T_LAN 1
217#define NETDEV_HW_ADDR_T_SAN 2
218#define NETDEV_HW_ADDR_T_SLAVE 3
219#define NETDEV_HW_ADDR_T_UNICAST 4
220 int refcount;
221 bool synced;
Jiri Pirkof001fde2009-05-05 02:48:28 +0000222 struct rcu_head rcu_head;
223};
224
Jiri Pirko31278e72009-06-17 01:12:19 +0000225struct netdev_hw_addr_list {
226 struct list_head list;
227 int count;
228};
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230struct hh_cache
231{
232 struct hh_cache *hh_next; /* Next entry */
233 atomic_t hh_refcnt; /* number of users */
Eric Dumazetf0490982006-12-08 00:08:43 -0800234/*
235 * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
236 * cache line on SMP.
237 * They are mostly read, but hh_refcnt may be changed quite frequently,
238 * incurring cache line ping pongs.
239 */
240 __be16 hh_type ____cacheline_aligned_in_smp;
241 /* protocol identifier, f.e ETH_P_IP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 * NOTE: For VLANs, this will be the
243 * encapuslated type. --BLG
244 */
Arnaldo Carvalho de Melod5c42c02006-11-27 17:58:02 -0200245 u16 hh_len; /* length of header */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 int (*hh_output)(struct sk_buff *skb);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800247 seqlock_t hh_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249 /* cached hardware header; allow for machine alignment needs. */
250#define HH_DATA_MOD 16
251#define HH_DATA_OFF(__len) \
Jiri Benc5ba0eac2005-06-02 16:48:05 -0700252 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253#define HH_DATA_ALIGN(__len) \
254 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
255 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
256};
257
258/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
259 * Alternative is:
260 * dev->hard_header_len ? (dev->hard_header_len +
261 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
262 *
263 * We could use other alignment values, but we must maintain the
264 * relationship HH alignment <= LL alignment.
Johannes Bergf5184d22008-05-12 20:48:31 -0700265 *
266 * LL_ALLOCATED_SPACE also takes into account the tailroom the device
267 * may need.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 */
269#define LL_RESERVED_SPACE(dev) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700270 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
Johannes Bergf5184d22008-05-12 20:48:31 -0700272 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
273#define LL_ALLOCATED_SPACE(dev) \
274 ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700276struct header_ops {
277 int (*create) (struct sk_buff *skb, struct net_device *dev,
278 unsigned short type, const void *daddr,
279 const void *saddr, unsigned len);
280 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
281 int (*rebuild)(struct sk_buff *skb);
282#define HAVE_HEADER_CACHE
283 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
284 void (*cache_update)(struct hh_cache *hh,
285 const struct net_device *dev,
286 const unsigned char *haddr);
287};
288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289/* These flag bits are private to the generic network queueing
290 * layer, they may not be explicitly referenced by any other
291 * code.
292 */
293
294enum netdev_state_t
295{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 __LINK_STATE_START,
297 __LINK_STATE_PRESENT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 __LINK_STATE_NOCARRIER,
Stefan Rompfb00055a2006-03-20 17:09:11 -0800299 __LINK_STATE_LINKWATCH_PENDING,
300 __LINK_STATE_DORMANT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301};
302
303
304/*
305 * This structure holds at boot time configured netdevice settings. They
Graf Yangfe2918b2009-02-05 21:26:19 -0800306 * are then used in the device probing.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 */
308struct netdev_boot_setup {
309 char name[IFNAMSIZ];
310 struct ifmap map;
311};
312#define NETDEV_BOOT_SETUP_MAX 8
313
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -0300314extern int __init netdev_boot_setup(char *str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
316/*
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700317 * Structure for NAPI scheduling similar to tasklet but with weighting
318 */
319struct napi_struct {
320 /* The poll_list must only be managed by the entity which
321 * changes the state of the NAPI_STATE_SCHED bit. This means
322 * whoever atomically sets that bit can add this napi_struct
323 * to the per-cpu poll_list, and whoever clears that bit
324 * can remove from the list right before clearing the bit.
325 */
326 struct list_head poll_list;
327
328 unsigned long state;
329 int weight;
330 int (*poll)(struct napi_struct *, int);
331#ifdef CONFIG_NETPOLL
332 spinlock_t poll_lock;
333 int poll_owner;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700334#endif
Herbert Xu4ae55442009-02-08 18:00:36 +0000335
336 unsigned int gro_count;
337
Herbert Xu5d38a072009-01-04 16:13:40 -0800338 struct net_device *dev;
Herbert Xud565b0a2008-12-15 23:38:52 -0800339 struct list_head dev_list;
340 struct sk_buff *gro_list;
Herbert Xu5d38a072009-01-04 16:13:40 -0800341 struct sk_buff *skb;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700342};
343
344enum
345{
346 NAPI_STATE_SCHED, /* Poll is scheduled */
David S. Millera0a46192008-01-07 20:35:07 -0800347 NAPI_STATE_DISABLE, /* Disable pending */
Neil Horman7b363e42008-12-09 23:22:26 -0800348 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700349};
350
Herbert Xud1c76af2009-03-16 10:50:02 -0700351enum {
352 GRO_MERGED,
353 GRO_MERGED_FREE,
354 GRO_HELD,
355 GRO_NORMAL,
356 GRO_DROP,
357};
358
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800359extern void __napi_schedule(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700360
David S. Millera0a46192008-01-07 20:35:07 -0800361static inline int napi_disable_pending(struct napi_struct *n)
362{
363 return test_bit(NAPI_STATE_DISABLE, &n->state);
364}
365
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700366/**
367 * napi_schedule_prep - check if napi can be scheduled
368 * @n: napi context
369 *
370 * Test if NAPI routine is already running, and if not mark
371 * it as running. This is used as a condition variable
David S. Millera0a46192008-01-07 20:35:07 -0800372 * insure only one NAPI poll instance runs. We also make
373 * sure there is no pending NAPI disable.
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700374 */
375static inline int napi_schedule_prep(struct napi_struct *n)
376{
David S. Millera0a46192008-01-07 20:35:07 -0800377 return !napi_disable_pending(n) &&
378 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700379}
380
381/**
382 * napi_schedule - schedule NAPI poll
383 * @n: napi context
384 *
385 * Schedule NAPI poll routine to be called if it is not already
386 * running.
387 */
388static inline void napi_schedule(struct napi_struct *n)
389{
390 if (napi_schedule_prep(n))
391 __napi_schedule(n);
392}
393
Roland Dreierbfe13f52007-10-09 15:47:37 -0700394/* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
395static inline int napi_reschedule(struct napi_struct *napi)
396{
397 if (napi_schedule_prep(napi)) {
398 __napi_schedule(napi);
399 return 1;
400 }
401 return 0;
402}
403
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700404/**
405 * napi_complete - NAPI processing complete
406 * @n: napi context
407 *
408 * Mark NAPI processing as complete.
409 */
Herbert Xud565b0a2008-12-15 23:38:52 -0800410extern void __napi_complete(struct napi_struct *n);
411extern void napi_complete(struct napi_struct *n);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700412
413/**
414 * napi_disable - prevent NAPI from scheduling
415 * @n: napi context
416 *
417 * Stop NAPI from being scheduled on this context.
418 * Waits till any outstanding processing completes.
419 */
420static inline void napi_disable(struct napi_struct *n)
421{
David S. Millera0a46192008-01-07 20:35:07 -0800422 set_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700423 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
Benjamin Herrenschmidt43cc7382007-10-26 04:23:22 -0700424 msleep(1);
David S. Millera0a46192008-01-07 20:35:07 -0800425 clear_bit(NAPI_STATE_DISABLE, &n->state);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700426}
427
428/**
429 * napi_enable - enable NAPI scheduling
430 * @n: napi context
431 *
432 * Resume NAPI from being scheduled on this context.
433 * Must be paired with napi_disable.
434 */
435static inline void napi_enable(struct napi_struct *n)
436{
437 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
438 smp_mb__before_clear_bit();
439 clear_bit(NAPI_STATE_SCHED, &n->state);
440}
441
Stephen Hemmingerc264c3d2007-10-17 13:26:41 -0700442#ifdef CONFIG_SMP
443/**
444 * napi_synchronize - wait until NAPI is not running
445 * @n: napi context
446 *
447 * Wait until NAPI is done being scheduled on this context.
448 * Waits till any outstanding processing completes but
449 * does not disable future activations.
450 */
451static inline void napi_synchronize(const struct napi_struct *n)
452{
453 while (test_bit(NAPI_STATE_SCHED, &n->state))
454 msleep(1);
455}
456#else
457# define napi_synchronize(n) barrier()
458#endif
459
David S. Miller79d16382008-07-08 23:14:46 -0700460enum netdev_queue_state_t
461{
462 __QUEUE_STATE_XOFF,
David S. Millerc3f26a22008-07-31 16:58:50 -0700463 __QUEUE_STATE_FROZEN,
David S. Miller79d16382008-07-08 23:14:46 -0700464};
465
David S. Millerbb949fb2008-07-08 16:55:56 -0700466struct netdev_queue {
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700467/*
468 * read mostly part
469 */
David S. Millerbb949fb2008-07-08 16:55:56 -0700470 struct net_device *dev;
David S. Millerb0e1e642008-07-08 17:42:10 -0700471 struct Qdisc *qdisc;
David S. Miller79d16382008-07-08 23:14:46 -0700472 unsigned long state;
David S. Millerb0e1e642008-07-08 17:42:10 -0700473 struct Qdisc *qdisc_sleeping;
Eric Dumazet6a321cb2009-04-28 04:43:42 -0700474/*
475 * write mostly part
476 */
477 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
478 int xmit_lock_owner;
Eric Dumazet9d214932009-05-17 20:55:16 -0700479 /*
480 * please use this field instead of dev->trans_start
481 */
482 unsigned long trans_start;
Eric Dumazet7004bf22009-05-18 00:34:33 +0000483 unsigned long tx_bytes;
484 unsigned long tx_packets;
485 unsigned long tx_dropped;
David S. Millere8a04642008-07-17 00:34:19 -0700486} ____cacheline_aligned_in_smp;
David S. Millerbb949fb2008-07-08 16:55:56 -0700487
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800488
489/*
490 * This structure defines the management hooks for network devices.
Stephen Hemminger00829822008-11-20 20:14:53 -0800491 * The following hooks can be defined; unless noted otherwise, they are
492 * optional and can be filled with a null pointer.
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800493 *
494 * int (*ndo_init)(struct net_device *dev);
495 * This function is called once when network device is registered.
496 * The network device can use this to any late stage initializaton
497 * or semantic validattion. It can fail with an error code which will
498 * be propogated back to register_netdev
499 *
500 * void (*ndo_uninit)(struct net_device *dev);
501 * This function is called when device is unregistered or when registration
502 * fails. It is not called if init fails.
503 *
504 * int (*ndo_open)(struct net_device *dev);
505 * This function is called when network device transistions to the up
506 * state.
507 *
508 * int (*ndo_stop)(struct net_device *dev);
509 * This function is called when network device transistions to the down
510 * state.
511 *
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000512 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
513 * struct net_device *dev);
Stephen Hemminger00829822008-11-20 20:14:53 -0800514 * Called when a packet needs to be transmitted.
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000515 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
516 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
Stephen Hemminger00829822008-11-20 20:14:53 -0800517 * Required can not be NULL.
518 *
519 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
520 * Called to decide which queue to when device supports multiple
521 * transmit queues.
522 *
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800523 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
524 * This function is called to allow device receiver to make
525 * changes to configuration when multicast or promiscious is enabled.
526 *
527 * void (*ndo_set_rx_mode)(struct net_device *dev);
528 * This function is called device changes address list filtering.
529 *
530 * void (*ndo_set_multicast_list)(struct net_device *dev);
531 * This function is called when the multicast address list changes.
532 *
533 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
534 * This function is called when the Media Access Control address
Mike Rapoport37b607c2009-04-27 05:45:54 -0700535 * needs to be changed. If this interface is not defined, the
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800536 * mac address can not be changed.
537 *
538 * int (*ndo_validate_addr)(struct net_device *dev);
539 * Test if Media Access Control address is valid for the device.
540 *
541 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
542 * Called when a user request an ioctl which can't be handled by
543 * the generic interface code. If not defined ioctl's return
544 * not supported error code.
545 *
546 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
547 * Used to set network devices bus interface parameters. This interface
548 * is retained for legacy reason, new devices should use the bus
549 * interface (PCI) for low level management.
550 *
551 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
552 * Called when a user wants to change the Maximum Transfer Unit
553 * of a device. If not defined, any request to change MTU will
554 * will return an error.
555 *
Stephen Hemminger00829822008-11-20 20:14:53 -0800556 * void (*ndo_tx_timeout)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800557 * Callback uses when the transmitter has not made any progress
558 * for dev->watchdog ticks.
559 *
Wolfram Sangd308e382009-10-07 13:53:11 -0700560 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800561 * Called when a user wants to get the network device usage
562 * statistics. If not defined, the counters in dev->stats will
563 * be used.
564 *
565 * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
566 * If device support VLAN receive accleration
567 * (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
568 * when vlan groups for the device changes. Note: grp is NULL
569 * if no vlan's groups are being used.
570 *
571 * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
572 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
573 * this function is called when a VLAN id is registered.
574 *
575 * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
576 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
577 * this function is called when a VLAN id is unregistered.
578 *
579 * void (*ndo_poll_controller)(struct net_device *dev);
580 */
Stephen Hemminger47fd5b82008-11-25 00:20:43 -0800581#define HAVE_NET_DEVICE_OPS
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800582struct net_device_ops {
583 int (*ndo_init)(struct net_device *dev);
584 void (*ndo_uninit)(struct net_device *dev);
585 int (*ndo_open)(struct net_device *dev);
586 int (*ndo_stop)(struct net_device *dev);
Stephen Hemmingerdc1f8bf2009-08-31 19:50:40 +0000587 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,
Stephen Hemminger00829822008-11-20 20:14:53 -0800588 struct net_device *dev);
589 u16 (*ndo_select_queue)(struct net_device *dev,
590 struct sk_buff *skb);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800591#define HAVE_CHANGE_RX_FLAGS
592 void (*ndo_change_rx_flags)(struct net_device *dev,
593 int flags);
594#define HAVE_SET_RX_MODE
595 void (*ndo_set_rx_mode)(struct net_device *dev);
596#define HAVE_MULTICAST
597 void (*ndo_set_multicast_list)(struct net_device *dev);
598#define HAVE_SET_MAC_ADDR
599 int (*ndo_set_mac_address)(struct net_device *dev,
600 void *addr);
601#define HAVE_VALIDATE_ADDR
602 int (*ndo_validate_addr)(struct net_device *dev);
603#define HAVE_PRIVATE_IOCTL
604 int (*ndo_do_ioctl)(struct net_device *dev,
605 struct ifreq *ifr, int cmd);
606#define HAVE_SET_CONFIG
607 int (*ndo_set_config)(struct net_device *dev,
608 struct ifmap *map);
609#define HAVE_CHANGE_MTU
Stephen Hemminger00829822008-11-20 20:14:53 -0800610 int (*ndo_change_mtu)(struct net_device *dev,
611 int new_mtu);
612 int (*ndo_neigh_setup)(struct net_device *dev,
613 struct neigh_parms *);
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800614#define HAVE_TX_TIMEOUT
615 void (*ndo_tx_timeout) (struct net_device *dev);
616
617 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
618
619 void (*ndo_vlan_rx_register)(struct net_device *dev,
620 struct vlan_group *grp);
621 void (*ndo_vlan_rx_add_vid)(struct net_device *dev,
622 unsigned short vid);
623 void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
624 unsigned short vid);
625#ifdef CONFIG_NET_POLL_CONTROLLER
626#define HAVE_NETDEV_POLL
627 void (*ndo_poll_controller)(struct net_device *dev);
628#endif
Yi Zou4d288d52009-02-27 14:06:59 -0800629#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
Yi Zoucb454392009-08-31 12:31:36 +0000630 int (*ndo_fcoe_enable)(struct net_device *dev);
631 int (*ndo_fcoe_disable)(struct net_device *dev);
Yi Zou4d288d52009-02-27 14:06:59 -0800632 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
633 u16 xid,
634 struct scatterlist *sgl,
635 unsigned int sgc);
636 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
637 u16 xid);
638#endif
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800639};
640
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700641/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 * The DEVICE structure.
643 * Actually, this whole structure is a big mistake. It mixes I/O
644 * data with strictly "high-level" data, and it has to know about
645 * almost every data structure used in the INET module.
646 *
647 * FIXME: cleanup struct net_device such that network protocol info
648 * moves out.
649 */
650
651struct net_device
652{
653
654 /*
655 * This is the first field of the "visible" part of this structure
656 * (i.e. as seen by users in the "Space.c" file). It is the name
657 * the interface.
658 */
659 char name[IFNAMSIZ];
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700660 /* device name hash chain */
661 struct hlist_node name_hlist;
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700662 /* snmp alias */
663 char *ifalias;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665 /*
666 * I/O specific fields
667 * FIXME: Merge these and struct ifmap into one
668 */
669 unsigned long mem_end; /* shared mem end */
670 unsigned long mem_start; /* shared mem start */
671 unsigned long base_addr; /* device I/O address */
672 unsigned int irq; /* device IRQ number */
673
674 /*
675 * Some hardware also needs these fields, but they are not
676 * part of the usual set specified in Space.c.
677 */
678
679 unsigned char if_port; /* Selectable AUI, TP,..*/
680 unsigned char dma; /* DMA channel */
681
682 unsigned long state;
683
Pavel Emelianov7562f872007-05-03 15:13:45 -0700684 struct list_head dev_list;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700685 struct list_head napi_list;
Eric Dumazet44a08732009-10-27 07:03:04 +0000686 struct list_head unreg_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700688 /* Net device features */
689 unsigned long features;
690#define NETIF_F_SG 1 /* Scatter/gather IO. */
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700691#define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700692#define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
693#define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700694#define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700695#define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
696#define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
697#define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
698#define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
699#define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
700#define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
Herbert Xu37c31852006-06-22 03:07:29 -0700701#define NETIF_F_GSO 2048 /* Enable software GSO. */
Christian Borntraegere24eb522007-09-25 19:42:02 -0700702#define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */
703 /* do not use LLTX in new drivers */
Eric W. Biedermance286d32007-09-12 13:53:49 +0200704#define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */
Herbert Xud565b0a2008-12-15 23:38:52 -0800705#define NETIF_F_GRO 16384 /* Generic receive offload */
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700706#define NETIF_F_LRO 32768 /* large receive offload */
Herbert Xu79671682006-06-22 02:40:14 -0700707
Jesse Brandeburg8dc92f72009-04-27 22:35:52 +0000708/* the GSO_MASK reserves bits 16 through 23 */
Chris Leech01d5b2f2009-02-27 14:06:49 -0800709#define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */
Jesse Brandeburg8dc92f72009-04-27 22:35:52 +0000710#define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */
Yi Zoubb2af4f2009-08-14 12:41:57 +0000711#define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
Chris Leech01d5b2f2009-02-27 14:06:49 -0800712
Herbert Xu79671682006-06-22 02:40:14 -0700713 /* Segmentation offload features */
Patrick McHardy289c79a2008-05-23 00:22:04 -0700714#define NETIF_F_GSO_SHIFT 16
Chris Leech43eb99c2009-02-27 14:06:43 -0800715#define NETIF_F_GSO_MASK 0x00ff0000
Herbert Xu79671682006-06-22 02:40:14 -0700716#define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700717#define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
Herbert Xu576a30e2006-06-27 13:22:38 -0700718#define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700719#define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
720#define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
Chris Leech01d5b2f2009-02-27 14:06:49 -0800721#define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700722
Herbert Xu78eb8872006-08-17 18:22:32 -0700723 /* List of features with software fallbacks. */
724#define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)
725
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700726
Herbert Xu8648b302006-06-17 22:06:05 -0700727#define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
Stephen Hemmingerd212f872007-06-27 00:47:37 -0700728#define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
729#define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
730#define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
Herbert Xu8648b302006-06-17 22:06:05 -0700731
Herbert Xub63365a2008-10-23 01:11:29 -0700732 /*
733 * If one device supports one of these features, then enable them
734 * for all in netdev_increment_features.
735 */
736#define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800737 NETIF_F_SG | NETIF_F_HIGHDMA | \
Herbert Xub63365a2008-10-23 01:11:29 -0700738 NETIF_F_FRAGLIST)
739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 /* Interface index. Unique device identifier */
741 int ifindex;
742 int iflink;
743
Rusty Russellc45d2862007-03-28 14:29:08 -0700744 struct net_device_stats stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
Johannes Bergb86e0282007-04-26 20:48:23 -0700746#ifdef CONFIG_WIRELESS_EXT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 /* List of functions to handle Wireless Extensions (instead of ioctl).
748 * See <net/iw_handler.h> for details. Jean II */
749 const struct iw_handler_def * wireless_handlers;
750 /* Instance data managed by the core of Wireless Extensions. */
751 struct iw_public_data * wireless_data;
Johannes Bergb86e0282007-04-26 20:48:23 -0700752#endif
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800753 /* Management operations */
754 const struct net_device_ops *netdev_ops;
Stephen Hemminger76fd8592006-09-08 11:16:13 -0700755 const struct ethtool_ops *ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700757 /* Hardware header description */
758 const struct header_ops *header_ops;
759
Stefan Rompfb00055a2006-03-20 17:09:11 -0800760 unsigned int flags; /* interface flags (a la BSD) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 unsigned short gflags;
762 unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */
763 unsigned short padded; /* How much padding added by alloc_netdev() */
764
Stefan Rompfb00055a2006-03-20 17:09:11 -0800765 unsigned char operstate; /* RFC2863 operstate */
766 unsigned char link_mode; /* mapping policy to operstate */
767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 unsigned mtu; /* interface MTU value */
769 unsigned short type; /* interface hardware type */
770 unsigned short hard_header_len; /* hardware hdr length */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
Johannes Bergf5184d22008-05-12 20:48:31 -0700772 /* extra head- and tailroom the hardware may need, but not in all cases
773 * can this be guaranteed, especially tailroom. Some cases also use
774 * LL_MAX_HEADER instead to allocate the skb.
775 */
776 unsigned short needed_headroom;
777 unsigned short needed_tailroom;
778
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 struct net_device *master; /* Pointer to master device of a group,
780 * which this device is member of.
781 */
782
783 /* Interface address info. */
Jon Wetzela6f9a702005-08-20 17:15:54 -0700784 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 unsigned char addr_len; /* hardware address length */
786 unsigned short dev_id; /* for shared network cards */
787
Jiri Pirko31278e72009-06-17 01:12:19 +0000788 struct netdev_hw_addr_list uc; /* Secondary unicast
789 mac addresses */
Patrick McHardy4417da62007-06-27 01:28:10 -0700790 int uc_promisc;
Jiri Pirkoccffad252009-05-22 23:22:17 +0000791 spinlock_t addr_list_lock;
Patrick McHardy3fba5a82007-06-27 01:26:58 -0700792 struct dev_addr_list *mc_list; /* Multicast mac addresses */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 int mc_count; /* Number of installed mcasts */
Wang Chen9d45abe2008-06-17 21:12:48 -0700794 unsigned int promiscuity;
795 unsigned int allmulti;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
798 /* Protocol specific pointers */
799
Lennert Buytenhek91da11f2008-10-07 13:44:02 +0000800#ifdef CONFIG_NET_DSA
801 void *dsa_ptr; /* dsa specific data */
802#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 void *atalk_ptr; /* AppleTalk link */
Graf Yangfe2918b2009-02-05 21:26:19 -0800804 void *ip_ptr; /* IPv4 specific data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 void *dn_ptr; /* DECnet specific data */
806 void *ip6_ptr; /* IPv6 specific data */
807 void *ec_ptr; /* Econet specific data */
808 void *ax25_ptr; /* AX.25 specific data */
Johannes Berg704232c2007-04-23 12:20:05 -0700809 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
810 assign before registering */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700812/*
813 * Cache line mostly used on receive path (including eth_type_trans())
814 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700815 unsigned long last_rx; /* Time of last Rx */
816 /* Interface address info used in eth_type_trans() */
Jiri Pirkof001fde2009-05-05 02:48:28 +0000817 unsigned char *dev_addr; /* hw address, (before bcast
818 because most packets are
819 unicast) */
820
Jiri Pirko31278e72009-06-17 01:12:19 +0000821 struct netdev_hw_addr_list dev_addrs; /* list of device
822 hw addresses */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700824 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
825
David S. Millerbb949fb2008-07-08 16:55:56 -0700826 struct netdev_queue rx_queue;
David S. Millere8a04642008-07-17 00:34:19 -0700827
828 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700829
830 /* Number of TX queues allocated at alloc_netdev_mq() time */
David S. Millere8a04642008-07-17 00:34:19 -0700831 unsigned int num_tx_queues;
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700832
833 /* Number of TX queues currently active in device */
834 unsigned int real_num_tx_queues;
835
Patrick McHardyaf356af2009-09-04 06:41:18 +0000836 /* root qdisc from userspace point of view */
837 struct Qdisc *qdisc;
838
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 unsigned long tx_queue_len; /* Max frames per queue allowed */
David S. Millerc3f26a22008-07-31 16:58:50 -0700840 spinlock_t tx_global_lock;
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700841/*
842 * One part is mostly used on xmit path (device)
843 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700844 /* These may be needed for future network-power-down code. */
Eric Dumazet9d214932009-05-17 20:55:16 -0700845
846 /*
847 * trans_start here is expensive for high speed devices on SMP,
848 * please use netdev_queue->trans_start instead.
849 */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700850 unsigned long trans_start; /* Time (in jiffies) of last Tx */
851
852 int watchdog_timeo; /* used by dev_watchdog() */
853 struct timer_list watchdog_timer;
854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 /* Number of references to this device */
Eric Dumazet9356b8f2005-09-27 15:23:16 -0700856 atomic_t refcnt ____cacheline_aligned_in_smp;
857
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 /* delayed register/unregister */
859 struct list_head todo_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 /* device index hash chain */
861 struct hlist_node index_hlist;
862
Herbert Xu572a1032007-05-08 18:34:17 -0700863 struct net_device *link_watch_next;
864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 /* register/unregister state machine */
866 enum { NETREG_UNINITIALIZED=0,
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -0700867 NETREG_REGISTERED, /* completed register_netdevice */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 NETREG_UNREGISTERING, /* called unregister_netdevice */
869 NETREG_UNREGISTERED, /* completed unregister todo */
870 NETREG_RELEASED, /* called free_netdev */
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -0800871 NETREG_DUMMY, /* dummy device for NAPI poll */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 } reg_state;
873
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800874 /* Called from unregister, can be used to call free_netdev */
875 void (*destructor)(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877#ifdef CONFIG_NETPOLL
Jeff Moyer115c1d62005-06-22 22:05:31 -0700878 struct netpoll_info *npinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879#endif
David S. Millereae792b2008-07-15 03:03:33 -0700880
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900881#ifdef CONFIG_NET_NS
Eric W. Biederman4a1c5372007-09-12 11:56:32 +0200882 /* Network namespace this network device is inside */
883 struct net *nd_net;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900884#endif
Eric W. Biederman4a1c5372007-09-12 11:56:32 +0200885
David S. Miller49517042008-05-12 03:29:11 -0700886 /* mid-layer private */
887 void *ml_priv;
888
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 /* bridge stuff */
890 struct net_bridge_port *br_port;
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700891 /* macvlan */
892 struct macvlan_port *macvlan_port;
Patrick McHardyeca9eba2008-07-05 21:26:13 -0700893 /* GARP */
894 struct garp_port *garp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 /* class/net/name entry */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700897 struct device dev;
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700898 /* space for optional statistics and wireless sysfs groups */
David Brownella4dbd672009-06-24 10:06:31 -0700899 const struct attribute_group *sysfs_groups[3];
Patrick McHardy38f7b872007-06-13 12:03:51 -0700900
901 /* rtnetlink link ops */
902 const struct rtnl_link_ops *rtnl_link_ops;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700903
Patrick McHardy289c79a2008-05-23 00:22:04 -0700904 /* VLAN feature mask */
905 unsigned long vlan_features;
906
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -0700907 /* for setting kernel sock attribute on TCP connection setup */
908#define GSO_MAX_SIZE 65536
909 unsigned int gso_max_size;
Stephen Hemmingerd3147742008-11-19 21:32:24 -0800910
Jeff Kirsher7a6b6f52008-11-25 01:02:08 -0800911#ifdef CONFIG_DCB
Alexander Duyck2f90b862008-11-20 20:52:10 -0800912 /* Data Center Bridging netlink ops */
Stephen Hemminger32953542009-10-05 06:01:03 +0000913 const struct dcbnl_rtnl_ops *dcbnl_ops;
Alexander Duyck2f90b862008-11-20 20:52:10 -0800914#endif
915
Yi Zou4d288d52009-02-27 14:06:59 -0800916#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
917 /* max exchange id for FCoE LRO by ddp */
918 unsigned int fcoe_ddp_xid;
919#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920};
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700921#define to_net_dev(d) container_of(d, struct net_device, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923#define NETDEV_ALIGN 32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
David S. Millere8a04642008-07-17 00:34:19 -0700925static inline
926struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
927 unsigned int index)
928{
929 return &dev->_tx[index];
930}
931
932static inline void netdev_for_each_tx_queue(struct net_device *dev,
933 void (*f)(struct net_device *,
934 struct netdev_queue *,
935 void *),
936 void *arg)
937{
938 unsigned int i;
939
940 for (i = 0; i < dev->num_tx_queues; i++)
941 f(dev, &dev->_tx[i], arg);
942}
943
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900944/*
945 * Net namespace inlines
946 */
947static inline
948struct net *dev_net(const struct net_device *dev)
949{
950#ifdef CONFIG_NET_NS
951 return dev->nd_net;
952#else
953 return &init_net;
954#endif
955}
956
957static inline
Denis V. Lunevf5aa23f2008-03-26 00:48:17 -0700958void dev_net_set(struct net_device *dev, struct net *net)
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900959{
960#ifdef CONFIG_NET_NS
Denis V. Lunevf3005d72008-04-16 02:02:18 -0700961 release_net(dev->nd_net);
962 dev->nd_net = hold_net(net);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900963#endif
964}
965
Lennert Buytenhekcf85d082008-10-07 13:45:02 +0000966static inline bool netdev_uses_dsa_tags(struct net_device *dev)
967{
968#ifdef CONFIG_NET_DSA_TAG_DSA
969 if (dev->dsa_ptr != NULL)
970 return dsa_uses_dsa_tags(dev->dsa_ptr);
971#endif
972
973 return 0;
974}
975
Lennert Buytenhek396138f2008-10-07 13:46:07 +0000976static inline bool netdev_uses_trailer_tags(struct net_device *dev)
977{
978#ifdef CONFIG_NET_DSA_TAG_TRAILER
979 if (dev->dsa_ptr != NULL)
980 return dsa_uses_trailer_tags(dev->dsa_ptr);
981#endif
982
983 return 0;
984}
985
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700986/**
987 * netdev_priv - access network device private data
988 * @dev: network device
989 *
990 * Get network device private data
991 */
Patrick McHardy6472ce62007-06-13 12:03:21 -0700992static inline void *netdev_priv(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993{
Eric Dumazet1ce8e7b2009-05-27 04:42:37 +0000994 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995}
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997/* Set the sysfs physical device reference for the network logical device
998 * if set prior to registration will cause a symlink during initialization.
999 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001000#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Marcel Holtmann384912e2009-08-31 21:08:19 +00001002/* Set the sysfs device type for the network logical device to allow
1003 * fin grained indentification of different network device types. For
1004 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
1005 */
1006#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
1007
Stephen Hemminger3b582cc2007-11-01 02:21:47 -07001008/**
1009 * netif_napi_add - initialize a napi context
1010 * @dev: network device
1011 * @napi: napi context
1012 * @poll: polling function
1013 * @weight: default weight
1014 *
1015 * netif_napi_add() must be used to initialize a napi context prior to calling
1016 * *any* of the other napi related functions.
1017 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001018void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
1019 int (*poll)(struct napi_struct *, int), int weight);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001020
Alexander Duyckd8156532008-07-08 15:13:05 -07001021/**
1022 * netif_napi_del - remove a napi context
1023 * @napi: napi context
1024 *
1025 * netif_napi_del() removes a napi context from the network device napi list
1026 */
Herbert Xud565b0a2008-12-15 23:38:52 -08001027void netif_napi_del(struct napi_struct *napi);
1028
1029struct napi_gro_cb {
Herbert Xu78a478d2009-05-26 18:50:21 +00001030 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
1031 void *frag0;
1032
Herbert Xu74895942009-05-26 18:50:27 +00001033 /* Length of frag0. */
1034 unsigned int frag0_len;
1035
Herbert Xu86911732009-01-29 14:19:50 +00001036 /* This indicates where we are processing relative to skb->data. */
1037 int data_offset;
1038
Herbert Xud565b0a2008-12-15 23:38:52 -08001039 /* This is non-zero if the packet may be of the same flow. */
1040 int same_flow;
1041
1042 /* This is non-zero if the packet cannot be merged with the new skb. */
1043 int flush;
1044
1045 /* Number of segments aggregated. */
1046 int count;
Herbert Xu5d38a072009-01-04 16:13:40 -08001047
1048 /* Free the skb? */
1049 int free;
Herbert Xud565b0a2008-12-15 23:38:52 -08001050};
1051
1052#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
Alexander Duyckd8156532008-07-08 15:13:05 -07001053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054struct packet_type {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001055 __be16 type; /* This is really htons(ether_type). */
1056 struct net_device *dev; /* NULL is wildcarded here */
1057 int (*func) (struct sk_buff *,
1058 struct net_device *,
1059 struct packet_type *,
1060 struct net_device *);
Herbert Xu576a30e2006-06-27 13:22:38 -07001061 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
1062 int features);
Herbert Xua430a432006-07-08 13:34:56 -07001063 int (*gso_send_check)(struct sk_buff *skb);
Herbert Xud565b0a2008-12-15 23:38:52 -08001064 struct sk_buff **(*gro_receive)(struct sk_buff **head,
1065 struct sk_buff *skb);
1066 int (*gro_complete)(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 void *af_packet_priv;
1068 struct list_head list;
1069};
1070
1071#include <linux/interrupt.h>
1072#include <linux/notifier.h>
1073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074extern rwlock_t dev_base_lock; /* Device list lock */
1075
Eric W. Biederman881d9662007-09-17 11:56:21 -07001076
1077#define for_each_netdev(net, d) \
1078 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
1079#define for_each_netdev_safe(net, d, n) \
1080 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
1081#define for_each_netdev_continue(net, d) \
1082 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001083#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
1084
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001085static inline struct net_device *next_net_device(struct net_device *dev)
1086{
1087 struct list_head *lh;
1088 struct net *net;
Pavel Emelianov7562f872007-05-03 15:13:45 -07001089
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001090 net = dev_net(dev);
Daniel Lezcanoa050c332007-09-12 14:57:09 +02001091 lh = dev->dev_list.next;
1092 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1093}
1094
1095static inline struct net_device *first_net_device(struct net *net)
1096{
1097 return list_empty(&net->dev_base_head) ? NULL :
1098 net_device_entry(net->dev_base_head.next);
1099}
Pavel Emelianov7562f872007-05-03 15:13:45 -07001100
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101extern int netdev_boot_setup_check(struct net_device *dev);
1102extern unsigned long netdev_boot_base(const char *prefix, int unit);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001103extern struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);
1104extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
1105extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106extern void dev_add_pack(struct packet_type *pt);
1107extern void dev_remove_pack(struct packet_type *pt);
1108extern void __dev_remove_pack(struct packet_type *pt);
1109
Eric W. Biederman881d9662007-09-17 11:56:21 -07001110extern struct net_device *dev_get_by_flags(struct net *net, unsigned short flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 unsigned short mask);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001112extern struct net_device *dev_get_by_name(struct net *net, const char *name);
1113extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114extern int dev_alloc_name(struct net_device *dev, const char *name);
1115extern int dev_open(struct net_device *dev);
1116extern int dev_close(struct net_device *dev);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001117extern void dev_disable_lro(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118extern int dev_queue_xmit(struct sk_buff *skb);
1119extern int register_netdevice(struct net_device *dev);
Eric Dumazet44a08732009-10-27 07:03:04 +00001120extern void unregister_netdevice_queue(struct net_device *dev,
1121 struct list_head *head);
Eric Dumazet9b5e3832009-10-27 07:04:19 +00001122extern void unregister_netdevice_many(struct list_head *head);
Eric Dumazet44a08732009-10-27 07:03:04 +00001123static inline void unregister_netdevice(struct net_device *dev)
1124{
1125 unregister_netdevice_queue(dev, NULL);
1126}
1127
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128extern void free_netdev(struct net_device *dev);
1129extern void synchronize_net(void);
1130extern int register_netdevice_notifier(struct notifier_block *nb);
1131extern int unregister_netdevice_notifier(struct notifier_block *nb);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001132extern int init_dummy_netdev(struct net_device *dev);
David S. Miller9d40bbd2009-03-04 23:46:25 -08001133extern void netdev_resync_ops(struct net_device *dev);
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08001134
Eric W. Biedermanad7379d2007-09-16 15:33:32 -07001135extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001136extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
1137extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138extern int dev_restart(struct net_device *dev);
1139#ifdef CONFIG_NETPOLL_TRAP
1140extern int netpoll_trap(void);
1141#endif
Herbert Xu86911732009-01-29 14:19:50 +00001142extern int skb_gro_receive(struct sk_buff **head,
1143 struct sk_buff *skb);
Herbert Xu78a478d2009-05-26 18:50:21 +00001144extern void skb_gro_reset_offset(struct sk_buff *skb);
Herbert Xu86911732009-01-29 14:19:50 +00001145
1146static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
1147{
1148 return NAPI_GRO_CB(skb)->data_offset;
1149}
1150
1151static inline unsigned int skb_gro_len(const struct sk_buff *skb)
1152{
1153 return skb->len - NAPI_GRO_CB(skb)->data_offset;
1154}
1155
1156static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
1157{
1158 NAPI_GRO_CB(skb)->data_offset += len;
1159}
1160
Herbert Xua5b1cf22009-05-26 18:50:28 +00001161static inline void *skb_gro_header_fast(struct sk_buff *skb,
1162 unsigned int offset)
Herbert Xu86911732009-01-29 14:19:50 +00001163{
Herbert Xu78a478d2009-05-26 18:50:21 +00001164 return NAPI_GRO_CB(skb)->frag0 + offset;
Herbert Xu86911732009-01-29 14:19:50 +00001165}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
Herbert Xua5b1cf22009-05-26 18:50:28 +00001167static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
1168{
1169 return NAPI_GRO_CB(skb)->frag0_len < hlen;
1170}
1171
1172static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
1173 unsigned int offset)
1174{
1175 NAPI_GRO_CB(skb)->frag0 = NULL;
1176 NAPI_GRO_CB(skb)->frag0_len = 0;
1177 return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
1178}
1179
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001180static inline void *skb_gro_mac_header(struct sk_buff *skb)
1181{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001182 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
Herbert Xuaa4b9f52009-02-08 18:00:37 +00001183}
1184
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001185static inline void *skb_gro_network_header(struct sk_buff *skb)
1186{
Herbert Xu78d3fd02009-05-26 18:50:23 +00001187 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
1188 skb_network_offset(skb);
Herbert Xu36e7b1b2009-04-27 05:44:45 -07001189}
1190
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001191static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
1192 unsigned short type,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001193 const void *daddr, const void *saddr,
1194 unsigned len)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001195{
Ursula Braunf1ecfd52007-10-22 16:16:14 +02001196 if (!dev->header_ops || !dev->header_ops->create)
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001197 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001198
1199 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001200}
1201
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001202static inline int dev_parse_header(const struct sk_buff *skb,
1203 unsigned char *haddr)
1204{
1205 const struct net_device *dev = skb->dev;
1206
Patrick McHardy1b833362007-10-18 05:09:28 -07001207 if (!dev->header_ops || !dev->header_ops->parse)
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001208 return 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001209 return dev->header_ops->parse(skb, haddr);
Stephen Hemmingerb95cce32007-09-26 22:13:38 -07001210}
1211
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
1213extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
1214static inline int unregister_gifconf(unsigned int family)
1215{
1216 return register_gifconf(family, NULL);
1217}
1218
1219/*
1220 * Incoming packets are placed on per-cpu queues so that
1221 * no locking is needed.
1222 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223struct softnet_data
1224{
David S. Miller37437bb2008-07-16 02:15:04 -07001225 struct Qdisc *output_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 struct sk_buff_head input_pkt_queue;
1227 struct list_head poll_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 struct sk_buff *completion_queue;
1229
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001230 struct napi_struct backlog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231};
1232
1233DECLARE_PER_CPU(struct softnet_data,softnet_data);
1234
1235#define HAVE_NETIF_QUEUE
1236
David S. Miller37437bb2008-07-16 02:15:04 -07001237extern void __netif_schedule(struct Qdisc *q);
David S. Miller86d804e2008-07-08 23:11:25 -07001238
1239static inline void netif_schedule_queue(struct netdev_queue *txq)
1240{
David S. Miller79d16382008-07-08 23:14:46 -07001241 if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001242 __netif_schedule(txq->qdisc);
David S. Miller86d804e2008-07-08 23:11:25 -07001243}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001245static inline void netif_tx_schedule_all(struct net_device *dev)
1246{
1247 unsigned int i;
1248
1249 for (i = 0; i < dev->num_tx_queues; i++)
1250 netif_schedule_queue(netdev_get_tx_queue(dev, i));
1251}
1252
Dave Jonesd29f7492008-07-22 14:09:06 -07001253static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
1254{
1255 clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1256}
1257
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001258/**
1259 * netif_start_queue - allow transmit
1260 * @dev: network device
1261 *
1262 * Allow upper layers to call the device hard_start_xmit routine.
1263 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264static inline void netif_start_queue(struct net_device *dev)
1265{
David S. Millere8a04642008-07-17 00:34:19 -07001266 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267}
1268
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001269static inline void netif_tx_start_all_queues(struct net_device *dev)
1270{
1271 unsigned int i;
1272
1273 for (i = 0; i < dev->num_tx_queues; i++) {
1274 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1275 netif_tx_start_queue(txq);
1276 }
1277}
1278
David S. Miller79d16382008-07-08 23:14:46 -07001279static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280{
1281#ifdef CONFIG_NETPOLL_TRAP
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001282 if (netpoll_trap()) {
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001283 netif_tx_start_queue(dev_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 return;
Sergei Shtylyov5f286e12007-04-28 20:57:37 -07001285 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286#endif
David S. Miller79d16382008-07-08 23:14:46 -07001287 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001288 __netif_schedule(dev_queue->qdisc);
David S. Miller79d16382008-07-08 23:14:46 -07001289}
1290
Dave Jonesd29f7492008-07-22 14:09:06 -07001291/**
1292 * netif_wake_queue - restart transmit
1293 * @dev: network device
1294 *
1295 * Allow upper layers to call the device hard_start_xmit routine.
1296 * Used for flow control when transmit resources are available.
1297 */
David S. Miller79d16382008-07-08 23:14:46 -07001298static inline void netif_wake_queue(struct net_device *dev)
1299{
David S. Millere8a04642008-07-17 00:34:19 -07001300 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301}
1302
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001303static inline void netif_tx_wake_all_queues(struct net_device *dev)
1304{
1305 unsigned int i;
1306
1307 for (i = 0; i < dev->num_tx_queues; i++) {
1308 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1309 netif_tx_wake_queue(txq);
1310 }
1311}
1312
Dave Jonesd29f7492008-07-22 14:09:06 -07001313static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
1314{
1315 set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1316}
1317
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001318/**
1319 * netif_stop_queue - stop transmitted packets
1320 * @dev: network device
1321 *
1322 * Stop upper layers calling the device hard_start_xmit routine.
1323 * Used for flow control when transmit resources are unavailable.
1324 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325static inline void netif_stop_queue(struct net_device *dev)
1326{
David S. Millere8a04642008-07-17 00:34:19 -07001327 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328}
1329
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001330static inline void netif_tx_stop_all_queues(struct net_device *dev)
1331{
1332 unsigned int i;
1333
1334 for (i = 0; i < dev->num_tx_queues; i++) {
1335 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1336 netif_tx_stop_queue(txq);
1337 }
1338}
1339
Dave Jonesd29f7492008-07-22 14:09:06 -07001340static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
1341{
1342 return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1343}
1344
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001345/**
1346 * netif_queue_stopped - test if transmit queue is flowblocked
1347 * @dev: network device
1348 *
1349 * Test if transmit queue on device is currently unable to send.
1350 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351static inline int netif_queue_stopped(const struct net_device *dev)
1352{
David S. Millere8a04642008-07-17 00:34:19 -07001353 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354}
1355
David S. Millerc3f26a22008-07-31 16:58:50 -07001356static inline int netif_tx_queue_frozen(const struct netdev_queue *dev_queue)
1357{
1358 return test_bit(__QUEUE_STATE_FROZEN, &dev_queue->state);
1359}
1360
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001361/**
1362 * netif_running - test if up
1363 * @dev: network device
1364 *
1365 * Test if the device has been brought up.
1366 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367static inline int netif_running(const struct net_device *dev)
1368{
1369 return test_bit(__LINK_STATE_START, &dev->state);
1370}
1371
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001372/*
1373 * Routines to manage the subqueues on a device. We only need start
1374 * stop, and a check if it's stopped. All other device management is
1375 * done at the overall netdevice level.
1376 * Also test the device if we're multiqueue.
1377 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001378
1379/**
1380 * netif_start_subqueue - allow sending packets on subqueue
1381 * @dev: network device
1382 * @queue_index: sub queue index
1383 *
1384 * Start individual transmit queue of a device with multiple transmit queues.
1385 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001386static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
1387{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001388 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001389
1390 netif_tx_start_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001391}
1392
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001393/**
1394 * netif_stop_subqueue - stop sending packets on subqueue
1395 * @dev: network device
1396 * @queue_index: sub queue index
1397 *
1398 * Stop individual transmit queue of a device with multiple transmit queues.
1399 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001400static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
1401{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001402 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001403#ifdef CONFIG_NETPOLL_TRAP
1404 if (netpoll_trap())
1405 return;
1406#endif
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001407 netif_tx_stop_queue(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001408}
1409
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001410/**
1411 * netif_subqueue_stopped - test status of subqueue
1412 * @dev: network device
1413 * @queue_index: sub queue index
1414 *
1415 * Check individual transmit queue of a device with multiple transmit queues.
1416 */
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001417static inline int __netif_subqueue_stopped(const struct net_device *dev,
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001418 u16 queue_index)
1419{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001420 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001421
1422 return netif_tx_queue_stopped(txq);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001423}
1424
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001425static inline int netif_subqueue_stopped(const struct net_device *dev,
1426 struct sk_buff *skb)
1427{
1428 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
1429}
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001430
1431/**
1432 * netif_wake_subqueue - allow sending packets on subqueue
1433 * @dev: network device
1434 * @queue_index: sub queue index
1435 *
1436 * Resume individual transmit queue of a device with multiple transmit queues.
1437 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001438static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
1439{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001440 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001441#ifdef CONFIG_NETPOLL_TRAP
1442 if (netpoll_trap())
1443 return;
1444#endif
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001445 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
David S. Miller37437bb2008-07-16 02:15:04 -07001446 __netif_schedule(txq->qdisc);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001447}
1448
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001449/**
1450 * netif_is_multiqueue - test if device has multiple transmit queues
1451 * @dev: network device
1452 *
1453 * Check if device has multiple transmit queues
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001454 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001455static inline int netif_is_multiqueue(const struct net_device *dev)
1456{
David S. Miller09e83b52008-07-17 01:52:12 -07001457 return (dev->num_tx_queues > 1);
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001458}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
1460/* Use this variant when it is known for sure that it
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07001461 * is executing from hardware interrupt context or with hardware interrupts
1462 * disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001464extern void dev_kfree_skb_irq(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465
1466/* Use this variant in places where it could be invoked
Matti Linnanvuori0ef47302008-03-28 16:33:00 -07001467 * from either hardware interrupt or other context, with hardware interrupts
1468 * either disabled or enabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 */
Denis Vlasenko56079432006-03-29 15:57:29 -08001470extern void dev_kfree_skb_any(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
1472#define HAVE_NETIF_RX 1
1473extern int netif_rx(struct sk_buff *skb);
1474extern int netif_rx_ni(struct sk_buff *skb);
1475#define HAVE_NETIF_RECEIVE_SKB 1
1476extern int netif_receive_skb(struct sk_buff *skb);
Herbert Xud565b0a2008-12-15 23:38:52 -08001477extern void napi_gro_flush(struct napi_struct *napi);
Herbert Xu96e93ea2009-01-06 10:49:34 -08001478extern int dev_gro_receive(struct napi_struct *napi,
1479 struct sk_buff *skb);
Herbert Xu5d0d9be2009-01-29 14:19:48 +00001480extern int napi_skb_finish(int ret, struct sk_buff *skb);
Herbert Xud565b0a2008-12-15 23:38:52 -08001481extern int napi_gro_receive(struct napi_struct *napi,
1482 struct sk_buff *skb);
Herbert Xu96e93ea2009-01-06 10:49:34 -08001483extern void napi_reuse_skb(struct napi_struct *napi,
1484 struct sk_buff *skb);
Herbert Xu76620aa2009-04-16 02:02:07 -07001485extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
Herbert Xu5d0d9be2009-01-29 14:19:48 +00001486extern int napi_frags_finish(struct napi_struct *napi,
1487 struct sk_buff *skb, int ret);
Herbert Xu76620aa2009-04-16 02:02:07 -07001488extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
1489extern int napi_gro_frags(struct napi_struct *napi);
1490
1491static inline void napi_free_frags(struct napi_struct *napi)
1492{
1493 kfree_skb(napi->skb);
1494 napi->skb = NULL;
1495}
1496
Patrick McHardybc1d0412008-07-14 22:49:30 -07001497extern void netif_nit_deliver(struct sk_buff *skb);
Mitch Williamsc2373ee2005-11-09 10:34:45 -08001498extern int dev_valid_name(const char *name);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001499extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
1500extern int dev_ethtool(struct net *net, struct ifreq *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501extern unsigned dev_get_flags(const struct net_device *);
1502extern int dev_change_flags(struct net_device *, unsigned);
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -07001503extern int dev_change_name(struct net_device *, const char *);
Stephen Hemminger0b815a12008-09-22 21:28:11 -07001504extern int dev_set_alias(struct net_device *, const char *, size_t);
Eric W. Biedermance286d32007-09-12 13:53:49 +02001505extern int dev_change_net_namespace(struct net_device *,
1506 struct net *, const char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507extern int dev_set_mtu(struct net_device *, int);
1508extern int dev_set_mac_address(struct net_device *,
1509 struct sockaddr *);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001510extern int dev_hard_start_xmit(struct sk_buff *skb,
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001511 struct net_device *dev,
1512 struct netdev_queue *txq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001514extern int netdev_budget;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515
1516/* Called by rtnetlink.c:rtnl_unlock() */
1517extern void netdev_run_todo(void);
1518
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001519/**
1520 * dev_put - release reference to device
1521 * @dev: network device
1522 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07001523 * Release reference to device to allow it to be freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001524 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525static inline void dev_put(struct net_device *dev)
1526{
1527 atomic_dec(&dev->refcnt);
1528}
1529
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001530/**
1531 * dev_hold - get reference to device
1532 * @dev: network device
1533 *
Benjamin Thery9ef44292007-10-10 21:18:17 -07001534 * Hold reference to device to keep it from being freed.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001535 */
Stephen Hemminger15333062006-03-20 22:32:28 -08001536static inline void dev_hold(struct net_device *dev)
1537{
1538 atomic_inc(&dev->refcnt);
1539}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540
1541/* Carrier loss detection, dial on demand. The functions netif_carrier_on
1542 * and _off may be called from IRQ context, but it is caller
1543 * who is responsible for serialization of these calls.
Stefan Rompfb00055a2006-03-20 17:09:11 -08001544 *
1545 * The name carrier is inappropriate, these functions should really be
1546 * called netif_lowerlayer_*() because they represent the state of any
1547 * kind of lower layer not just hardware media.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 */
1549
1550extern void linkwatch_fire_event(struct net_device *dev);
1551
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001552/**
1553 * netif_carrier_ok - test if carrier present
1554 * @dev: network device
1555 *
1556 * Check if carrier is present on device
1557 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558static inline int netif_carrier_ok(const struct net_device *dev)
1559{
1560 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
1561}
1562
Eric Dumazet9d214932009-05-17 20:55:16 -07001563extern unsigned long dev_trans_start(struct net_device *dev);
1564
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565extern void __netdev_watchdog_up(struct net_device *dev);
1566
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07001567extern void netif_carrier_on(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
Denis Vlasenko0a242ef2005-08-11 15:32:53 -07001569extern void netif_carrier_off(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001571/**
1572 * netif_dormant_on - mark device as dormant.
1573 * @dev: network device
1574 *
1575 * Mark device as dormant (as per RFC2863).
1576 *
1577 * The dormant state indicates that the relevant interface is not
1578 * actually in a condition to pass packets (i.e., it is not 'up') but is
1579 * in a "pending" state, waiting for some external event. For "on-
1580 * demand" interfaces, this new state identifies the situation where the
1581 * interface is waiting for events to place it in the up state.
1582 *
1583 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001584static inline void netif_dormant_on(struct net_device *dev)
1585{
1586 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
1587 linkwatch_fire_event(dev);
1588}
1589
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001590/**
1591 * netif_dormant_off - set device as not dormant.
1592 * @dev: network device
1593 *
1594 * Device is not in dormant state.
1595 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001596static inline void netif_dormant_off(struct net_device *dev)
1597{
1598 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
1599 linkwatch_fire_event(dev);
1600}
1601
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001602/**
1603 * netif_dormant - test if carrier present
1604 * @dev: network device
1605 *
1606 * Check if carrier is present on device
1607 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001608static inline int netif_dormant(const struct net_device *dev)
1609{
1610 return test_bit(__LINK_STATE_DORMANT, &dev->state);
1611}
1612
1613
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001614/**
1615 * netif_oper_up - test if device is operational
1616 * @dev: network device
1617 *
1618 * Check if carrier is operational
1619 */
Stefan Rompfb00055a2006-03-20 17:09:11 -08001620static inline int netif_oper_up(const struct net_device *dev) {
1621 return (dev->operstate == IF_OPER_UP ||
1622 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
1623}
1624
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001625/**
1626 * netif_device_present - is device available or removed
1627 * @dev: network device
1628 *
1629 * Check if device has not been removed from system.
1630 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631static inline int netif_device_present(struct net_device *dev)
1632{
1633 return test_bit(__LINK_STATE_PRESENT, &dev->state);
1634}
1635
Denis Vlasenko56079432006-03-29 15:57:29 -08001636extern void netif_device_detach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
Denis Vlasenko56079432006-03-29 15:57:29 -08001638extern void netif_device_attach(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639
1640/*
1641 * Network interface message level settings
1642 */
1643#define HAVE_NETIF_MSG 1
1644
1645enum {
1646 NETIF_MSG_DRV = 0x0001,
1647 NETIF_MSG_PROBE = 0x0002,
1648 NETIF_MSG_LINK = 0x0004,
1649 NETIF_MSG_TIMER = 0x0008,
1650 NETIF_MSG_IFDOWN = 0x0010,
1651 NETIF_MSG_IFUP = 0x0020,
1652 NETIF_MSG_RX_ERR = 0x0040,
1653 NETIF_MSG_TX_ERR = 0x0080,
1654 NETIF_MSG_TX_QUEUED = 0x0100,
1655 NETIF_MSG_INTR = 0x0200,
1656 NETIF_MSG_TX_DONE = 0x0400,
1657 NETIF_MSG_RX_STATUS = 0x0800,
1658 NETIF_MSG_PKTDATA = 0x1000,
1659 NETIF_MSG_HW = 0x2000,
1660 NETIF_MSG_WOL = 0x4000,
1661};
1662
1663#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
1664#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
1665#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
1666#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
1667#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
1668#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
1669#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
1670#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
1671#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
1672#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
1673#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
1674#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
1675#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
1676#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
1677#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
1678
1679static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
1680{
1681 /* use default */
1682 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
1683 return default_msg_enable_bits;
1684 if (debug_value == 0) /* no output */
1685 return 0;
1686 /* set low N bits */
1687 return (1 << debug_value) - 1;
1688}
1689
David S. Millerc773e842008-07-08 23:13:53 -07001690static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
Herbert Xu932ff272006-06-09 12:20:56 -07001691{
David S. Millerc773e842008-07-08 23:13:53 -07001692 spin_lock(&txq->_xmit_lock);
1693 txq->xmit_lock_owner = cpu;
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001694}
1695
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001696static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
1697{
1698 spin_lock_bh(&txq->_xmit_lock);
1699 txq->xmit_lock_owner = smp_processor_id();
1700}
1701
David S. Millerc773e842008-07-08 23:13:53 -07001702static inline int __netif_tx_trylock(struct netdev_queue *txq)
1703{
1704 int ok = spin_trylock(&txq->_xmit_lock);
1705 if (likely(ok))
1706 txq->xmit_lock_owner = smp_processor_id();
1707 return ok;
Herbert Xu932ff272006-06-09 12:20:56 -07001708}
1709
David S. Millerc773e842008-07-08 23:13:53 -07001710static inline void __netif_tx_unlock(struct netdev_queue *txq)
1711{
1712 txq->xmit_lock_owner = -1;
1713 spin_unlock(&txq->_xmit_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07001714}
1715
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001716static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
1717{
1718 txq->xmit_lock_owner = -1;
1719 spin_unlock_bh(&txq->_xmit_lock);
1720}
1721
Eric Dumazet08baf562009-05-25 22:58:01 -07001722static inline void txq_trans_update(struct netdev_queue *txq)
1723{
1724 if (txq->xmit_lock_owner != -1)
1725 txq->trans_start = jiffies;
1726}
1727
David S. Millerc3f26a22008-07-31 16:58:50 -07001728/**
1729 * netif_tx_lock - grab network device transmit lock
1730 * @dev: network device
David S. Millerc3f26a22008-07-31 16:58:50 -07001731 *
1732 * Get network device transmit lock
1733 */
1734static inline void netif_tx_lock(struct net_device *dev)
1735{
1736 unsigned int i;
1737 int cpu;
1738
1739 spin_lock(&dev->tx_global_lock);
1740 cpu = smp_processor_id();
1741 for (i = 0; i < dev->num_tx_queues; i++) {
1742 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1743
1744 /* We are the only thread of execution doing a
1745 * freeze, but we have to grab the _xmit_lock in
1746 * order to synchronize with threads which are in
1747 * the ->hard_start_xmit() handler and already
1748 * checked the frozen bit.
1749 */
1750 __netif_tx_lock(txq, cpu);
1751 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
1752 __netif_tx_unlock(txq);
1753 }
1754}
1755
1756static inline void netif_tx_lock_bh(struct net_device *dev)
1757{
1758 local_bh_disable();
1759 netif_tx_lock(dev);
1760}
1761
Herbert Xu932ff272006-06-09 12:20:56 -07001762static inline void netif_tx_unlock(struct net_device *dev)
1763{
David S. Millere8a04642008-07-17 00:34:19 -07001764 unsigned int i;
David S. Millerc773e842008-07-08 23:13:53 -07001765
David S. Millere8a04642008-07-17 00:34:19 -07001766 for (i = 0; i < dev->num_tx_queues; i++) {
1767 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millere8a04642008-07-17 00:34:19 -07001768
David S. Millerc3f26a22008-07-31 16:58:50 -07001769 /* No need to grab the _xmit_lock here. If the
1770 * queue is not stopped for another reason, we
1771 * force a schedule.
1772 */
1773 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
Krishna Kumar7b3d3e42009-08-29 20:21:21 +00001774 netif_schedule_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07001775 }
1776 spin_unlock(&dev->tx_global_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07001777}
1778
1779static inline void netif_tx_unlock_bh(struct net_device *dev)
1780{
David S. Millere8a04642008-07-17 00:34:19 -07001781 netif_tx_unlock(dev);
1782 local_bh_enable();
Herbert Xu932ff272006-06-09 12:20:56 -07001783}
1784
David S. Millerc773e842008-07-08 23:13:53 -07001785#define HARD_TX_LOCK(dev, txq, cpu) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001786 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07001787 __netif_tx_lock(txq, cpu); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001788 } \
1789}
1790
David S. Millerc773e842008-07-08 23:13:53 -07001791#define HARD_TX_UNLOCK(dev, txq) { \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001792 if ((dev->features & NETIF_F_LLTX) == 0) { \
David S. Millerc773e842008-07-08 23:13:53 -07001793 __netif_tx_unlock(txq); \
Jamal Hadi Salim22dd7492007-09-16 14:40:49 -07001794 } \
1795}
1796
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797static inline void netif_tx_disable(struct net_device *dev)
1798{
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001799 unsigned int i;
David S. Millerc3f26a22008-07-31 16:58:50 -07001800 int cpu;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001801
David S. Millerc3f26a22008-07-31 16:58:50 -07001802 local_bh_disable();
1803 cpu = smp_processor_id();
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001804 for (i = 0; i < dev->num_tx_queues; i++) {
1805 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
David S. Millerc3f26a22008-07-31 16:58:50 -07001806
1807 __netif_tx_lock(txq, cpu);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001808 netif_tx_stop_queue(txq);
David S. Millerc3f26a22008-07-31 16:58:50 -07001809 __netif_tx_unlock(txq);
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001810 }
David S. Millerc3f26a22008-07-31 16:58:50 -07001811 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812}
1813
David S. Millere308a5d2008-07-15 00:13:44 -07001814static inline void netif_addr_lock(struct net_device *dev)
1815{
1816 spin_lock(&dev->addr_list_lock);
1817}
1818
1819static inline void netif_addr_lock_bh(struct net_device *dev)
1820{
1821 spin_lock_bh(&dev->addr_list_lock);
1822}
1823
1824static inline void netif_addr_unlock(struct net_device *dev)
1825{
1826 spin_unlock(&dev->addr_list_lock);
1827}
1828
1829static inline void netif_addr_unlock_bh(struct net_device *dev)
1830{
1831 spin_unlock_bh(&dev->addr_list_lock);
1832}
1833
Jiri Pirkof001fde2009-05-05 02:48:28 +00001834/*
Jiri Pirko31278e72009-06-17 01:12:19 +00001835 * dev_addrs walker. Should be used only for read access. Call with
Jiri Pirkof001fde2009-05-05 02:48:28 +00001836 * rcu_read_lock held.
1837 */
1838#define for_each_dev_addr(dev, ha) \
Jiri Pirko31278e72009-06-17 01:12:19 +00001839 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
Jiri Pirkof001fde2009-05-05 02:48:28 +00001840
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841/* These functions live elsewhere (drivers/net/net_init.c, but related) */
1842
1843extern void ether_setup(struct net_device *dev);
1844
1845/* Support for loadable net-drivers */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001846extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
1847 void (*setup)(struct net_device *),
1848 unsigned int queue_count);
1849#define alloc_netdev(sizeof_priv, name, setup) \
1850 alloc_netdev_mq(sizeof_priv, name, setup, 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851extern int register_netdev(struct net_device *dev);
1852extern void unregister_netdev(struct net_device *dev);
Jiri Pirkof001fde2009-05-05 02:48:28 +00001853
1854/* Functions used for device addresses handling */
1855extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
1856 unsigned char addr_type);
1857extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
1858 unsigned char addr_type);
1859extern int dev_addr_add_multiple(struct net_device *to_dev,
1860 struct net_device *from_dev,
1861 unsigned char addr_type);
1862extern int dev_addr_del_multiple(struct net_device *to_dev,
1863 struct net_device *from_dev,
1864 unsigned char addr_type);
1865
Patrick McHardy4417da62007-06-27 01:28:10 -07001866/* Functions used for secondary unicast and multicast support */
1867extern void dev_set_rx_mode(struct net_device *dev);
1868extern void __dev_set_rx_mode(struct net_device *dev);
Jiri Pirkoccffad252009-05-22 23:22:17 +00001869extern int dev_unicast_delete(struct net_device *dev, void *addr);
1870extern int dev_unicast_add(struct net_device *dev, void *addr);
Chris Leeche83a2ea2008-01-31 16:53:23 -08001871extern int dev_unicast_sync(struct net_device *to, struct net_device *from);
1872extern void dev_unicast_unsync(struct net_device *to, struct net_device *from);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
1874extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
Patrick McHardya0a400d2007-07-14 18:52:02 -07001875extern int dev_mc_sync(struct net_device *to, struct net_device *from);
1876extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07001877extern int __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);
1878extern int __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);
Chris Leeche83a2ea2008-01-31 16:53:23 -08001879extern int __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
1880extern 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 -07001881extern int dev_set_promiscuity(struct net_device *dev, int inc);
1882extern int dev_set_allmulti(struct net_device *dev, int inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883extern void netdev_state_change(struct net_device *dev);
Moni Shoua75c78502009-09-15 02:37:40 -07001884extern void netdev_bonding_change(struct net_device *dev,
1885 unsigned long event);
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -07001886extern void netdev_features_change(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887/* Load a device via the kmod */
Eric W. Biederman881d9662007-09-17 11:56:21 -07001888extern void dev_load(struct net *net, const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889extern void dev_mcast_init(void);
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -08001890extern const struct net_device_stats *dev_get_stats(struct net_device *dev);
1891
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892extern int netdev_max_backlog;
1893extern int weight_p;
1894extern int netdev_set_master(struct net_device *dev, struct net_device *master);
Patrick McHardy84fa7932006-08-29 16:44:56 -07001895extern int skb_checksum_help(struct sk_buff *skb);
Herbert Xu576a30e2006-06-27 13:22:38 -07001896extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
Herbert Xufb286bb2005-11-10 13:01:24 -08001897#ifdef CONFIG_BUG
1898extern void netdev_rx_csum_fault(struct net_device *dev);
1899#else
1900static inline void netdev_rx_csum_fault(struct net_device *dev)
1901{
1902}
1903#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904/* rx skb timestamps */
1905extern void net_enable_timestamp(void);
1906extern void net_disable_timestamp(void);
1907
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001908#ifdef CONFIG_PROC_FS
1909extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
1910extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
1911extern void dev_seq_stop(struct seq_file *seq, void *v);
1912#endif
1913
Jay Vosburghb8a97872008-06-13 18:12:04 -07001914extern int netdev_class_create_file(struct class_attribute *class_attr);
1915extern void netdev_class_remove_file(struct class_attribute *class_attr);
1916
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -07001917extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);
Arjan van de Ven6579e572008-07-21 13:31:48 -07001918
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001919extern void linkwatch_run_queue(void);
1920
Herbert Xub63365a2008-10-23 01:11:29 -07001921unsigned long netdev_increment_features(unsigned long all, unsigned long one,
1922 unsigned long mask);
1923unsigned long netdev_fix_features(unsigned long features, const char *name);
Herbert Xu7f353bf2007-08-10 15:47:58 -07001924
Herbert Xubcd76112006-06-30 13:36:35 -07001925static inline int net_gso_ok(int features, int gso_type)
1926{
1927 int feature = gso_type << NETIF_F_GSO_SHIFT;
1928 return (features & feature) == feature;
1929}
1930
Herbert Xu576a30e2006-06-27 13:22:38 -07001931static inline int skb_gso_ok(struct sk_buff *skb, int features)
1932{
Herbert Xu278b2512009-06-03 21:20:51 -07001933 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
David S. Millera5bd8a12009-06-09 00:17:27 -07001934 (!skb_has_frags(skb) || (features & NETIF_F_FRAGLIST));
Herbert Xu576a30e2006-06-27 13:22:38 -07001935}
1936
Herbert Xu79671682006-06-22 02:40:14 -07001937static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
1938{
Herbert Xua430a432006-07-08 13:34:56 -07001939 return skb_is_gso(skb) &&
1940 (!skb_gso_ok(skb, dev->features) ||
Patrick McHardy84fa7932006-08-29 16:44:56 -07001941 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
Herbert Xu79671682006-06-22 02:40:14 -07001942}
1943
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001944static inline void netif_set_gso_max_size(struct net_device *dev,
1945 unsigned int size)
1946{
1947 dev->gso_max_size = size;
1948}
1949
Jiri Pirko5d4e0392009-05-28 01:05:00 +00001950static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
1951 struct net_device *master)
1952{
1953 if (skb->pkt_type == PACKET_HOST) {
1954 u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
1955
1956 memcpy(dest, master->dev_addr, ETH_ALEN);
1957 }
1958}
1959
David S. Miller7ea49ed2006-08-14 17:08:36 -07001960/* On bonding slaves other than the currently active slave, suppress
Jay Vosburghf5b2b962006-09-22 21:54:53 -07001961 * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
1962 * ARP on active-backup slaves with arp_validate enabled.
David S. Miller7ea49ed2006-08-14 17:08:36 -07001963 */
1964static inline int skb_bond_should_drop(struct sk_buff *skb)
1965{
1966 struct net_device *dev = skb->dev;
1967 struct net_device *master = dev->master;
1968
Jay Vosburgh6cf3f412008-11-03 18:16:50 -08001969 if (master) {
1970 if (master->priv_flags & IFF_MASTER_ARPMON)
1971 dev->last_rx = jiffies;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07001972
Jiri Pirko5d4e0392009-05-28 01:05:00 +00001973 if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {
1974 /* Do address unmangle. The local destination address
1975 * will be always the one master has. Provides the right
1976 * functionality in a bridge.
1977 */
1978 skb_bond_set_mac_by_master(skb, master);
1979 }
1980
Jay Vosburgh6cf3f412008-11-03 18:16:50 -08001981 if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
1982 if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
Harvey Harrisonf3a7c662009-02-14 22:58:35 -08001983 skb->protocol == __cpu_to_be16(ETH_P_ARP))
David S. Miller7ea49ed2006-08-14 17:08:36 -07001984 return 0;
David S. Miller7ea49ed2006-08-14 17:08:36 -07001985
Jay Vosburgh6cf3f412008-11-03 18:16:50 -08001986 if (master->priv_flags & IFF_MASTER_ALB) {
1987 if (skb->pkt_type != PACKET_BROADCAST &&
1988 skb->pkt_type != PACKET_MULTICAST)
1989 return 0;
1990 }
1991 if (master->priv_flags & IFF_MASTER_8023AD &&
Harvey Harrisonf3a7c662009-02-14 22:58:35 -08001992 skb->protocol == __cpu_to_be16(ETH_P_SLOW))
Jay Vosburgh6cf3f412008-11-03 18:16:50 -08001993 return 0;
1994
1995 return 1;
1996 }
David S. Miller7ea49ed2006-08-14 17:08:36 -07001997 }
1998 return 0;
1999}
2000
Eric W. Biederman505d4f72008-11-07 22:54:20 -08002001extern struct pernet_operations __net_initdata loopback_net_ops;
Patrick McHardyb1b67dd2009-04-20 04:49:28 +00002002
2003static inline int dev_ethtool_get_settings(struct net_device *dev,
2004 struct ethtool_cmd *cmd)
2005{
2006 if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
2007 return -EOPNOTSUPP;
2008 return dev->ethtool_ops->get_settings(dev, cmd);
2009}
2010
2011static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
2012{
2013 if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
2014 return 0;
2015 return dev->ethtool_ops->get_rx_csum(dev);
2016}
2017
2018static inline u32 dev_ethtool_get_flags(struct net_device *dev)
2019{
2020 if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
2021 return 0;
2022 return dev->ethtool_ops->get_flags(dev);
2023}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024#endif /* __KERNEL__ */
2025
Jiri Pirko385a1542009-05-27 15:48:07 -07002026#endif /* _LINUX_NETDEVICE_H */