]> bbs.cooldavid.org Git - net-next-2.6.git/blame - include/linux/netdevice.h
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[WEXT] net_device: Don't include wext bits if not required.
[net-next-2.6.git] / include / linux / netdevice.h
CommitLineData
1da177e4
LT		 1/*
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 *
02c30a84 10 * Authors: Ross Biro
1da177e4
LT		 11 * 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>
14 * Alan Cox, <Alan.Cox@linux.org>
15 * 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__
d7fe0f24 33#include <linux/timer.h>
1da177e4
LT		 34#include <asm/atomic.h>
35#include <asm/cache.h>
36#include <asm/byteorder.h>
37
1da177e4
LT		 38#include <linux/device.h>
39#include <linux/percpu.h>
db217334 40#include <linux/dmaengine.h>
1da177e4 41
1da177e4
LT		 42struct vlan_group;
43struct ethtool_ops;
115c1d6e 44struct netpoll_info;
704232c2
JB		 45/* 802.11 specific */
46struct wireless_dev;
1da177e4
LT		 47 /* source back-compat hooks */
48#define SET_ETHTOOL_OPS(netdev,ops) \
49 ( (netdev)->ethtool_ops = (ops) )
50
51#define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev
52 functions are available. */
53#define HAVE_FREE_NETDEV /* free_netdev() */
54#define HAVE_NETDEV_PRIV /* netdev_priv() */
55
56#define NET_XMIT_SUCCESS 0
57#define NET_XMIT_DROP 1 /* skb dropped */
58#define NET_XMIT_CN 2 /* congestion notification */
59#define NET_XMIT_POLICED 3 /* skb is shot by police */
60#define NET_XMIT_BYPASS 4 /* packet does not leave via dequeue;
61 (TC use only - dev_queue_xmit
62 returns this as NET_XMIT_SUCCESS) */
63
64/* Backlog congestion levels */
65#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
66#define NET_RX_DROP 1 /* packet dropped */
67#define NET_RX_CN_LOW 2 /* storm alert, just in case */
68#define NET_RX_CN_MOD 3 /* Storm on its way! */
69#define NET_RX_CN_HIGH 4 /* The storm is here */
70#define NET_RX_BAD 5 /* packet dropped due to kernel error */
71
b9df3cb8
GR		 72/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
73 * indicates that the device will soon be dropping packets, or already drops
74 * some packets of the same priority; prompting us to send less aggressively. */
75#define net_xmit_eval(e) ((e) == NET_XMIT_CN? 0 : (e))
1da177e4
LT		 76#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
77
78#endif
79
80#define MAX_ADDR_LEN 32 /* Largest hardware address length */
81
82/* Driver transmit return codes */
83#define NETDEV_TX_OK 0 /* driver took care of packet */
84#define NETDEV_TX_BUSY 1 /* driver tx path was busy*/
85#define NETDEV_TX_LOCKED -1 /* driver tx lock was already taken */
86
87/*
88 * Compute the worst case header length according to the protocols
89 * used.
90 */
91
92#if !defined(CONFIG_AX25) && !defined(CONFIG_AX25_MODULE) && !defined(CONFIG_TR)
93#define LL_MAX_HEADER 32
94#else
95#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
96#define LL_MAX_HEADER 96
97#else
98#define LL_MAX_HEADER 48
99#endif
100#endif
101
e81c7359
DM		 102#if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
103 !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
104 !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
105 !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
1da177e4
LT		 106#define MAX_HEADER LL_MAX_HEADER
107#else
108#define MAX_HEADER (LL_MAX_HEADER + 48)
109#endif
110
111/*
112 * Network device statistics. Akin to the 2.0 ether stats but
113 * with byte counters.
114 */
115
116struct net_device_stats
117{
118 unsigned long rx_packets; /* total packets received */
119 unsigned long tx_packets; /* total packets transmitted */
120 unsigned long rx_bytes; /* total bytes received */
121 unsigned long tx_bytes; /* total bytes transmitted */
122 unsigned long rx_errors; /* bad packets received */
123 unsigned long tx_errors; /* packet transmit problems */
124 unsigned long rx_dropped; /* no space in linux buffers */
125 unsigned long tx_dropped; /* no space available in linux */
126 unsigned long multicast; /* multicast packets received */
127 unsigned long collisions;
128
129 /* detailed rx_errors: */
130 unsigned long rx_length_errors;
131 unsigned long rx_over_errors; /* receiver ring buff overflow */
132 unsigned long rx_crc_errors; /* recved pkt with crc error */
133 unsigned long rx_frame_errors; /* recv'd frame alignment error */
134 unsigned long rx_fifo_errors; /* recv'r fifo overrun */
135 unsigned long rx_missed_errors; /* receiver missed packet */
136
137 /* detailed tx_errors */
138 unsigned long tx_aborted_errors;
139 unsigned long tx_carrier_errors;
140 unsigned long tx_fifo_errors;
141 unsigned long tx_heartbeat_errors;
142 unsigned long tx_window_errors;
143
144 /* for cslip etc */
145 unsigned long rx_compressed;
146 unsigned long tx_compressed;
147};
148
149
150/* Media selection options. */
151enum {
152 IF_PORT_UNKNOWN = 0,
153 IF_PORT_10BASE2,
154 IF_PORT_10BASET,
155 IF_PORT_AUI,
156 IF_PORT_100BASET,
157 IF_PORT_100BASETX,
158 IF_PORT_100BASEFX
159};
160
161#ifdef __KERNEL__
162
163#include <linux/cache.h>
164#include <linux/skbuff.h>
165
166struct neighbour;
167struct neigh_parms;
168struct sk_buff;
169
170struct netif_rx_stats
171{
172 unsigned total;
173 unsigned dropped;
174 unsigned time_squeeze;
1da177e4
LT		 175 unsigned cpu_collision;
176};
177
178DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
179
180
181/*
182 * We tag multicasts with these structures.
183 */
184
185struct dev_mc_list
186{
187 struct dev_mc_list *next;
188 __u8 dmi_addr[MAX_ADDR_LEN];
189 unsigned char dmi_addrlen;
190 int dmi_users;
191 int dmi_gusers;
192};
193
194struct hh_cache
195{
196 struct hh_cache *hh_next; /* Next entry */
197 atomic_t hh_refcnt; /* number of users */
f0490980
ED		 198/*
199 * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
200 * cache line on SMP.
201 * They are mostly read, but hh_refcnt may be changed quite frequently,
202 * incurring cache line ping pongs.
203 */
204 __be16 hh_type ____cacheline_aligned_in_smp;
205 /* protocol identifier, f.e ETH_P_IP
1da177e4
LT		 206 * NOTE: For VLANs, this will be the
207 * encapuslated type. --BLG
208 */
d5c42c0e 209 u16 hh_len; /* length of header */
1da177e4 210 int (*hh_output)(struct sk_buff *skb);
3644f0ce 211 seqlock_t hh_lock;
1da177e4
LT		 212
213 /* cached hardware header; allow for machine alignment needs. */
214#define HH_DATA_MOD 16
215#define HH_DATA_OFF(__len) \
5ba0eac6 216 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
1da177e4
LT		 217#define HH_DATA_ALIGN(__len) \
218 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
219 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
220};
221
222/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
223 * Alternative is:
224 * dev->hard_header_len ? (dev->hard_header_len +
225 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
226 *
227 * We could use other alignment values, but we must maintain the
228 * relationship HH alignment <= LL alignment.
229 */
230#define LL_RESERVED_SPACE(dev) \
231 (((dev)->hard_header_len&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
232#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
233 ((((dev)->hard_header_len+extra)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
234
235/* These flag bits are private to the generic network queueing
236 * layer, they may not be explicitly referenced by any other
237 * code.
238 */
239
240enum netdev_state_t
241{
242 __LINK_STATE_XOFF=0,
243 __LINK_STATE_START,
244 __LINK_STATE_PRESENT,
245 __LINK_STATE_SCHED,
246 __LINK_STATE_NOCARRIER,
247 __LINK_STATE_RX_SCHED,
b00055aa
SR		 248 __LINK_STATE_LINKWATCH_PENDING,
249 __LINK_STATE_DORMANT,
48d83325 250 __LINK_STATE_QDISC_RUNNING,
1da177e4
LT		 251};
252
253
254/*
255 * This structure holds at boot time configured netdevice settings. They
256 * are then used in the device probing.
257 */
258struct netdev_boot_setup {
259 char name[IFNAMSIZ];
260 struct ifmap map;
261};
262#define NETDEV_BOOT_SETUP_MAX 8
263
20380731 264extern int __init netdev_boot_setup(char *str);
1da177e4
LT		 265
266/*
267 * The DEVICE structure.
268 * Actually, this whole structure is a big mistake. It mixes I/O
269 * data with strictly "high-level" data, and it has to know about
270 * almost every data structure used in the INET module.
271 *
272 * FIXME: cleanup struct net_device such that network protocol info
273 * moves out.
274 */
275
276struct net_device
277{
278
279 /*
280 * This is the first field of the "visible" part of this structure
281 * (i.e. as seen by users in the "Space.c" file). It is the name
282 * the interface.
283 */
284 char name[IFNAMSIZ];
9356b8fc
ED		 285 /* device name hash chain */
286 struct hlist_node name_hlist;
1da177e4
LT		 287
288 /*
289 * I/O specific fields
290 * FIXME: Merge these and struct ifmap into one
291 */
292 unsigned long mem_end; /* shared mem end */
293 unsigned long mem_start; /* shared mem start */
294 unsigned long base_addr; /* device I/O address */
295 unsigned int irq; /* device IRQ number */
296
297 /*
298 * Some hardware also needs these fields, but they are not
299 * part of the usual set specified in Space.c.
300 */
301
302 unsigned char if_port; /* Selectable AUI, TP,..*/
303 unsigned char dma; /* DMA channel */
304
305 unsigned long state;
306
307 struct net_device *next;
308
309 /* The device initialization function. Called only once. */
310 int (*init)(struct net_device *dev);
311
312 /* ------- Fields preinitialized in Space.c finish here ------- */
313
9356b8fc
ED		 314 /* Net device features */
315 unsigned long features;
316#define NETIF_F_SG 1 /* Scatter/gather IO. */
317#define NETIF_F_IP_CSUM 2 /* Can checksum only TCP/UDP over IPv4. */
318#define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
319#define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
320#define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
321#define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
322#define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
323#define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
324#define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
325#define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
37c3185a 326#define NETIF_F_GSO 2048 /* Enable software GSO. */
9356b8fc 327#define NETIF_F_LLTX 4096 /* LockLess TX */
c45d286e 328#define NETIF_F_INTERNAL_STATS 8192 /* Use stats structure in net_device */
7967168c
HX		 329
330 /* Segmentation offload features */
331#define NETIF_F_GSO_SHIFT 16
bcd76111 332#define NETIF_F_GSO_MASK 0xffff0000
7967168c 333#define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
f83ef8c0 334#define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
576a30eb 335#define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
f83ef8c0
HX		 336#define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
337#define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
9356b8fc 338
78eb8877
HX		 339 /* List of features with software fallbacks. */
340#define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)
341
8648b305
HX		 342#define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
343#define NETIF_F_ALL_CSUM (NETIF_F_IP_CSUM | NETIF_F_GEN_CSUM)
344
1da177e4
LT		 345 struct net_device *next_sched;
346
347 /* Interface index. Unique device identifier */
348 int ifindex;
349 int iflink;
350
351
352 struct net_device_stats* (*get_stats)(struct net_device *dev);
c45d286e 353 struct net_device_stats stats;
1da177e4 354
b86e0280 355#ifdef CONFIG_WIRELESS_EXT
1da177e4
LT		 356 /* List of functions to handle Wireless Extensions (instead of ioctl).
357 * See <net/iw_handler.h> for details. Jean II */
358 const struct iw_handler_def * wireless_handlers;
359 /* Instance data managed by the core of Wireless Extensions. */
360 struct iw_public_data * wireless_data;
b86e0280 361#endif
76fd8593 362 const struct ethtool_ops *ethtool_ops;
1da177e4
LT		 363
364 /*
365 * This marks the end of the "visible" part of the structure. All
366 * fields hereafter are internal to the system, and may change at
367 * will (read: may be cleaned up at will).
368 */
369
1da177e4 370
b00055aa 371 unsigned int flags; /* interface flags (a la BSD) */
1da177e4
LT		 372 unsigned short gflags;
373 unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */
374 unsigned short padded; /* How much padding added by alloc_netdev() */
375
b00055aa
SR		 376 unsigned char operstate; /* RFC2863 operstate */
377 unsigned char link_mode; /* mapping policy to operstate */
378
1da177e4
LT		 379 unsigned mtu; /* interface MTU value */
380 unsigned short type; /* interface hardware type */
381 unsigned short hard_header_len; /* hardware hdr length */
1da177e4
LT		 382
383 struct net_device *master; /* Pointer to master device of a group,
384 * which this device is member of.
385 */
386
387 /* Interface address info. */
a6f9a705 388 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
1da177e4
LT		 389 unsigned char addr_len; /* hardware address length */
390 unsigned short dev_id; /* for shared network cards */
391
392 struct dev_mc_list *mc_list; /* Multicast mac addresses */
393 int mc_count; /* Number of installed mcasts */
394 int promiscuity;
395 int allmulti;
396
1da177e4
LT		 397
398 /* Protocol specific pointers */
399
400 void *atalk_ptr; /* AppleTalk link */
401 void *ip_ptr; /* IPv4 specific data */
402 void *dn_ptr; /* DECnet specific data */
403 void *ip6_ptr; /* IPv6 specific data */
404 void *ec_ptr; /* Econet specific data */
405 void *ax25_ptr; /* AX.25 specific data */
704232c2
JB		 406 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
407 assign before registering */
1da177e4 408
9356b8fc
ED		 409/*
410 * Cache line mostly used on receive path (including eth_type_trans())
411 */
412 struct list_head poll_list ____cacheline_aligned_in_smp;
413 /* Link to poll list */
414
415 int (*poll) (struct net_device *dev, int *quota);
1da177e4
LT		 416 int quota;
417 int weight;
9356b8fc
ED		 418 unsigned long last_rx; /* Time of last Rx */
419 /* Interface address info used in eth_type_trans() */
420 unsigned char dev_addr[MAX_ADDR_LEN]; /* hw address, (before bcast
421 because most packets are unicast) */
422
423 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
1da177e4 424
9356b8fc
ED		 425/*
426 * Cache line mostly used on queue transmit path (qdisc)
427 */
428 /* device queue lock */
429 spinlock_t queue_lock ____cacheline_aligned_in_smp;
1da177e4
LT		 430 struct Qdisc *qdisc;
431 struct Qdisc *qdisc_sleeping;
1da177e4
LT		 432 struct list_head qdisc_list;
433 unsigned long tx_queue_len; /* Max frames per queue allowed */
434
f6a78bfc
HX		 435 /* Partially transmitted GSO packet. */
436 struct sk_buff *gso_skb;
437
1da177e4
LT		 438 /* ingress path synchronizer */
439 spinlock_t ingress_lock;
9356b8fc
ED		 440 struct Qdisc *qdisc_ingress;
441
442/*
443 * One part is mostly used on xmit path (device)
444 */
1da177e4 445 /* hard_start_xmit synchronizer */
932ff279 446 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
1da177e4
LT		 447 /* cpu id of processor entered to hard_start_xmit or -1,
448 if nobody entered there.
449 */
450 int xmit_lock_owner;
9356b8fc
ED		 451 void *priv; /* pointer to private data */
452 int (*hard_start_xmit) (struct sk_buff *skb,
453 struct net_device *dev);
454 /* These may be needed for future network-power-down code. */
455 unsigned long trans_start; /* Time (in jiffies) of last Tx */
456
457 int watchdog_timeo; /* used by dev_watchdog() */
458 struct timer_list watchdog_timer;
459
460/*
461 * refcnt is a very hot point, so align it on SMP
462 */
1da177e4 463 /* Number of references to this device */
9356b8fc
ED		 464 atomic_t refcnt ____cacheline_aligned_in_smp;
465
1da177e4
LT		 466 /* delayed register/unregister */
467 struct list_head todo_list;
1da177e4
LT		 468 /* device index hash chain */
469 struct hlist_node index_hlist;
470
471 /* register/unregister state machine */
472 enum { NETREG_UNINITIALIZED=0,
b17a7c17 473 NETREG_REGISTERED, /* completed register_netdevice */
1da177e4
LT		 474 NETREG_UNREGISTERING, /* called unregister_netdevice */
475 NETREG_UNREGISTERED, /* completed unregister todo */
476 NETREG_RELEASED, /* called free_netdev */
477 } reg_state;
478
1da177e4
LT		 479 /* Called after device is detached from network. */
480 void (*uninit)(struct net_device *dev);
481 /* Called after last user reference disappears. */
482 void (*destructor)(struct net_device *dev);
483
484 /* Pointers to interface service routines. */
485 int (*open)(struct net_device *dev);
486 int (*stop)(struct net_device *dev);
1da177e4 487#define HAVE_NETDEV_POLL
1da177e4
LT		 488 int (*hard_header) (struct sk_buff *skb,
489 struct net_device *dev,
490 unsigned short type,
491 void *daddr,
492 void *saddr,
493 unsigned len);
494 int (*rebuild_header)(struct sk_buff *skb);
495#define HAVE_MULTICAST
496 void (*set_multicast_list)(struct net_device *dev);
497#define HAVE_SET_MAC_ADDR
498 int (*set_mac_address)(struct net_device *dev,
499 void *addr);
500#define HAVE_PRIVATE_IOCTL
501 int (*do_ioctl)(struct net_device *dev,
502 struct ifreq *ifr, int cmd);
503#define HAVE_SET_CONFIG
504 int (*set_config)(struct net_device *dev,
505 struct ifmap *map);
506#define HAVE_HEADER_CACHE
507 int (*hard_header_cache)(struct neighbour *neigh,
508 struct hh_cache *hh);
509 void (*header_cache_update)(struct hh_cache *hh,
510 struct net_device *dev,
511 unsigned char * haddr);
512#define HAVE_CHANGE_MTU
513 int (*change_mtu)(struct net_device *dev, int new_mtu);
514
515#define HAVE_TX_TIMEOUT
516 void (*tx_timeout) (struct net_device *dev);
517
518 void (*vlan_rx_register)(struct net_device *dev,
519 struct vlan_group *grp);
520 void (*vlan_rx_add_vid)(struct net_device *dev,
521 unsigned short vid);
522 void (*vlan_rx_kill_vid)(struct net_device *dev,
523 unsigned short vid);
524
525 int (*hard_header_parse)(struct sk_buff *skb,
526 unsigned char *haddr);
527 int (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
528#ifdef CONFIG_NETPOLL
115c1d6e 529 struct netpoll_info *npinfo;
1da177e4
LT		 530#endif
531#ifdef CONFIG_NET_POLL_CONTROLLER
532 void (*poll_controller)(struct net_device *dev);
533#endif
534
535 /* bridge stuff */
536 struct net_bridge_port *br_port;
537
1da177e4 538 /* class/net/name entry */
43cb76d9 539 struct device dev;
fe9925b5
SH		 540 /* space for optional statistics and wireless sysfs groups */
541 struct attribute_group *sysfs_groups[3];
1da177e4 542};
43cb76d9 543#define to_net_dev(d) container_of(d, struct net_device, dev)
1da177e4
LT		 544
545#define NETDEV_ALIGN 32
546#define NETDEV_ALIGN_CONST (NETDEV_ALIGN - 1)
547
548static inline void *netdev_priv(struct net_device *dev)
549{
550 return (char *)dev + ((sizeof(struct net_device)
551 + NETDEV_ALIGN_CONST)
552 & ~NETDEV_ALIGN_CONST);
553}
554
555#define SET_MODULE_OWNER(dev) do { } while (0)
556/* Set the sysfs physical device reference for the network logical device
557 * if set prior to registration will cause a symlink during initialization.
558 */
43cb76d9 559#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
1da177e4
LT		 560
561struct packet_type {
f2ccd8fa
DM		 562 __be16 type; /* This is really htons(ether_type). */
563 struct net_device *dev; /* NULL is wildcarded here */
564 int (*func) (struct sk_buff *,
565 struct net_device *,
566 struct packet_type *,
567 struct net_device *);
576a30eb
HX		 568 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
569 int features);
a430a43d 570 int (*gso_send_check)(struct sk_buff *skb);
1da177e4
LT		 571 void *af_packet_priv;
572 struct list_head list;
573};
574
575#include <linux/interrupt.h>
576#include <linux/notifier.h>
577
578extern struct net_device loopback_dev; /* The loopback */
579extern struct net_device *dev_base; /* All devices */
580extern rwlock_t dev_base_lock; /* Device list lock */
581
582extern int netdev_boot_setup_check(struct net_device *dev);
583extern unsigned long netdev_boot_base(const char *prefix, int unit);
584extern struct net_device *dev_getbyhwaddr(unsigned short type, char *hwaddr);
585extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
586extern void dev_add_pack(struct packet_type *pt);
587extern void dev_remove_pack(struct packet_type *pt);
588extern void __dev_remove_pack(struct packet_type *pt);
589
590extern struct net_device *dev_get_by_flags(unsigned short flags,
591 unsigned short mask);
592extern struct net_device *dev_get_by_name(const char *name);
593extern struct net_device *__dev_get_by_name(const char *name);
594extern int dev_alloc_name(struct net_device *dev, const char *name);
595extern int dev_open(struct net_device *dev);
596extern int dev_close(struct net_device *dev);
597extern int dev_queue_xmit(struct sk_buff *skb);
598extern int register_netdevice(struct net_device *dev);
22f8cde5 599extern void unregister_netdevice(struct net_device *dev);
1da177e4
LT		 600extern void free_netdev(struct net_device *dev);
601extern void synchronize_net(void);
602extern int register_netdevice_notifier(struct notifier_block *nb);
603extern int unregister_netdevice_notifier(struct notifier_block *nb);
604extern int call_netdevice_notifiers(unsigned long val, void *v);
605extern struct net_device *dev_get_by_index(int ifindex);
606extern struct net_device *__dev_get_by_index(int ifindex);
607extern int dev_restart(struct net_device *dev);
608#ifdef CONFIG_NETPOLL_TRAP
609extern int netpoll_trap(void);
610#endif
611
612typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
613extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
614static inline int unregister_gifconf(unsigned int family)
615{
616 return register_gifconf(family, NULL);
617}
618
619/*
620 * Incoming packets are placed on per-cpu queues so that
621 * no locking is needed.
622 */
623
624struct softnet_data
625{
31aa02c5 626 struct net_device *output_queue;
1da177e4
LT		 627 struct sk_buff_head input_pkt_queue;
628 struct list_head poll_list;
1da177e4
LT		 629 struct sk_buff *completion_queue;
630
631 struct net_device backlog_dev; /* Sorry. 8) */
db217334
CL		 632#ifdef CONFIG_NET_DMA
633 struct dma_chan *net_dma;
634#endif
1da177e4
LT		 635};
636
637DECLARE_PER_CPU(struct softnet_data,softnet_data);
638
639#define HAVE_NETIF_QUEUE
640
56079431 641extern void __netif_schedule(struct net_device *dev);
1da177e4
LT		 642
643static inline void netif_schedule(struct net_device *dev)
644{
645 if (!test_bit(__LINK_STATE_XOFF, &dev->state))
646 __netif_schedule(dev);
647}
648
649static inline void netif_start_queue(struct net_device *dev)
650{
651 clear_bit(__LINK_STATE_XOFF, &dev->state);
652}
653
654static inline void netif_wake_queue(struct net_device *dev)
655{
656#ifdef CONFIG_NETPOLL_TRAP
657 if (netpoll_trap())
658 return;
659#endif
660 if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
661 __netif_schedule(dev);
662}
663
664static inline void netif_stop_queue(struct net_device *dev)
665{
666#ifdef CONFIG_NETPOLL_TRAP
667 if (netpoll_trap())
668 return;
669#endif
670 set_bit(__LINK_STATE_XOFF, &dev->state);
671}
672
673static inline int netif_queue_stopped(const struct net_device *dev)
674{
675 return test_bit(__LINK_STATE_XOFF, &dev->state);
676}
677
678static inline int netif_running(const struct net_device *dev)
679{
680 return test_bit(__LINK_STATE_START, &dev->state);
681}
682
683
684/* Use this variant when it is known for sure that it
685 * is executing from interrupt context.
686 */
687static inline void dev_kfree_skb_irq(struct sk_buff *skb)
688{
689 if (atomic_dec_and_test(&skb->users)) {
690 struct softnet_data *sd;
691 unsigned long flags;
692
693 local_irq_save(flags);
694 sd = &__get_cpu_var(softnet_data);
695 skb->next = sd->completion_queue;
696 sd->completion_queue = skb;
697 raise_softirq_irqoff(NET_TX_SOFTIRQ);
698 local_irq_restore(flags);
699 }
700}
701
702/* Use this variant in places where it could be invoked
703 * either from interrupt or non-interrupt context.
704 */
56079431 705extern void dev_kfree_skb_any(struct sk_buff *skb);
1da177e4
LT		 706
707#define HAVE_NETIF_RX 1
708extern int netif_rx(struct sk_buff *skb);
709extern int netif_rx_ni(struct sk_buff *skb);
710#define HAVE_NETIF_RECEIVE_SKB 1
711extern int netif_receive_skb(struct sk_buff *skb);
c2373ee9 712extern int dev_valid_name(const char *name);
1da177e4
LT		 713extern int dev_ioctl(unsigned int cmd, void __user *);
714extern int dev_ethtool(struct ifreq *);
715extern unsigned dev_get_flags(const struct net_device *);
716extern int dev_change_flags(struct net_device *, unsigned);
717extern int dev_change_name(struct net_device *, char *);
718extern int dev_set_mtu(struct net_device *, int);
719extern int dev_set_mac_address(struct net_device *,
720 struct sockaddr *);
f6a78bfc
HX		 721extern int dev_hard_start_xmit(struct sk_buff *skb,
722 struct net_device *dev);
1da177e4
LT		 723
724extern void dev_init(void);
725
20380731 726extern int netdev_budget;
1da177e4
LT		 727
728/* Called by rtnetlink.c:rtnl_unlock() */
729extern void netdev_run_todo(void);
730
731static inline void dev_put(struct net_device *dev)
732{
733 atomic_dec(&dev->refcnt);
734}
735
15333061
SH		 736static inline void dev_hold(struct net_device *dev)
737{
738 atomic_inc(&dev->refcnt);
739}
1da177e4
LT		 740
741/* Carrier loss detection, dial on demand. The functions netif_carrier_on
742 * and _off may be called from IRQ context, but it is caller
743 * who is responsible for serialization of these calls.
b00055aa
SR		 744 *
745 * The name carrier is inappropriate, these functions should really be
746 * called netif_lowerlayer_*() because they represent the state of any
747 * kind of lower layer not just hardware media.
1da177e4
LT		 748 */
749
750extern void linkwatch_fire_event(struct net_device *dev);
751
752static inline int netif_carrier_ok(const struct net_device *dev)
753{
754 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
755}
756
757extern void __netdev_watchdog_up(struct net_device *dev);
758
0a242efc 759extern void netif_carrier_on(struct net_device *dev);
1da177e4 760
0a242efc 761extern void netif_carrier_off(struct net_device *dev);
1da177e4 762
b00055aa
SR		 763static inline void netif_dormant_on(struct net_device *dev)
764{
765 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
766 linkwatch_fire_event(dev);
767}
768
769static inline void netif_dormant_off(struct net_device *dev)
770{
771 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
772 linkwatch_fire_event(dev);
773}
774
775static inline int netif_dormant(const struct net_device *dev)
776{
777 return test_bit(__LINK_STATE_DORMANT, &dev->state);
778}
779
780
781static inline int netif_oper_up(const struct net_device *dev) {
782 return (dev->operstate == IF_OPER_UP ||
783 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
784}
785
1da177e4
LT		 786/* Hot-plugging. */
787static inline int netif_device_present(struct net_device *dev)
788{
789 return test_bit(__LINK_STATE_PRESENT, &dev->state);
790}
791
56079431 792extern void netif_device_detach(struct net_device *dev);
1da177e4 793
56079431 794extern void netif_device_attach(struct net_device *dev);
1da177e4
LT		 795
796/*
797 * Network interface message level settings
798 */
799#define HAVE_NETIF_MSG 1
800
801enum {
802 NETIF_MSG_DRV = 0x0001,
803 NETIF_MSG_PROBE = 0x0002,
804 NETIF_MSG_LINK = 0x0004,
805 NETIF_MSG_TIMER = 0x0008,
806 NETIF_MSG_IFDOWN = 0x0010,
807 NETIF_MSG_IFUP = 0x0020,
808 NETIF_MSG_RX_ERR = 0x0040,
809 NETIF_MSG_TX_ERR = 0x0080,
810 NETIF_MSG_TX_QUEUED = 0x0100,
811 NETIF_MSG_INTR = 0x0200,
812 NETIF_MSG_TX_DONE = 0x0400,
813 NETIF_MSG_RX_STATUS = 0x0800,
814 NETIF_MSG_PKTDATA = 0x1000,
815 NETIF_MSG_HW = 0x2000,
816 NETIF_MSG_WOL = 0x4000,
817};
818
819#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
820#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
821#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
822#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
823#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
824#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
825#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
826#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
827#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
828#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
829#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
830#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
831#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
832#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
833#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
834
835static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
836{
837 /* use default */
838 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
839 return default_msg_enable_bits;
840 if (debug_value == 0) /* no output */
841 return 0;
842 /* set low N bits */
843 return (1 << debug_value) - 1;
844}
845
0a122576
SH		 846/* Test if receive needs to be scheduled */
847static inline int __netif_rx_schedule_prep(struct net_device *dev)
793b883e
SH		 848{
849 return !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
850}
1da177e4 851
0a122576 852/* Test if receive needs to be scheduled but only if up */
1da177e4
LT		 853static inline int netif_rx_schedule_prep(struct net_device *dev)
854{
0a122576 855 return netif_running(dev) && __netif_rx_schedule_prep(dev);
1da177e4
LT		 856}
857
858/* Add interface to tail of rx poll list. This assumes that _prep has
859 * already been called and returned 1.
860 */
861
56079431 862extern void __netif_rx_schedule(struct net_device *dev);
1da177e4
LT		 863
864/* Try to reschedule poll. Called by irq handler. */
865
866static inline void netif_rx_schedule(struct net_device *dev)
867{
868 if (netif_rx_schedule_prep(dev))
869 __netif_rx_schedule(dev);
870}
871
d3240312
SH		 872/* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().
873 * Do not inline this?
874 */
1da177e4
LT		 875static inline int netif_rx_reschedule(struct net_device *dev, int undo)
876{
877 if (netif_rx_schedule_prep(dev)) {
878 unsigned long flags;
d3240312
SH		 879
880 dev->quota += undo;
881
1da177e4 882 local_irq_save(flags);
d3240312
SH		 883 list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
884 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
1da177e4
LT		 885 local_irq_restore(flags);
886 return 1;
887 }
888 return 0;
889}
890
891/* Remove interface from poll list: it must be in the poll list
892 * on current cpu. This primitive is called by dev->poll(), when
893 * it completes the work. The device cannot be out of poll list at this
894 * moment, it is BUG().
895 */
896static inline void netif_rx_complete(struct net_device *dev)
897{
898 unsigned long flags;
899
900 local_irq_save(flags);
901 BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
902 list_del(&dev->poll_list);
903 smp_mb__before_clear_bit();
904 clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
905 local_irq_restore(flags);
906}
907
908static inline void netif_poll_disable(struct net_device *dev)
909{
3173c890 910 while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state))
1da177e4 911 /* No hurry. */
3173c890 912 schedule_timeout_interruptible(1);
1da177e4
LT		 913}
914
915static inline void netif_poll_enable(struct net_device *dev)
916{
e44c39bd 917 smp_mb__before_clear_bit();
1da177e4
LT		 918 clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
919}
920
921/* same as netif_rx_complete, except that local_irq_save(flags)
922 * has already been issued
923 */
924static inline void __netif_rx_complete(struct net_device *dev)
925{
926 BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
927 list_del(&dev->poll_list);
928 smp_mb__before_clear_bit();
929 clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
930}
931
932ff279
HX		 932static inline void netif_tx_lock(struct net_device *dev)
933{
934 spin_lock(&dev->_xmit_lock);
935 dev->xmit_lock_owner = smp_processor_id();
936}
937
938static inline void netif_tx_lock_bh(struct net_device *dev)
939{
940 spin_lock_bh(&dev->_xmit_lock);
941 dev->xmit_lock_owner = smp_processor_id();
942}
943
944static inline int netif_tx_trylock(struct net_device *dev)
945{
53c4b2cc
HX		 946 int ok = spin_trylock(&dev->_xmit_lock);
947 if (likely(ok))
932ff279 948 dev->xmit_lock_owner = smp_processor_id();
53c4b2cc 949 return ok;
932ff279
HX		 950}
951
952static inline void netif_tx_unlock(struct net_device *dev)
953{
954 dev->xmit_lock_owner = -1;
955 spin_unlock(&dev->_xmit_lock);
956}
957
958static inline void netif_tx_unlock_bh(struct net_device *dev)
959{
960 dev->xmit_lock_owner = -1;
961 spin_unlock_bh(&dev->_xmit_lock);
962}
963
1da177e4
LT		 964static inline void netif_tx_disable(struct net_device *dev)
965{
932ff279 966 netif_tx_lock_bh(dev);
1da177e4 967 netif_stop_queue(dev);
932ff279 968 netif_tx_unlock_bh(dev);
1da177e4
LT		 969}
970
971/* These functions live elsewhere (drivers/net/net_init.c, but related) */
972
973extern void ether_setup(struct net_device *dev);
974
975/* Support for loadable net-drivers */
976extern struct net_device *alloc_netdev(int sizeof_priv, const char *name,
977 void (*setup)(struct net_device *));
978extern int register_netdev(struct net_device *dev);
979extern void unregister_netdev(struct net_device *dev);
980/* Functions used for multicast support */
981extern void dev_mc_upload(struct net_device *dev);
982extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
983extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
984extern void dev_mc_discard(struct net_device *dev);
985extern void dev_set_promiscuity(struct net_device *dev, int inc);
986extern void dev_set_allmulti(struct net_device *dev, int inc);
987extern void netdev_state_change(struct net_device *dev);
d8a33ac4 988extern void netdev_features_change(struct net_device *dev);
1da177e4
LT		 989/* Load a device via the kmod */
990extern void dev_load(const char *name);
991extern void dev_mcast_init(void);
992extern int netdev_max_backlog;
993extern int weight_p;
994extern int netdev_set_master(struct net_device *dev, struct net_device *master);
84fa7933 995extern int skb_checksum_help(struct sk_buff *skb);
576a30eb 996extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
fb286bb2
HX		 997#ifdef CONFIG_BUG
998extern void netdev_rx_csum_fault(struct net_device *dev);
999#else
1000static inline void netdev_rx_csum_fault(struct net_device *dev)
1001{
1002}
1003#endif
1da177e4
LT		 1004/* rx skb timestamps */
1005extern void net_enable_timestamp(void);
1006extern void net_disable_timestamp(void);
1007
20380731
ACM		 1008#ifdef CONFIG_PROC_FS
1009extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
1010extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
1011extern void dev_seq_stop(struct seq_file *seq, void *v);
1012#endif
1013
1014extern void linkwatch_run_queue(void);
1015
bcd76111 1016static inline int net_gso_ok(int features, int gso_type)
576a30eb 1017{
bcd76111 1018 int feature = gso_type << NETIF_F_GSO_SHIFT;
d6b4991a 1019 return (features & feature) == feature;
576a30eb
HX		 1020}
1021
bcd76111
HX		 1022static inline int skb_gso_ok(struct sk_buff *skb, int features)
1023{
a430a43d 1024 return net_gso_ok(features, skb_shinfo(skb)->gso_type);
bcd76111
HX		 1025}
1026
7967168c
HX		 1027static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
1028{
a430a43d
HX		 1029 return skb_is_gso(skb) &&
1030 (!skb_gso_ok(skb, dev->features) ||
84fa7933 1031 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
7967168c
HX		 1032}
1033
7ea49ed7 1034/* On bonding slaves other than the currently active slave, suppress
f5b2b966
JV		 1035 * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
1036 * ARP on active-backup slaves with arp_validate enabled.
7ea49ed7
DM		 1037 */
1038static inline int skb_bond_should_drop(struct sk_buff *skb)
1039{
1040 struct net_device *dev = skb->dev;
1041 struct net_device *master = dev->master;
1042
1043 if (master &&
1044 (dev->priv_flags & IFF_SLAVE_INACTIVE)) {
f5b2b966
JV		 1045 if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
1046 skb->protocol == __constant_htons(ETH_P_ARP))
1047 return 0;
1048
7ea49ed7
DM		 1049 if (master->priv_flags & IFF_MASTER_ALB) {
1050 if (skb->pkt_type != PACKET_BROADCAST &&
1051 skb->pkt_type != PACKET_MULTICAST)
1052 return 0;
1053 }
1054 if (master->priv_flags & IFF_MASTER_8023AD &&
1055 skb->protocol == __constant_htons(ETH_P_SLOW))
1056 return 0;
1057
1058 return 1;
1059 }
1060 return 0;
1061}
1062
1da177e4
LT		 1063#endif /* __KERNEL__ */
1064
1065#endif /* _LINUX_DEV_H */
Clone of davem's net-next-2.6 tree