?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include/linux/netdevice.h: Add netif_printk helpers
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / include / linux / netdevice.h
blob1412dde16d0095741ca2c44347ff673d374f6327
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 *
10 * Authors: Ross Biro
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@lxorguk.ukuu.org.uk>
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__
33 #include <linux/timer.h>
34 #include <linux/delay.h>
35 #include <linux/mm.h>
36 #include <asm/atomic.h>
37 #include <asm/cache.h>
38 #include <asm/byteorder.h>
39
40 #include <linux/device.h>
41 #include <linux/percpu.h>
42 #include <linux/rculist.h>
43 #include <linux/dmaengine.h>
44 #include <linux/workqueue.h>
45
46 #include <linux/ethtool.h>
47 #include <net/net_namespace.h>
48 #include <net/dsa.h>
49 #ifdef CONFIG_DCB
50 #include <net/dcbnl.h>
51 #endif
52
53 struct vlan_group;
54 struct netpoll_info;
55 /* 802.11 specific */
56 struct wireless_dev;
57 /* 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 /* Backlog congestion levels */
67 #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
68 #define NET_RX_DROP 1 /* packet dropped */
69
70 /*
71 * Transmit return codes: transmit return codes originate from three different
72 * namespaces:
73 *
74 * - qdisc return codes
75 * - driver transmit return codes
76 * - errno values
77 *
78 * Drivers are allowed to return any one of those in their hard_start_xmit()
79 * function. Real network devices commonly used with qdiscs should only return
80 * the driver transmit return codes though - when qdiscs are used, the actual
81 * transmission happens asynchronously, so the value is not propagated to
82 * higher layers. Virtual network devices transmit synchronously, in this case
83 * the driver transmit return codes are consumed by dev_queue_xmit(), all
84 * others are propagated to higher layers.
85 */
86
87 /* qdisc ->enqueue() return codes. */
88 #define NET_XMIT_SUCCESS 0x00
89 #define NET_XMIT_DROP 0x01 /* skb dropped */
90 #define NET_XMIT_CN 0x02 /* congestion notification */
91 #define NET_XMIT_POLICED 0x03 /* skb is shot by police */
92 #define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
93
94 /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
95 * indicates that the device will soon be dropping packets, or already drops
96 * some packets of the same priority; prompting us to send less aggressively. */
97 #define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
98 #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
99
100 /* Driver transmit return codes */
101 #define NETDEV_TX_MASK 0xf0
102
103 enum netdev_tx {
104 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
105 NETDEV_TX_OK = 0x00, /* driver took care of packet */
106 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
107 NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */
108 };
109 typedef enum netdev_tx netdev_tx_t;
110
111 /*
112 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
113 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
114 */
115 static inline bool dev_xmit_complete(int rc)
116 {
117 /*
118 * Positive cases with an skb consumed by a driver:
119 * - successful transmission (rc == NETDEV_TX_OK)
120 * - error while transmitting (rc < 0)
121 * - error while queueing to a different device (rc & NET_XMIT_MASK)
122 */
123 if (likely(rc < NET_XMIT_MASK))
124 return true;
125
126 return false;
127 }
128
129 #endif
130
131 #define MAX_ADDR_LEN 32 /* Largest hardware address length */
132
133 #ifdef __KERNEL__
134 /*
135 * Compute the worst case header length according to the protocols
136 * used.
137 */
138
139 #if defined(CONFIG_WLAN_80211) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
140 # if defined(CONFIG_MAC80211_MESH)
141 # define LL_MAX_HEADER 128
142 # else
143 # define LL_MAX_HEADER 96
144 # endif
145 #elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
146 # define LL_MAX_HEADER 48
147 #else
148 # define LL_MAX_HEADER 32
149 #endif
150
151 #if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
152 !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
153 !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
154 !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
155 #define MAX_HEADER LL_MAX_HEADER
156 #else
157 #define MAX_HEADER (LL_MAX_HEADER + 48)
158 #endif
159
160 #endif /* __KERNEL__ */
161
162 /*
163 * Network device statistics. Akin to the 2.0 ether stats but
164 * with byte counters.
165 */
166
167 struct net_device_stats {
168 unsigned long rx_packets; /* total packets received */
169 unsigned long tx_packets; /* total packets transmitted */
170 unsigned long rx_bytes; /* total bytes received */
171 unsigned long tx_bytes; /* total bytes transmitted */
172 unsigned long rx_errors; /* bad packets received */
173 unsigned long tx_errors; /* packet transmit problems */
174 unsigned long rx_dropped; /* no space in linux buffers */
175 unsigned long tx_dropped; /* no space available in linux */
176 unsigned long multicast; /* multicast packets received */
177 unsigned long collisions;
178
179 /* detailed rx_errors: */
180 unsigned long rx_length_errors;
181 unsigned long rx_over_errors; /* receiver ring buff overflow */
182 unsigned long rx_crc_errors; /* recved pkt with crc error */
183 unsigned long rx_frame_errors; /* recv'd frame alignment error */
184 unsigned long rx_fifo_errors; /* recv'r fifo overrun */
185 unsigned long rx_missed_errors; /* receiver missed packet */
186
187 /* detailed tx_errors */
188 unsigned long tx_aborted_errors;
189 unsigned long tx_carrier_errors;
190 unsigned long tx_fifo_errors;
191 unsigned long tx_heartbeat_errors;
192 unsigned long tx_window_errors;
193
194 /* for cslip etc */
195 unsigned long rx_compressed;
196 unsigned long tx_compressed;
197 };
198
199
200 /* Media selection options. */
201 enum {
202 IF_PORT_UNKNOWN = 0,
203 IF_PORT_10BASE2,
204 IF_PORT_10BASET,
205 IF_PORT_AUI,
206 IF_PORT_100BASET,
207 IF_PORT_100BASETX,
208 IF_PORT_100BASEFX
209 };
210
211 #ifdef __KERNEL__
212
213 #include <linux/cache.h>
214 #include <linux/skbuff.h>
215
216 struct neighbour;
217 struct neigh_parms;
218 struct sk_buff;
219
220 struct netif_rx_stats {
221 unsigned total;
222 unsigned dropped;
223 unsigned time_squeeze;
224 unsigned cpu_collision;
225 };
226
227 DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
228
229 struct dev_addr_list {
230 struct dev_addr_list *next;
231 u8 da_addr[MAX_ADDR_LEN];
232 u8 da_addrlen;
233 u8 da_synced;
234 int da_users;
235 int da_gusers;
236 };
237
238 /*
239 * We tag multicasts with these structures.
240 */
241
242 #define dev_mc_list dev_addr_list
243 #define dmi_addr da_addr
244 #define dmi_addrlen da_addrlen
245 #define dmi_users da_users
246 #define dmi_gusers da_gusers
247
248 struct netdev_hw_addr {
249 struct list_head list;
250 unsigned char addr[MAX_ADDR_LEN];
251 unsigned char type;
252 #define NETDEV_HW_ADDR_T_LAN 1
253 #define NETDEV_HW_ADDR_T_SAN 2
254 #define NETDEV_HW_ADDR_T_SLAVE 3
255 #define NETDEV_HW_ADDR_T_UNICAST 4
256 int refcount;
257 bool synced;
258 struct rcu_head rcu_head;
259 };
260
261 struct netdev_hw_addr_list {
262 struct list_head list;
263 int count;
264 };
265
266 #define netdev_uc_count(dev) ((dev)->uc.count)
267 #define netdev_uc_empty(dev) ((dev)->uc.count == 0)
268 #define netdev_for_each_uc_addr(ha, dev) \
269 list_for_each_entry(ha, &dev->uc.list, list)
270
271 #define netdev_mc_count(dev) ((dev)->mc_count)
272 #define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0)
273
274 #define netdev_for_each_mc_addr(mclist, dev) \
275 for (mclist = dev->mc_list; mclist; mclist = mclist->next)
276
277 struct hh_cache {
278 struct hh_cache *hh_next; /* Next entry */
279 atomic_t hh_refcnt; /* number of users */
280 /*
281 * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
282 * cache line on SMP.
283 * They are mostly read, but hh_refcnt may be changed quite frequently,
284 * incurring cache line ping pongs.
285 */
286 __be16 hh_type ____cacheline_aligned_in_smp;
287 /* protocol identifier, f.e ETH_P_IP
288 * NOTE: For VLANs, this will be the
289 * encapuslated type. --BLG
290 */
291 u16 hh_len; /* length of header */
292 int (*hh_output)(struct sk_buff *skb);
293 seqlock_t hh_lock;
294
295 /* cached hardware header; allow for machine alignment needs. */
296 #define HH_DATA_MOD 16
297 #define HH_DATA_OFF(__len) \
298 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
299 #define HH_DATA_ALIGN(__len) \
300 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
301 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
302 };
303
304 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
305 * Alternative is:
306 * dev->hard_header_len ? (dev->hard_header_len +
307 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
308 *
309 * We could use other alignment values, but we must maintain the
310 * relationship HH alignment <= LL alignment.
311 *
312 * LL_ALLOCATED_SPACE also takes into account the tailroom the device
313 * may need.
314 */
315 #define LL_RESERVED_SPACE(dev) \
316 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
317 #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
318 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
319 #define LL_ALLOCATED_SPACE(dev) \
320 ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
321
322 struct header_ops {
323 int (*create) (struct sk_buff *skb, struct net_device *dev,
324 unsigned short type, const void *daddr,
325 const void *saddr, unsigned len);
326 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
327 int (*rebuild)(struct sk_buff *skb);
328 #define HAVE_HEADER_CACHE
329 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
330 void (*cache_update)(struct hh_cache *hh,
331 const struct net_device *dev,
332 const unsigned char *haddr);
333 };
334
335 /* These flag bits are private to the generic network queueing
336 * layer, they may not be explicitly referenced by any other
337 * code.
338 */
339
340 enum netdev_state_t {
341 __LINK_STATE_START,
342 __LINK_STATE_PRESENT,
343 __LINK_STATE_NOCARRIER,
344 __LINK_STATE_LINKWATCH_PENDING,
345 __LINK_STATE_DORMANT,
346 };
347
348
349 /*
350 * This structure holds at boot time configured netdevice settings. They
351 * are then used in the device probing.
352 */
353 struct netdev_boot_setup {
354 char name[IFNAMSIZ];
355 struct ifmap map;
356 };
357 #define NETDEV_BOOT_SETUP_MAX 8
358
359 extern int __init netdev_boot_setup(char *str);
360
361 /*
362 * Structure for NAPI scheduling similar to tasklet but with weighting
363 */
364 struct napi_struct {
365 /* The poll_list must only be managed by the entity which
366 * changes the state of the NAPI_STATE_SCHED bit. This means
367 * whoever atomically sets that bit can add this napi_struct
368 * to the per-cpu poll_list, and whoever clears that bit
369 * can remove from the list right before clearing the bit.
370 */
371 struct list_head poll_list;
372
373 unsigned long state;
374 int weight;
375 int (*poll)(struct napi_struct *, int);
376 #ifdef CONFIG_NETPOLL
377 spinlock_t poll_lock;
378 int poll_owner;
379 #endif
380
381 unsigned int gro_count;
382
383 struct net_device *dev;
384 struct list_head dev_list;
385 struct sk_buff *gro_list;
386 struct sk_buff *skb;
387 };
388
389 enum {
390 NAPI_STATE_SCHED, /* Poll is scheduled */
391 NAPI_STATE_DISABLE, /* Disable pending */
392 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
393 };
394
395 enum gro_result {
396 GRO_MERGED,
397 GRO_MERGED_FREE,
398 GRO_HELD,
399 GRO_NORMAL,
400 GRO_DROP,
401 };
402 typedef enum gro_result gro_result_t;
403
404 extern void __napi_schedule(struct napi_struct *n);
405
406 static inline int napi_disable_pending(struct napi_struct *n)
407 {
408 return test_bit(NAPI_STATE_DISABLE, &n->state);
409 }
410
411 /**
412 * napi_schedule_prep - check if napi can be scheduled
413 * @n: napi context
414 *
415 * Test if NAPI routine is already running, and if not mark
416 * it as running. This is used as a condition variable
417 * insure only one NAPI poll instance runs. We also make
418 * sure there is no pending NAPI disable.
419 */
420 static inline int napi_schedule_prep(struct napi_struct *n)
421 {
422 return !napi_disable_pending(n) &&
423 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
424 }
425
426 /**
427 * napi_schedule - schedule NAPI poll
428 * @n: napi context
429 *
430 * Schedule NAPI poll routine to be called if it is not already
431 * running.
432 */
433 static inline void napi_schedule(struct napi_struct *n)
434 {
435 if (napi_schedule_prep(n))
436 __napi_schedule(n);
437 }
438
439 /* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
440 static inline int napi_reschedule(struct napi_struct *napi)
441 {
442 if (napi_schedule_prep(napi)) {
443 __napi_schedule(napi);
444 return 1;
445 }
446 return 0;
447 }
448
449 /**
450 * napi_complete - NAPI processing complete
451 * @n: napi context
452 *
453 * Mark NAPI processing as complete.
454 */
455 extern void __napi_complete(struct napi_struct *n);
456 extern void napi_complete(struct napi_struct *n);
457
458 /**
459 * napi_disable - prevent NAPI from scheduling
460 * @n: napi context
461 *
462 * Stop NAPI from being scheduled on this context.
463 * Waits till any outstanding processing completes.
464 */
465 static inline void napi_disable(struct napi_struct *n)
466 {
467 set_bit(NAPI_STATE_DISABLE, &n->state);
468 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
469 msleep(1);
470 clear_bit(NAPI_STATE_DISABLE, &n->state);
471 }
472
473 /**
474 * napi_enable - enable NAPI scheduling
475 * @n: napi context
476 *
477 * Resume NAPI from being scheduled on this context.
478 * Must be paired with napi_disable.
479 */
480 static inline void napi_enable(struct napi_struct *n)
481 {
482 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
483 smp_mb__before_clear_bit();
484 clear_bit(NAPI_STATE_SCHED, &n->state);
485 }
486
487 #ifdef CONFIG_SMP
488 /**
489 * napi_synchronize - wait until NAPI is not running
490 * @n: napi context
491 *
492 * Wait until NAPI is done being scheduled on this context.
493 * Waits till any outstanding processing completes but
494 * does not disable future activations.
495 */
496 static inline void napi_synchronize(const struct napi_struct *n)
497 {
498 while (test_bit(NAPI_STATE_SCHED, &n->state))
499 msleep(1);
500 }
501 #else
502 # define napi_synchronize(n) barrier()
503 #endif
504
505 enum netdev_queue_state_t {
506 __QUEUE_STATE_XOFF,
507 __QUEUE_STATE_FROZEN,
508 };
509
510 struct netdev_queue {
511 /*
512 * read mostly part
513 */
514 struct net_device *dev;
515 struct Qdisc *qdisc;
516 unsigned long state;
517 struct Qdisc *qdisc_sleeping;
518 /*
519 * write mostly part
520 */
521 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
522 int xmit_lock_owner;
523 /*
524 * please use this field instead of dev->trans_start
525 */
526 unsigned long trans_start;
527 unsigned long tx_bytes;
528 unsigned long tx_packets;
529 unsigned long tx_dropped;
530 } ____cacheline_aligned_in_smp;
531
532
533 /*
534 * This structure defines the management hooks for network devices.
535 * The following hooks can be defined; unless noted otherwise, they are
536 * optional and can be filled with a null pointer.
537 *
538 * int (*ndo_init)(struct net_device *dev);
539 * This function is called once when network device is registered.
540 * The network device can use this to any late stage initializaton
541 * or semantic validattion. It can fail with an error code which will
542 * be propogated back to register_netdev
543 *
544 * void (*ndo_uninit)(struct net_device *dev);
545 * This function is called when device is unregistered or when registration
546 * fails. It is not called if init fails.
547 *
548 * int (*ndo_open)(struct net_device *dev);
549 * This function is called when network device transistions to the up
550 * state.
551 *
552 * int (*ndo_stop)(struct net_device *dev);
553 * This function is called when network device transistions to the down
554 * state.
555 *
556 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
557 * struct net_device *dev);
558 * Called when a packet needs to be transmitted.
559 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
560 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
561 * Required can not be NULL.
562 *
563 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
564 * Called to decide which queue to when device supports multiple
565 * transmit queues.
566 *
567 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
568 * This function is called to allow device receiver to make
569 * changes to configuration when multicast or promiscious is enabled.
570 *
571 * void (*ndo_set_rx_mode)(struct net_device *dev);
572 * This function is called device changes address list filtering.
573 *
574 * void (*ndo_set_multicast_list)(struct net_device *dev);
575 * This function is called when the multicast address list changes.
576 *
577 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
578 * This function is called when the Media Access Control address
579 * needs to be changed. If this interface is not defined, the
580 * mac address can not be changed.
581 *
582 * int (*ndo_validate_addr)(struct net_device *dev);
583 * Test if Media Access Control address is valid for the device.
584 *
585 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
586 * Called when a user request an ioctl which can't be handled by
587 * the generic interface code. If not defined ioctl's return
588 * not supported error code.
589 *
590 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
591 * Used to set network devices bus interface parameters. This interface
592 * is retained for legacy reason, new devices should use the bus
593 * interface (PCI) for low level management.
594 *
595 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
596 * Called when a user wants to change the Maximum Transfer Unit
597 * of a device. If not defined, any request to change MTU will
598 * will return an error.
599 *
600 * void (*ndo_tx_timeout)(struct net_device *dev);
601 * Callback uses when the transmitter has not made any progress
602 * for dev->watchdog ticks.
603 *
604 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
605 * Called when a user wants to get the network device usage
606 * statistics. If not defined, the counters in dev->stats will
607 * be used.
608 *
609 * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
610 * If device support VLAN receive accleration
611 * (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
612 * when vlan groups for the device changes. Note: grp is NULL
613 * if no vlan's groups are being used.
614 *
615 * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
616 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
617 * this function is called when a VLAN id is registered.
618 *
619 * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
620 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
621 * this function is called when a VLAN id is unregistered.
622 *
623 * void (*ndo_poll_controller)(struct net_device *dev);
624 */
625 #define HAVE_NET_DEVICE_OPS
626 struct net_device_ops {
627 int (*ndo_init)(struct net_device *dev);
628 void (*ndo_uninit)(struct net_device *dev);
629 int (*ndo_open)(struct net_device *dev);
630 int (*ndo_stop)(struct net_device *dev);
631 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,
632 struct net_device *dev);
633 u16 (*ndo_select_queue)(struct net_device *dev,
634 struct sk_buff *skb);
635 void (*ndo_change_rx_flags)(struct net_device *dev,
636 int flags);
637 void (*ndo_set_rx_mode)(struct net_device *dev);
638 void (*ndo_set_multicast_list)(struct net_device *dev);
639 int (*ndo_set_mac_address)(struct net_device *dev,
640 void *addr);
641 int (*ndo_validate_addr)(struct net_device *dev);
642 int (*ndo_do_ioctl)(struct net_device *dev,
643 struct ifreq *ifr, int cmd);
644 int (*ndo_set_config)(struct net_device *dev,
645 struct ifmap *map);
646 int (*ndo_change_mtu)(struct net_device *dev,
647 int new_mtu);
648 int (*ndo_neigh_setup)(struct net_device *dev,
649 struct neigh_parms *);
650 void (*ndo_tx_timeout) (struct net_device *dev);
651
652 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
653
654 void (*ndo_vlan_rx_register)(struct net_device *dev,
655 struct vlan_group *grp);
656 void (*ndo_vlan_rx_add_vid)(struct net_device *dev,
657 unsigned short vid);
658 void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
659 unsigned short vid);
660 #ifdef CONFIG_NET_POLL_CONTROLLER
661 void (*ndo_poll_controller)(struct net_device *dev);
662 #endif
663 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
664 int (*ndo_fcoe_enable)(struct net_device *dev);
665 int (*ndo_fcoe_disable)(struct net_device *dev);
666 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
667 u16 xid,
668 struct scatterlist *sgl,
669 unsigned int sgc);
670 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
671 u16 xid);
672 #define NETDEV_FCOE_WWNN 0
673 #define NETDEV_FCOE_WWPN 1
674 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
675 u64 *wwn, int type);
676 #endif
677 };
678
679 /*
680 * The DEVICE structure.
681 * Actually, this whole structure is a big mistake. It mixes I/O
682 * data with strictly "high-level" data, and it has to know about
683 * almost every data structure used in the INET module.
684 *
685 * FIXME: cleanup struct net_device such that network protocol info
686 * moves out.
687 */
688
689 struct net_device {
690
691 /*
692 * This is the first field of the "visible" part of this structure
693 * (i.e. as seen by users in the "Space.c" file). It is the name
694 * the interface.
695 */
696 char name[IFNAMSIZ];
697 /* device name hash chain */
698 struct hlist_node name_hlist;
699 /* snmp alias */
700 char *ifalias;
701
702 /*
703 * I/O specific fields
704 * FIXME: Merge these and struct ifmap into one
705 */
706 unsigned long mem_end; /* shared mem end */
707 unsigned long mem_start; /* shared mem start */
708 unsigned long base_addr; /* device I/O address */
709 unsigned int irq; /* device IRQ number */
710
711 /*
712 * Some hardware also needs these fields, but they are not
713 * part of the usual set specified in Space.c.
714 */
715
716 unsigned char if_port; /* Selectable AUI, TP,..*/
717 unsigned char dma; /* DMA channel */
718
719 unsigned long state;
720
721 struct list_head dev_list;
722 struct list_head napi_list;
723 struct list_head unreg_list;
724
725 /* Net device features */
726 unsigned long features;
727 #define NETIF_F_SG 1 /* Scatter/gather IO. */
728 #define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */
729 #define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
730 #define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
731 #define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */
732 #define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
733 #define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
734 #define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
735 #define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
736 #define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
737 #define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
738 #define NETIF_F_GSO 2048 /* Enable software GSO. */
739 #define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */
740 /* do not use LLTX in new drivers */
741 #define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */
742 #define NETIF_F_GRO 16384 /* Generic receive offload */
743 #define NETIF_F_LRO 32768 /* large receive offload */
744
745 /* the GSO_MASK reserves bits 16 through 23 */
746 #define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */
747 #define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */
748 #define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
749 #define NETIF_F_NTUPLE (1 << 27) /* N-tuple filters supported */
750
751 /* Segmentation offload features */
752 #define NETIF_F_GSO_SHIFT 16
753 #define NETIF_F_GSO_MASK 0x00ff0000
754 #define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
755 #define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
756 #define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
757 #define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
758 #define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
759 #define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
760
761 /* List of features with software fallbacks. */
762 #define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)
763
764
765 #define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
766 #define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
767 #define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
768 #define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
769
770 /*
771 * If one device supports one of these features, then enable them
772 * for all in netdev_increment_features.
773 */
774 #define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
775 NETIF_F_SG | NETIF_F_HIGHDMA | \
776 NETIF_F_FRAGLIST)
777
778 /* Interface index. Unique device identifier */
779 int ifindex;
780 int iflink;
781
782 struct net_device_stats stats;
783
784 #ifdef CONFIG_WIRELESS_EXT
785 /* List of functions to handle Wireless Extensions (instead of ioctl).
786 * See <net/iw_handler.h> for details. Jean II */
787 const struct iw_handler_def * wireless_handlers;
788 /* Instance data managed by the core of Wireless Extensions. */
789 struct iw_public_data * wireless_data;
790 #endif
791 /* Management operations */
792 const struct net_device_ops *netdev_ops;
793 const struct ethtool_ops *ethtool_ops;
794
795 /* Hardware header description */
796 const struct header_ops *header_ops;
797
798 unsigned int flags; /* interface flags (a la BSD) */
799 unsigned short gflags;
800 unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */
801 unsigned short padded; /* How much padding added by alloc_netdev() */
802
803 unsigned char operstate; /* RFC2863 operstate */
804 unsigned char link_mode; /* mapping policy to operstate */
805
806 unsigned mtu; /* interface MTU value */
807 unsigned short type; /* interface hardware type */
808 unsigned short hard_header_len; /* hardware hdr length */
809
810 /* extra head- and tailroom the hardware may need, but not in all cases
811 * can this be guaranteed, especially tailroom. Some cases also use
812 * LL_MAX_HEADER instead to allocate the skb.
813 */
814 unsigned short needed_headroom;
815 unsigned short needed_tailroom;
816
817 struct net_device *master; /* Pointer to master device of a group,
818 * which this device is member of.
819 */
820
821 /* Interface address info. */
822 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
823 unsigned char addr_len; /* hardware address length */
824 unsigned short dev_id; /* for shared network cards */
825
826 struct netdev_hw_addr_list uc; /* Secondary unicast
827 mac addresses */
828 int uc_promisc;
829 spinlock_t addr_list_lock;
830 struct dev_addr_list *mc_list; /* Multicast mac addresses */
831 int mc_count; /* Number of installed mcasts */
832 unsigned int promiscuity;
833 unsigned int allmulti;
834
835
836 /* Protocol specific pointers */
837
838 #ifdef CONFIG_NET_DSA
839 void *dsa_ptr; /* dsa specific data */
840 #endif
841 void *atalk_ptr; /* AppleTalk link */
842 void *ip_ptr; /* IPv4 specific data */
843 void *dn_ptr; /* DECnet specific data */
844 void *ip6_ptr; /* IPv6 specific data */
845 void *ec_ptr; /* Econet specific data */
846 void *ax25_ptr; /* AX.25 specific data */
847 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
848 assign before registering */
849
850 /*
851 * Cache line mostly used on receive path (including eth_type_trans())
852 */
853 unsigned long last_rx; /* Time of last Rx */
854 /* Interface address info used in eth_type_trans() */
855 unsigned char *dev_addr; /* hw address, (before bcast
856 because most packets are
857 unicast) */
858
859 struct netdev_hw_addr_list dev_addrs; /* list of device
860 hw addresses */
861
862 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
863
864 struct netdev_queue rx_queue;
865
866 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
867
868 /* Number of TX queues allocated at alloc_netdev_mq() time */
869 unsigned int num_tx_queues;
870
871 /* Number of TX queues currently active in device */
872 unsigned int real_num_tx_queues;
873
874 /* root qdisc from userspace point of view */
875 struct Qdisc *qdisc;
876
877 unsigned long tx_queue_len; /* Max frames per queue allowed */
878 spinlock_t tx_global_lock;
879 /*
880 * One part is mostly used on xmit path (device)
881 */
882 /* These may be needed for future network-power-down code. */
883
884 /*
885 * trans_start here is expensive for high speed devices on SMP,
886 * please use netdev_queue->trans_start instead.
887 */
888 unsigned long trans_start; /* Time (in jiffies) of last Tx */
889
890 int watchdog_timeo; /* used by dev_watchdog() */
891 struct timer_list watchdog_timer;
892
893 /* Number of references to this device */
894 atomic_t refcnt ____cacheline_aligned_in_smp;
895
896 /* delayed register/unregister */
897 struct list_head todo_list;
898 /* device index hash chain */
899 struct hlist_node index_hlist;
900
901 struct list_head link_watch_list;
902
903 /* register/unregister state machine */
904 enum { NETREG_UNINITIALIZED=0,
905 NETREG_REGISTERED, /* completed register_netdevice */
906 NETREG_UNREGISTERING, /* called unregister_netdevice */
907 NETREG_UNREGISTERED, /* completed unregister todo */
908 NETREG_RELEASED, /* called free_netdev */
909 NETREG_DUMMY, /* dummy device for NAPI poll */
910 } reg_state;
911
912 /* Called from unregister, can be used to call free_netdev */
913 void (*destructor)(struct net_device *dev);
914
915 #ifdef CONFIG_NETPOLL
916 struct netpoll_info *npinfo;
917 #endif
918
919 #ifdef CONFIG_NET_NS
920 /* Network namespace this network device is inside */
921 struct net *nd_net;
922 #endif
923
924 /* mid-layer private */
925 void *ml_priv;
926
927 /* bridge stuff */
928 struct net_bridge_port *br_port;
929 /* macvlan */
930 struct macvlan_port *macvlan_port;
931 /* GARP */
932 struct garp_port *garp_port;
933
934 /* class/net/name entry */
935 struct device dev;
936 /* space for optional device, statistics, and wireless sysfs groups */
937 const struct attribute_group *sysfs_groups[4];
938
939 /* rtnetlink link ops */
940 const struct rtnl_link_ops *rtnl_link_ops;
941
942 /* VLAN feature mask */
943 unsigned long vlan_features;
944
945 /* for setting kernel sock attribute on TCP connection setup */
946 #define GSO_MAX_SIZE 65536
947 unsigned int gso_max_size;
948
949 #ifdef CONFIG_DCB
950 /* Data Center Bridging netlink ops */
951 const struct dcbnl_rtnl_ops *dcbnl_ops;
952 #endif
953
954 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
955 /* max exchange id for FCoE LRO by ddp */
956 unsigned int fcoe_ddp_xid;
957 #endif
958 /* n-tuple filter list attached to this device */
959 struct ethtool_rx_ntuple_list ethtool_ntuple_list;
960 };
961 #define to_net_dev(d) container_of(d, struct net_device, dev)
962
963 #define NETDEV_ALIGN 32
964
965 static inline
966 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
967 unsigned int index)
968 {
969 return &dev->_tx[index];
970 }
971
972 static inline void netdev_for_each_tx_queue(struct net_device *dev,
973 void (*f)(struct net_device *,
974 struct netdev_queue *,
975 void *),
976 void *arg)
977 {
978 unsigned int i;
979
980 for (i = 0; i < dev->num_tx_queues; i++)
981 f(dev, &dev->_tx[i], arg);
982 }
983
984 /*
985 * Net namespace inlines
986 */
987 static inline
988 struct net *dev_net(const struct net_device *dev)
989 {
990 #ifdef CONFIG_NET_NS
991 return dev->nd_net;
992 #else
993 return &init_net;
994 #endif
995 }
996
997 static inline
998 void dev_net_set(struct net_device *dev, struct net *net)
999 {
1000 #ifdef CONFIG_NET_NS
1001 release_net(dev->nd_net);
1002 dev->nd_net = hold_net(net);
1003 #endif
1004 }
1005
1006 static inline bool netdev_uses_dsa_tags(struct net_device *dev)
1007 {
1008 #ifdef CONFIG_NET_DSA_TAG_DSA
1009 if (dev->dsa_ptr != NULL)
1010 return dsa_uses_dsa_tags(dev->dsa_ptr);
1011 #endif
1012
1013 return 0;
1014 }
1015
1016 #ifndef CONFIG_NET_NS
1017 static inline void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
1018 {
1019 skb->dev = dev;
1020 }
1021 #else /* CONFIG_NET_NS */
1022 void skb_set_dev(struct sk_buff *skb, struct net_device *dev);
1023 #endif
1024
1025 static inline bool netdev_uses_trailer_tags(struct net_device *dev)
1026 {
1027 #ifdef CONFIG_NET_DSA_TAG_TRAILER
1028 if (dev->dsa_ptr != NULL)
1029 return dsa_uses_trailer_tags(dev->dsa_ptr);
1030 #endif
1031
1032 return 0;
1033 }
1034
1035 /**
1036 * netdev_priv - access network device private data
1037 * @dev: network device
1038 *
1039 * Get network device private data
1040 */
1041 static inline void *netdev_priv(const struct net_device *dev)
1042 {
1043 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
1044 }
1045
1046 /* Set the sysfs physical device reference for the network logical device
1047 * if set prior to registration will cause a symlink during initialization.
1048 */
1049 #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
1050
1051 /* Set the sysfs device type for the network logical device to allow
1052 * fin grained indentification of different network device types. For
1053 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
1054 */
1055 #define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
1056
1057 /**
1058 * netif_napi_add - initialize a napi context
1059 * @dev: network device
1060 * @napi: napi context
1061 * @poll: polling function
1062 * @weight: default weight
1063 *
1064 * netif_napi_add() must be used to initialize a napi context prior to calling
1065 * *any* of the other napi related functions.
1066 */
1067 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
1068 int (*poll)(struct napi_struct *, int), int weight);
1069
1070 /**
1071 * netif_napi_del - remove a napi context
1072 * @napi: napi context
1073 *
1074 * netif_napi_del() removes a napi context from the network device napi list
1075 */
1076 void netif_napi_del(struct napi_struct *napi);
1077
1078 struct napi_gro_cb {
1079 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
1080 void *frag0;
1081
1082 /* Length of frag0. */
1083 unsigned int frag0_len;
1084
1085 /* This indicates where we are processing relative to skb->data. */
1086 int data_offset;
1087
1088 /* This is non-zero if the packet may be of the same flow. */
1089 int same_flow;
1090
1091 /* This is non-zero if the packet cannot be merged with the new skb. */
1092 int flush;
1093
1094 /* Number of segments aggregated. */
1095 int count;
1096
1097 /* Free the skb? */
1098 int free;
1099 };
1100
1101 #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
1102
1103 struct packet_type {
1104 __be16 type; /* This is really htons(ether_type). */
1105 struct net_device *dev; /* NULL is wildcarded here */
1106 int (*func) (struct sk_buff *,
1107 struct net_device *,
1108 struct packet_type *,
1109 struct net_device *);
1110 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
1111 int features);
1112 int (*gso_send_check)(struct sk_buff *skb);
1113 struct sk_buff **(*gro_receive)(struct sk_buff **head,
1114 struct sk_buff *skb);
1115 int (*gro_complete)(struct sk_buff *skb);
1116 void *af_packet_priv;
1117 struct list_head list;
1118 };
1119
1120 #include <linux/interrupt.h>
1121 #include <linux/notifier.h>
1122
1123 extern rwlock_t dev_base_lock; /* Device list lock */
1124
1125
1126 #define for_each_netdev(net, d) \
1127 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
1128 #define for_each_netdev_reverse(net, d) \
1129 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
1130 #define for_each_netdev_rcu(net, d) \
1131 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
1132 #define for_each_netdev_safe(net, d, n) \
1133 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
1134 #define for_each_netdev_continue(net, d) \
1135 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
1136 #define for_each_netdev_continue_rcu(net, d) \
1137 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
1138 #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
1139
1140 static inline struct net_device *next_net_device(struct net_device *dev)
1141 {
1142 struct list_head *lh;
1143 struct net *net;
1144
1145 net = dev_net(dev);
1146 lh = dev->dev_list.next;
1147 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1148 }
1149
1150 static inline struct net_device *next_net_device_rcu(struct net_device *dev)
1151 {
1152 struct list_head *lh;
1153 struct net *net;
1154
1155 net = dev_net(dev);
1156 lh = rcu_dereference(dev->dev_list.next);
1157 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1158 }
1159
1160 static inline struct net_device *first_net_device(struct net *net)
1161 {
1162 return list_empty(&net->dev_base_head) ? NULL :
1163 net_device_entry(net->dev_base_head.next);
1164 }
1165
1166 extern int netdev_boot_setup_check(struct net_device *dev);
1167 extern unsigned long netdev_boot_base(const char *prefix, int unit);
1168 extern struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);
1169 extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
1170 extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
1171 extern void dev_add_pack(struct packet_type *pt);
1172 extern void dev_remove_pack(struct packet_type *pt);
1173 extern void __dev_remove_pack(struct packet_type *pt);
1174
1175 extern struct net_device *dev_get_by_flags(struct net *net, unsigned short flags,
1176 unsigned short mask);
1177 extern struct net_device *dev_get_by_name(struct net *net, const char *name);
1178 extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
1179 extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
1180 extern int dev_alloc_name(struct net_device *dev, const char *name);
1181 extern int dev_open(struct net_device *dev);
1182 extern int dev_close(struct net_device *dev);
1183 extern void dev_disable_lro(struct net_device *dev);
1184 extern int dev_queue_xmit(struct sk_buff *skb);
1185 extern int register_netdevice(struct net_device *dev);
1186 extern void unregister_netdevice_queue(struct net_device *dev,
1187 struct list_head *head);
1188 extern void unregister_netdevice_many(struct list_head *head);
1189 static inline void unregister_netdevice(struct net_device *dev)
1190 {
1191 unregister_netdevice_queue(dev, NULL);
1192 }
1193
1194 extern void free_netdev(struct net_device *dev);
1195 extern void synchronize_net(void);
1196 extern int register_netdevice_notifier(struct notifier_block *nb);
1197 extern int unregister_netdevice_notifier(struct notifier_block *nb);
1198 extern int init_dummy_netdev(struct net_device *dev);
1199 extern void netdev_resync_ops(struct net_device *dev);
1200
1201 extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
1202 extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
1203 extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
1204 extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
1205 extern int dev_restart(struct net_device *dev);
1206 #ifdef CONFIG_NETPOLL_TRAP
1207 extern int netpoll_trap(void);
1208 #endif
1209 extern int skb_gro_receive(struct sk_buff **head,
1210 struct sk_buff *skb);
1211 extern void skb_gro_reset_offset(struct sk_buff *skb);
1212
1213 static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
1214 {
1215 return NAPI_GRO_CB(skb)->data_offset;
1216 }
1217
1218 static inline unsigned int skb_gro_len(const struct sk_buff *skb)
1219 {
1220 return skb->len - NAPI_GRO_CB(skb)->data_offset;
1221 }
1222
1223 static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
1224 {
1225 NAPI_GRO_CB(skb)->data_offset += len;
1226 }
1227
1228 static inline void *skb_gro_header_fast(struct sk_buff *skb,
1229 unsigned int offset)
1230 {
1231 return NAPI_GRO_CB(skb)->frag0 + offset;
1232 }
1233
1234 static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
1235 {
1236 return NAPI_GRO_CB(skb)->frag0_len < hlen;
1237 }
1238
1239 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
1240 unsigned int offset)
1241 {
1242 NAPI_GRO_CB(skb)->frag0 = NULL;
1243 NAPI_GRO_CB(skb)->frag0_len = 0;
1244 return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
1245 }
1246
1247 static inline void *skb_gro_mac_header(struct sk_buff *skb)
1248 {
1249 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
1250 }
1251
1252 static inline void *skb_gro_network_header(struct sk_buff *skb)
1253 {
1254 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
1255 skb_network_offset(skb);
1256 }
1257
1258 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
1259 unsigned short type,
1260 const void *daddr, const void *saddr,
1261 unsigned len)
1262 {
1263 if (!dev->header_ops || !dev->header_ops->create)
1264 return 0;
1265
1266 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
1267 }
1268
1269 static inline int dev_parse_header(const struct sk_buff *skb,
1270 unsigned char *haddr)
1271 {
1272 const struct net_device *dev = skb->dev;
1273
1274 if (!dev->header_ops || !dev->header_ops->parse)
1275 return 0;
1276 return dev->header_ops->parse(skb, haddr);
1277 }
1278
1279 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
1280 extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
1281 static inline int unregister_gifconf(unsigned int family)
1282 {
1283 return register_gifconf(family, NULL);
1284 }
1285
1286 /*
1287 * Incoming packets are placed on per-cpu queues so that
1288 * no locking is needed.
1289 */
1290 struct softnet_data {
1291 struct Qdisc *output_queue;
1292 struct sk_buff_head input_pkt_queue;
1293 struct list_head poll_list;
1294 struct sk_buff *completion_queue;
1295
1296 struct napi_struct backlog;
1297 };
1298
1299 DECLARE_PER_CPU(struct softnet_data,softnet_data);
1300
1301 #define HAVE_NETIF_QUEUE
1302
1303 extern void __netif_schedule(struct Qdisc *q);
1304
1305 static inline void netif_schedule_queue(struct netdev_queue *txq)
1306 {
1307 if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
1308 __netif_schedule(txq->qdisc);
1309 }
1310
1311 static inline void netif_tx_schedule_all(struct net_device *dev)
1312 {
1313 unsigned int i;
1314
1315 for (i = 0; i < dev->num_tx_queues; i++)
1316 netif_schedule_queue(netdev_get_tx_queue(dev, i));
1317 }
1318
1319 static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
1320 {
1321 clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1322 }
1323
1324 /**
1325 * netif_start_queue - allow transmit
1326 * @dev: network device
1327 *
1328 * Allow upper layers to call the device hard_start_xmit routine.
1329 */
1330 static inline void netif_start_queue(struct net_device *dev)
1331 {
1332 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
1333 }
1334
1335 static inline void netif_tx_start_all_queues(struct net_device *dev)
1336 {
1337 unsigned int i;
1338
1339 for (i = 0; i < dev->num_tx_queues; i++) {
1340 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1341 netif_tx_start_queue(txq);
1342 }
1343 }
1344
1345 static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
1346 {
1347 #ifdef CONFIG_NETPOLL_TRAP
1348 if (netpoll_trap()) {
1349 netif_tx_start_queue(dev_queue);
1350 return;
1351 }
1352 #endif
1353 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
1354 __netif_schedule(dev_queue->qdisc);
1355 }
1356
1357 /**
1358 * netif_wake_queue - restart transmit
1359 * @dev: network device
1360 *
1361 * Allow upper layers to call the device hard_start_xmit routine.
1362 * Used for flow control when transmit resources are available.
1363 */
1364 static inline void netif_wake_queue(struct net_device *dev)
1365 {
1366 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
1367 }
1368
1369 static inline void netif_tx_wake_all_queues(struct net_device *dev)
1370 {
1371 unsigned int i;
1372
1373 for (i = 0; i < dev->num_tx_queues; i++) {
1374 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1375 netif_tx_wake_queue(txq);
1376 }
1377 }
1378
1379 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
1380 {
1381 set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1382 }
1383
1384 /**
1385 * netif_stop_queue - stop transmitted packets
1386 * @dev: network device
1387 *
1388 * Stop upper layers calling the device hard_start_xmit routine.
1389 * Used for flow control when transmit resources are unavailable.
1390 */
1391 static inline void netif_stop_queue(struct net_device *dev)
1392 {
1393 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
1394 }
1395
1396 static inline void netif_tx_stop_all_queues(struct net_device *dev)
1397 {
1398 unsigned int i;
1399
1400 for (i = 0; i < dev->num_tx_queues; i++) {
1401 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1402 netif_tx_stop_queue(txq);
1403 }
1404 }
1405
1406 static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
1407 {
1408 return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1409 }
1410
1411 /**
1412 * netif_queue_stopped - test if transmit queue is flowblocked
1413 * @dev: network device
1414 *
1415 * Test if transmit queue on device is currently unable to send.
1416 */
1417 static inline int netif_queue_stopped(const struct net_device *dev)
1418 {
1419 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
1420 }
1421
1422 static inline int netif_tx_queue_frozen(const struct netdev_queue *dev_queue)
1423 {
1424 return test_bit(__QUEUE_STATE_FROZEN, &dev_queue->state);
1425 }
1426
1427 /**
1428 * netif_running - test if up
1429 * @dev: network device
1430 *
1431 * Test if the device has been brought up.
1432 */
1433 static inline int netif_running(const struct net_device *dev)
1434 {
1435 return test_bit(__LINK_STATE_START, &dev->state);
1436 }
1437
1438 /*
1439 * Routines to manage the subqueues on a device. We only need start
1440 * stop, and a check if it's stopped. All other device management is
1441 * done at the overall netdevice level.
1442 * Also test the device if we're multiqueue.
1443 */
1444
1445 /**
1446 * netif_start_subqueue - allow sending packets on subqueue
1447 * @dev: network device
1448 * @queue_index: sub queue index
1449 *
1450 * Start individual transmit queue of a device with multiple transmit queues.
1451 */
1452 static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
1453 {
1454 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
1455
1456 netif_tx_start_queue(txq);
1457 }
1458
1459 /**
1460 * netif_stop_subqueue - stop sending packets on subqueue
1461 * @dev: network device
1462 * @queue_index: sub queue index
1463 *
1464 * Stop individual transmit queue of a device with multiple transmit queues.
1465 */
1466 static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
1467 {
1468 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
1469 #ifdef CONFIG_NETPOLL_TRAP
1470 if (netpoll_trap())
1471 return;
1472 #endif
1473 netif_tx_stop_queue(txq);
1474 }
1475
1476 /**
1477 * netif_subqueue_stopped - test status of subqueue
1478 * @dev: network device
1479 * @queue_index: sub queue index
1480 *
1481 * Check individual transmit queue of a device with multiple transmit queues.
1482 */
1483 static inline int __netif_subqueue_stopped(const struct net_device *dev,
1484 u16 queue_index)
1485 {
1486 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
1487
1488 return netif_tx_queue_stopped(txq);
1489 }
1490
1491 static inline int netif_subqueue_stopped(const struct net_device *dev,
1492 struct sk_buff *skb)
1493 {
1494 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
1495 }
1496
1497 /**
1498 * netif_wake_subqueue - allow sending packets on subqueue
1499 * @dev: network device
1500 * @queue_index: sub queue index
1501 *
1502 * Resume individual transmit queue of a device with multiple transmit queues.
1503 */
1504 static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
1505 {
1506 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
1507 #ifdef CONFIG_NETPOLL_TRAP
1508 if (netpoll_trap())
1509 return;
1510 #endif
1511 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
1512 __netif_schedule(txq->qdisc);
1513 }
1514
1515 /**
1516 * netif_is_multiqueue - test if device has multiple transmit queues
1517 * @dev: network device
1518 *
1519 * Check if device has multiple transmit queues
1520 */
1521 static inline int netif_is_multiqueue(const struct net_device *dev)
1522 {
1523 return (dev->num_tx_queues > 1);
1524 }
1525
1526 /* Use this variant when it is known for sure that it
1527 * is executing from hardware interrupt context or with hardware interrupts
1528 * disabled.
1529 */
1530 extern void dev_kfree_skb_irq(struct sk_buff *skb);
1531
1532 /* Use this variant in places where it could be invoked
1533 * from either hardware interrupt or other context, with hardware interrupts
1534 * either disabled or enabled.
1535 */
1536 extern void dev_kfree_skb_any(struct sk_buff *skb);
1537
1538 #define HAVE_NETIF_RX 1
1539 extern int netif_rx(struct sk_buff *skb);
1540 extern int netif_rx_ni(struct sk_buff *skb);
1541 #define HAVE_NETIF_RECEIVE_SKB 1
1542 extern int netif_receive_skb(struct sk_buff *skb);
1543 extern gro_result_t dev_gro_receive(struct napi_struct *napi,
1544 struct sk_buff *skb);
1545 extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb);
1546 extern gro_result_t napi_gro_receive(struct napi_struct *napi,
1547 struct sk_buff *skb);
1548 extern void napi_reuse_skb(struct napi_struct *napi,
1549 struct sk_buff *skb);
1550 extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
1551 extern gro_result_t napi_frags_finish(struct napi_struct *napi,
1552 struct sk_buff *skb,
1553 gro_result_t ret);
1554 extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
1555 extern gro_result_t napi_gro_frags(struct napi_struct *napi);
1556
1557 static inline void napi_free_frags(struct napi_struct *napi)
1558 {
1559 kfree_skb(napi->skb);
1560 napi->skb = NULL;
1561 }
1562
1563 extern void netif_nit_deliver(struct sk_buff *skb);
1564 extern int dev_valid_name(const char *name);
1565 extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
1566 extern int dev_ethtool(struct net *net, struct ifreq *);
1567 extern unsigned dev_get_flags(const struct net_device *);
1568 extern int dev_change_flags(struct net_device *, unsigned);
1569 extern int dev_change_name(struct net_device *, const char *);
1570 extern int dev_set_alias(struct net_device *, const char *, size_t);
1571 extern int dev_change_net_namespace(struct net_device *,
1572 struct net *, const char *);
1573 extern int dev_set_mtu(struct net_device *, int);
1574 extern int dev_set_mac_address(struct net_device *,
1575 struct sockaddr *);
1576 extern int dev_hard_start_xmit(struct sk_buff *skb,
1577 struct net_device *dev,
1578 struct netdev_queue *txq);
1579 extern int dev_forward_skb(struct net_device *dev,
1580 struct sk_buff *skb);
1581
1582 extern int netdev_budget;
1583
1584 /* Called by rtnetlink.c:rtnl_unlock() */
1585 extern void netdev_run_todo(void);
1586
1587 /**
1588 * dev_put - release reference to device
1589 * @dev: network device
1590 *
1591 * Release reference to device to allow it to be freed.
1592 */
1593 static inline void dev_put(struct net_device *dev)
1594 {
1595 atomic_dec(&dev->refcnt);
1596 }
1597
1598 /**
1599 * dev_hold - get reference to device
1600 * @dev: network device
1601 *
1602 * Hold reference to device to keep it from being freed.
1603 */
1604 static inline void dev_hold(struct net_device *dev)
1605 {
1606 atomic_inc(&dev->refcnt);
1607 }
1608
1609 /* Carrier loss detection, dial on demand. The functions netif_carrier_on
1610 * and _off may be called from IRQ context, but it is caller
1611 * who is responsible for serialization of these calls.
1612 *
1613 * The name carrier is inappropriate, these functions should really be
1614 * called netif_lowerlayer_*() because they represent the state of any
1615 * kind of lower layer not just hardware media.
1616 */
1617
1618 extern void linkwatch_fire_event(struct net_device *dev);
1619 extern void linkwatch_forget_dev(struct net_device *dev);
1620
1621 /**
1622 * netif_carrier_ok - test if carrier present
1623 * @dev: network device
1624 *
1625 * Check if carrier is present on device
1626 */
1627 static inline int netif_carrier_ok(const struct net_device *dev)
1628 {
1629 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
1630 }
1631
1632 extern unsigned long dev_trans_start(struct net_device *dev);
1633
1634 extern void __netdev_watchdog_up(struct net_device *dev);
1635
1636 extern void netif_carrier_on(struct net_device *dev);
1637
1638 extern void netif_carrier_off(struct net_device *dev);
1639
1640 /**
1641 * netif_dormant_on - mark device as dormant.
1642 * @dev: network device
1643 *
1644 * Mark device as dormant (as per RFC2863).
1645 *
1646 * The dormant state indicates that the relevant interface is not
1647 * actually in a condition to pass packets (i.e., it is not 'up') but is
1648 * in a "pending" state, waiting for some external event. For "on-
1649 * demand" interfaces, this new state identifies the situation where the
1650 * interface is waiting for events to place it in the up state.
1651 *
1652 */
1653 static inline void netif_dormant_on(struct net_device *dev)
1654 {
1655 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
1656 linkwatch_fire_event(dev);
1657 }
1658
1659 /**
1660 * netif_dormant_off - set device as not dormant.
1661 * @dev: network device
1662 *
1663 * Device is not in dormant state.
1664 */
1665 static inline void netif_dormant_off(struct net_device *dev)
1666 {
1667 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
1668 linkwatch_fire_event(dev);
1669 }
1670
1671 /**
1672 * netif_dormant - test if carrier present
1673 * @dev: network device
1674 *
1675 * Check if carrier is present on device
1676 */
1677 static inline int netif_dormant(const struct net_device *dev)
1678 {
1679 return test_bit(__LINK_STATE_DORMANT, &dev->state);
1680 }
1681
1682
1683 /**
1684 * netif_oper_up - test if device is operational
1685 * @dev: network device
1686 *
1687 * Check if carrier is operational
1688 */
1689 static inline int netif_oper_up(const struct net_device *dev)
1690 {
1691 return (dev->operstate == IF_OPER_UP ||
1692 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
1693 }
1694
1695 /**
1696 * netif_device_present - is device available or removed
1697 * @dev: network device
1698 *
1699 * Check if device has not been removed from system.
1700 */
1701 static inline int netif_device_present(struct net_device *dev)
1702 {
1703 return test_bit(__LINK_STATE_PRESENT, &dev->state);
1704 }
1705
1706 extern void netif_device_detach(struct net_device *dev);
1707
1708 extern void netif_device_attach(struct net_device *dev);
1709
1710 /*
1711 * Network interface message level settings
1712 */
1713 #define HAVE_NETIF_MSG 1
1714
1715 enum {
1716 NETIF_MSG_DRV = 0x0001,
1717 NETIF_MSG_PROBE = 0x0002,
1718 NETIF_MSG_LINK = 0x0004,
1719 NETIF_MSG_TIMER = 0x0008,
1720 NETIF_MSG_IFDOWN = 0x0010,
1721 NETIF_MSG_IFUP = 0x0020,
1722 NETIF_MSG_RX_ERR = 0x0040,
1723 NETIF_MSG_TX_ERR = 0x0080,
1724 NETIF_MSG_TX_QUEUED = 0x0100,
1725 NETIF_MSG_INTR = 0x0200,
1726 NETIF_MSG_TX_DONE = 0x0400,
1727 NETIF_MSG_RX_STATUS = 0x0800,
1728 NETIF_MSG_PKTDATA = 0x1000,
1729 NETIF_MSG_HW = 0x2000,
1730 NETIF_MSG_WOL = 0x4000,
1731 };
1732
1733 #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
1734 #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
1735 #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
1736 #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
1737 #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
1738 #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
1739 #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
1740 #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
1741 #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
1742 #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
1743 #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
1744 #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
1745 #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
1746 #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
1747 #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
1748
1749 static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
1750 {
1751 /* use default */
1752 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
1753 return default_msg_enable_bits;
1754 if (debug_value == 0) /* no output */
1755 return 0;
1756 /* set low N bits */
1757 return (1 << debug_value) - 1;
1758 }
1759
1760 static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
1761 {
1762 spin_lock(&txq->_xmit_lock);
1763 txq->xmit_lock_owner = cpu;
1764 }
1765
1766 static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
1767 {
1768 spin_lock_bh(&txq->_xmit_lock);
1769 txq->xmit_lock_owner = smp_processor_id();
1770 }
1771
1772 static inline int __netif_tx_trylock(struct netdev_queue *txq)
1773 {
1774 int ok = spin_trylock(&txq->_xmit_lock);
1775 if (likely(ok))
1776 txq->xmit_lock_owner = smp_processor_id();
1777 return ok;
1778 }
1779
1780 static inline void __netif_tx_unlock(struct netdev_queue *txq)
1781 {
1782 txq->xmit_lock_owner = -1;
1783 spin_unlock(&txq->_xmit_lock);
1784 }
1785
1786 static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
1787 {
1788 txq->xmit_lock_owner = -1;
1789 spin_unlock_bh(&txq->_xmit_lock);
1790 }
1791
1792 static inline void txq_trans_update(struct netdev_queue *txq)
1793 {
1794 if (txq->xmit_lock_owner != -1)
1795 txq->trans_start = jiffies;
1796 }
1797
1798 /**
1799 * netif_tx_lock - grab network device transmit lock
1800 * @dev: network device
1801 *
1802 * Get network device transmit lock
1803 */
1804 static inline void netif_tx_lock(struct net_device *dev)
1805 {
1806 unsigned int i;
1807 int cpu;
1808
1809 spin_lock(&dev->tx_global_lock);
1810 cpu = smp_processor_id();
1811 for (i = 0; i < dev->num_tx_queues; i++) {
1812 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1813
1814 /* We are the only thread of execution doing a
1815 * freeze, but we have to grab the _xmit_lock in
1816 * order to synchronize with threads which are in
1817 * the ->hard_start_xmit() handler and already
1818 * checked the frozen bit.
1819 */
1820 __netif_tx_lock(txq, cpu);
1821 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
1822 __netif_tx_unlock(txq);
1823 }
1824 }
1825
1826 static inline void netif_tx_lock_bh(struct net_device *dev)
1827 {
1828 local_bh_disable();
1829 netif_tx_lock(dev);
1830 }
1831
1832 static inline void netif_tx_unlock(struct net_device *dev)
1833 {
1834 unsigned int i;
1835
1836 for (i = 0; i < dev->num_tx_queues; i++) {
1837 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1838
1839 /* No need to grab the _xmit_lock here. If the
1840 * queue is not stopped for another reason, we
1841 * force a schedule.
1842 */
1843 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
1844 netif_schedule_queue(txq);
1845 }
1846 spin_unlock(&dev->tx_global_lock);
1847 }
1848
1849 static inline void netif_tx_unlock_bh(struct net_device *dev)
1850 {
1851 netif_tx_unlock(dev);
1852 local_bh_enable();
1853 }
1854
1855 #define HARD_TX_LOCK(dev, txq, cpu) { \
1856 if ((dev->features & NETIF_F_LLTX) == 0) { \
1857 __netif_tx_lock(txq, cpu); \
1858 } \
1859 }
1860
1861 #define HARD_TX_UNLOCK(dev, txq) { \
1862 if ((dev->features & NETIF_F_LLTX) == 0) { \
1863 __netif_tx_unlock(txq); \
1864 } \
1865 }
1866
1867 static inline void netif_tx_disable(struct net_device *dev)
1868 {
1869 unsigned int i;
1870 int cpu;
1871
1872 local_bh_disable();
1873 cpu = smp_processor_id();
1874 for (i = 0; i < dev->num_tx_queues; i++) {
1875 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1876
1877 __netif_tx_lock(txq, cpu);
1878 netif_tx_stop_queue(txq);
1879 __netif_tx_unlock(txq);
1880 }
1881 local_bh_enable();
1882 }
1883
1884 static inline void netif_addr_lock(struct net_device *dev)
1885 {
1886 spin_lock(&dev->addr_list_lock);
1887 }
1888
1889 static inline void netif_addr_lock_bh(struct net_device *dev)
1890 {
1891 spin_lock_bh(&dev->addr_list_lock);
1892 }
1893
1894 static inline void netif_addr_unlock(struct net_device *dev)
1895 {
1896 spin_unlock(&dev->addr_list_lock);
1897 }
1898
1899 static inline void netif_addr_unlock_bh(struct net_device *dev)
1900 {
1901 spin_unlock_bh(&dev->addr_list_lock);
1902 }
1903
1904 /*
1905 * dev_addrs walker. Should be used only for read access. Call with
1906 * rcu_read_lock held.
1907 */
1908 #define for_each_dev_addr(dev, ha) \
1909 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
1910
1911 /* These functions live elsewhere (drivers/net/net_init.c, but related) */
1912
1913 extern void ether_setup(struct net_device *dev);
1914
1915 /* Support for loadable net-drivers */
1916 extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
1917 void (*setup)(struct net_device *),
1918 unsigned int queue_count);
1919 #define alloc_netdev(sizeof_priv, name, setup) \
1920 alloc_netdev_mq(sizeof_priv, name, setup, 1)
1921 extern int register_netdev(struct net_device *dev);
1922 extern void unregister_netdev(struct net_device *dev);
1923
1924 /* Functions used for device addresses handling */
1925 extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
1926 unsigned char addr_type);
1927 extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
1928 unsigned char addr_type);
1929 extern int dev_addr_add_multiple(struct net_device *to_dev,
1930 struct net_device *from_dev,
1931 unsigned char addr_type);
1932 extern int dev_addr_del_multiple(struct net_device *to_dev,
1933 struct net_device *from_dev,
1934 unsigned char addr_type);
1935
1936 /* Functions used for secondary unicast and multicast support */
1937 extern void dev_set_rx_mode(struct net_device *dev);
1938 extern void __dev_set_rx_mode(struct net_device *dev);
1939 extern int dev_unicast_delete(struct net_device *dev, void *addr);
1940 extern int dev_unicast_add(struct net_device *dev, void *addr);
1941 extern int dev_unicast_sync(struct net_device *to, struct net_device *from);
1942 extern void dev_unicast_unsync(struct net_device *to, struct net_device *from);
1943 extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
1944 extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
1945 extern int dev_mc_sync(struct net_device *to, struct net_device *from);
1946 extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
1947 extern int __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);
1948 extern int __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);
1949 extern int __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
1950 extern void __dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
1951 extern int dev_set_promiscuity(struct net_device *dev, int inc);
1952 extern int dev_set_allmulti(struct net_device *dev, int inc);
1953 extern void netdev_state_change(struct net_device *dev);
1954 extern void netdev_bonding_change(struct net_device *dev,
1955 unsigned long event);
1956 extern void netdev_features_change(struct net_device *dev);
1957 /* Load a device via the kmod */
1958 extern void dev_load(struct net *net, const char *name);
1959 extern void dev_mcast_init(void);
1960 extern const struct net_device_stats *dev_get_stats(struct net_device *dev);
1961 extern void dev_txq_stats_fold(const struct net_device *dev, struct net_device_stats *stats);
1962
1963 extern int netdev_max_backlog;
1964 extern int weight_p;
1965 extern int netdev_set_master(struct net_device *dev, struct net_device *master);
1966 extern int skb_checksum_help(struct sk_buff *skb);
1967 extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
1968 #ifdef CONFIG_BUG
1969 extern void netdev_rx_csum_fault(struct net_device *dev);
1970 #else
1971 static inline void netdev_rx_csum_fault(struct net_device *dev)
1972 {
1973 }
1974 #endif
1975 /* rx skb timestamps */
1976 extern void net_enable_timestamp(void);
1977 extern void net_disable_timestamp(void);
1978
1979 #ifdef CONFIG_PROC_FS
1980 extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
1981 extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
1982 extern void dev_seq_stop(struct seq_file *seq, void *v);
1983 #endif
1984
1985 extern int netdev_class_create_file(struct class_attribute *class_attr);
1986 extern void netdev_class_remove_file(struct class_attribute *class_attr);
1987
1988 extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);
1989
1990 extern void linkwatch_run_queue(void);
1991
1992 unsigned long netdev_increment_features(unsigned long all, unsigned long one,
1993 unsigned long mask);
1994 unsigned long netdev_fix_features(unsigned long features, const char *name);
1995
1996 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
1997 struct net_device *dev);
1998
1999 static inline int net_gso_ok(int features, int gso_type)
2000 {
2001 int feature = gso_type << NETIF_F_GSO_SHIFT;
2002 return (features & feature) == feature;
2003 }
2004
2005 static inline int skb_gso_ok(struct sk_buff *skb, int features)
2006 {
2007 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
2008 (!skb_has_frags(skb) || (features & NETIF_F_FRAGLIST));
2009 }
2010
2011 static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
2012 {
2013 return skb_is_gso(skb) &&
2014 (!skb_gso_ok(skb, dev->features) ||
2015 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
2016 }
2017
2018 static inline void netif_set_gso_max_size(struct net_device *dev,
2019 unsigned int size)
2020 {
2021 dev->gso_max_size = size;
2022 }
2023
2024 static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
2025 struct net_device *master)
2026 {
2027 if (skb->pkt_type == PACKET_HOST) {
2028 u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
2029
2030 memcpy(dest, master->dev_addr, ETH_ALEN);
2031 }
2032 }
2033
2034 /* On bonding slaves other than the currently active slave, suppress
2035 * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
2036 * ARP on active-backup slaves with arp_validate enabled.
2037 */
2038 static inline int skb_bond_should_drop(struct sk_buff *skb)
2039 {
2040 struct net_device *dev = skb->dev;
2041 struct net_device *master = dev->master;
2042
2043 if (master) {
2044 if (master->priv_flags & IFF_MASTER_ARPMON)
2045 dev->last_rx = jiffies;
2046
2047 if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {
2048 /* Do address unmangle. The local destination address
2049 * will be always the one master has. Provides the right
2050 * functionality in a bridge.
2051 */
2052 skb_bond_set_mac_by_master(skb, master);
2053 }
2054
2055 if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
2056 if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
2057 skb->protocol == __cpu_to_be16(ETH_P_ARP))
2058 return 0;
2059
2060 if (master->priv_flags & IFF_MASTER_ALB) {
2061 if (skb->pkt_type != PACKET_BROADCAST &&
2062 skb->pkt_type != PACKET_MULTICAST)
2063 return 0;
2064 }
2065 if (master->priv_flags & IFF_MASTER_8023AD &&
2066 skb->protocol == __cpu_to_be16(ETH_P_SLOW))
2067 return 0;
2068
2069 return 1;
2070 }
2071 }
2072 return 0;
2073 }
2074
2075 extern struct pernet_operations __net_initdata loopback_net_ops;
2076
2077 static inline int dev_ethtool_get_settings(struct net_device *dev,
2078 struct ethtool_cmd *cmd)
2079 {
2080 if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
2081 return -EOPNOTSUPP;
2082 return dev->ethtool_ops->get_settings(dev, cmd);
2083 }
2084
2085 static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
2086 {
2087 if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
2088 return 0;
2089 return dev->ethtool_ops->get_rx_csum(dev);
2090 }
2091
2092 static inline u32 dev_ethtool_get_flags(struct net_device *dev)
2093 {
2094 if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
2095 return 0;
2096 return dev->ethtool_ops->get_flags(dev);
2097 }
2098
2099 /* Logging, debugging and troubleshooting/diagnostic helpers. */
2100
2101 /* netdev_printk helpers, similar to dev_printk */
2102
2103 static inline const char *netdev_name(const struct net_device *dev)
2104 {
2105 if (dev->reg_state != NETREG_REGISTERED)
2106 return "(unregistered net_device)";
2107 return dev->name;
2108 }
2109
2110 #define netdev_printk(level, netdev, format, args...) \
2111 dev_printk(level, (netdev)->dev.parent, \
2112 "%s: " format, \
2113 netdev_name(netdev), ##args)
2114
2115 #define netdev_emerg(dev, format, args...) \
2116 netdev_printk(KERN_EMERG, dev, format, ##args)
2117 #define netdev_alert(dev, format, args...) \
2118 netdev_printk(KERN_ALERT, dev, format, ##args)
2119 #define netdev_crit(dev, format, args...) \
2120 netdev_printk(KERN_CRIT, dev, format, ##args)
2121 #define netdev_err(dev, format, args...) \
2122 netdev_printk(KERN_ERR, dev, format, ##args)
2123 #define netdev_warn(dev, format, args...) \
2124 netdev_printk(KERN_WARNING, dev, format, ##args)
2125 #define netdev_notice(dev, format, args...) \
2126 netdev_printk(KERN_NOTICE, dev, format, ##args)
2127 #define netdev_info(dev, format, args...) \
2128 netdev_printk(KERN_INFO, dev, format, ##args)
2129
2130 #if defined(DEBUG)
2131 #define netdev_dbg(__dev, format, args...) \
2132 netdev_printk(KERN_DEBUG, __dev, format, ##args)
2133 #elif defined(CONFIG_DYNAMIC_DEBUG)
2134 #define netdev_dbg(__dev, format, args...) \
2135 do { \
2136 dynamic_dev_dbg((__dev)->dev.parent, "%s: " format, \
2137 netdev_name(__dev), ##args); \
2138 } while (0)
2139 #else
2140 #define netdev_dbg(__dev, format, args...) \
2141 ({ \
2142 if (0) \
2143 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
2144 0; \
2145 })
2146 #endif
2147
2148 #if defined(VERBOSE_DEBUG)
2149 #define netdev_vdbg netdev_dbg
2150 #else
2151
2152 #define netdev_vdbg(dev, format, args...) \
2153 ({ \
2154 if (0) \
2155 netdev_printk(KERN_DEBUG, dev, format, ##args); \
2156 0; \
2157 })
2158 #endif
2159
2160 /*
2161 * netdev_WARN() acts like dev_printk(), but with the key difference
2162 * of using a WARN/WARN_ON to get the message out, including the
2163 * file/line information and a backtrace.
2164 */
2165 #define netdev_WARN(dev, format, args...) \
2166 WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
2167
2168 /* netif printk helpers, similar to netdev_printk */
2169
2170 #define netif_printk(priv, type, level, dev, fmt, args...) \
2171 do { \
2172 if (netif_msg_##type(priv)) \
2173 netdev_printk(level, (dev), fmt, ##args); \
2174 } while (0)
2175
2176 #define netif_emerg(priv, type, dev, fmt, args...) \
2177 netif_printk(priv, type, KERN_EMERG, dev, fmt, ##args)
2178 #define netif_alert(priv, type, dev, fmt, args...) \
2179 netif_printk(priv, type, KERN_ALERT, dev, fmt, ##args)
2180 #define netif_crit(priv, type, dev, fmt, args...) \
2181 netif_printk(priv, type, KERN_CRIT, dev, fmt, ##args)
2182 #define netif_err(priv, type, dev, fmt, args...) \
2183 netif_printk(priv, type, KERN_ERR, dev, fmt, ##args)
2184 #define netif_warn(priv, type, dev, fmt, args...) \
2185 netif_printk(priv, type, KERN_WARNING, dev, fmt, ##args)
2186 #define netif_notice(priv, type, dev, fmt, args...) \
2187 netif_printk(priv, type, KERN_NOTICE, dev, fmt, ##args)
2188 #define netif_info(priv, type, dev, fmt, args...) \
2189 netif_printk(priv, type, KERN_INFO, (dev), fmt, ##args)
2190
2191 #if defined(DEBUG)
2192 #define netif_dbg(priv, type, dev, format, args...) \
2193 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
2194 #elif defined(CONFIG_DYNAMIC_DEBUG)
2195 #define netif_dbg(priv, type, netdev, format, args...) \
2196 do { \
2197 if (netif_msg_##type(priv)) \
2198 dynamic_dev_dbg((netdev)->dev.parent, \
2199 "%s: " format, \
2200 netdev_name(netdev), ##args); \
2201 } while (0)
2202 #else
2203 #define netif_dbg(priv, type, dev, format, args...) \
2204 ({ \
2205 if (0) \
2206 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
2207 0; \
2208 })
2209 #endif
2210
2211 #if defined(VERBOSE_DEBUG)
2212 #define netif_vdbg netdev_dbg
2213 #else
2214 #define netif_vdbg(priv, type, dev, format, args...) \
2215 ({ \
2216 if (0) \
2217 netif_printk(KERN_DEBUG, dev, format, ##args); \
2218 0; \
2219 })
2220 #endif
2221
2222 #endif /* __KERNEL__ */
2223
2224 #endif /* _LINUX_NETDEVICE_H */
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree