~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/netdevice.h

Version: ~ [ linux-5.0-rc6 ] ~ [ linux-4.20.10 ] ~ [ linux-4.19.23 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.101 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.158 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.174 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.134 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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, <bir7@leland.Stanford.Edu>
 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 #include <asm/atomic.h>
 33 #include <asm/cache.h>
 34 #include <asm/byteorder.h>
 35 
 36 #ifdef __KERNEL__
 37 #include <linux/config.h>
 38 #include <linux/device.h>
 39 #include <linux/percpu.h>
 40 
 41 struct divert_blk;
 42 struct vlan_group;
 43 struct ethtool_ops;
 44 
 45                                         /* source back-compat hook */
 46 #define SET_ETHTOOL_OPS(netdev,ops) \
 47         ( (netdev)->ethtool_ops = (ops) )
 48 
 49 #define HAVE_ALLOC_NETDEV               /* feature macro: alloc_xxxdev
 50                                            functions are available. */
 51 #define HAVE_FREE_NETDEV
 52 
 53 #define NET_XMIT_SUCCESS        0
 54 #define NET_XMIT_DROP           1       /* skb dropped                  */
 55 #define NET_XMIT_CN             2       /* congestion notification      */
 56 #define NET_XMIT_POLICED        3       /* skb is shot by police        */
 57 #define NET_XMIT_BYPASS         4       /* packet does not leave via dequeue;
 58                                            (TC use only - dev_queue_xmit
 59                                            returns this as NET_XMIT_SUCCESS) */
 60 
 61 /* Backlog congestion levels */
 62 #define NET_RX_SUCCESS          0   /* keep 'em coming, baby */
 63 #define NET_RX_DROP             1  /* packet dropped */
 64 #define NET_RX_CN_LOW           2   /* storm alert, just in case */
 65 #define NET_RX_CN_MOD           3   /* Storm on its way! */
 66 #define NET_RX_CN_HIGH          4   /* The storm is here */
 67 #define NET_RX_BAD              5  /* packet dropped due to kernel error */
 68 
 69 #define net_xmit_errno(e)       ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
 70 
 71 #endif
 72 
 73 #define MAX_ADDR_LEN    32              /* Largest hardware address length */
 74 
 75 /*
 76  *      Compute the worst case header length according to the protocols
 77  *      used.
 78  */
 79  
 80 #if !defined(CONFIG_AX25) && !defined(CONFIG_AX25_MODULE) && !defined(CONFIG_TR)
 81 #define LL_MAX_HEADER   32
 82 #else
 83 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 84 #define LL_MAX_HEADER   96
 85 #else
 86 #define LL_MAX_HEADER   48
 87 #endif
 88 #endif
 89 
 90 #if !defined(CONFIG_NET_IPIP) && \
 91     !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
 92 #define MAX_HEADER LL_MAX_HEADER
 93 #else
 94 #define MAX_HEADER (LL_MAX_HEADER + 48)
 95 #endif
 96 
 97 /*
 98  *      Network device statistics. Akin to the 2.0 ether stats but
 99  *      with byte counters.
100  */
101  
102 struct net_device_stats
103 {
104         unsigned long   rx_packets;             /* total packets received       */
105         unsigned long   tx_packets;             /* total packets transmitted    */
106         unsigned long   rx_bytes;               /* total bytes received         */
107         unsigned long   tx_bytes;               /* total bytes transmitted      */
108         unsigned long   rx_errors;              /* bad packets received         */
109         unsigned long   tx_errors;              /* packet transmit problems     */
110         unsigned long   rx_dropped;             /* no space in linux buffers    */
111         unsigned long   tx_dropped;             /* no space available in linux  */
112         unsigned long   multicast;              /* multicast packets received   */
113         unsigned long   collisions;
114 
115         /* detailed rx_errors: */
116         unsigned long   rx_length_errors;
117         unsigned long   rx_over_errors;         /* receiver ring buff overflow  */
118         unsigned long   rx_crc_errors;          /* recved pkt with crc error    */
119         unsigned long   rx_frame_errors;        /* recv'd frame alignment error */
120         unsigned long   rx_fifo_errors;         /* recv'r fifo overrun          */
121         unsigned long   rx_missed_errors;       /* receiver missed packet       */
122 
123         /* detailed tx_errors */
124         unsigned long   tx_aborted_errors;
125         unsigned long   tx_carrier_errors;
126         unsigned long   tx_fifo_errors;
127         unsigned long   tx_heartbeat_errors;
128         unsigned long   tx_window_errors;
129         
130         /* for cslip etc */
131         unsigned long   rx_compressed;
132         unsigned long   tx_compressed;
133 };
134 
135 
136 /* Media selection options. */
137 enum {
138         IF_PORT_UNKNOWN = 0,
139         IF_PORT_10BASE2,
140         IF_PORT_10BASET,
141         IF_PORT_AUI,
142         IF_PORT_100BASET,
143         IF_PORT_100BASETX,
144         IF_PORT_100BASEFX
145 };
146 
147 #ifdef __KERNEL__
148 
149 #include <linux/cache.h>
150 #include <linux/skbuff.h>
151 
152 struct neighbour;
153 struct neigh_parms;
154 struct sk_buff;
155 
156 struct netif_rx_stats
157 {
158         unsigned total;
159         unsigned dropped;
160         unsigned time_squeeze;
161         unsigned throttled;
162         unsigned fastroute_hit;
163         unsigned fastroute_success;
164         unsigned fastroute_defer;
165         unsigned fastroute_deferred_out;
166         unsigned fastroute_latency_reduction;
167         unsigned cpu_collision;
168 };
169 
170 DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
171 
172 
173 /*
174  *      We tag multicasts with these structures.
175  */
176  
177 struct dev_mc_list
178 {       
179         struct dev_mc_list      *next;
180         __u8                    dmi_addr[MAX_ADDR_LEN];
181         unsigned char           dmi_addrlen;
182         int                     dmi_users;
183         int                     dmi_gusers;
184 };
185 
186 struct hh_cache
187 {
188         struct hh_cache *hh_next;       /* Next entry                        */
189         atomic_t        hh_refcnt;      /* number of users                   */
190         unsigned short  hh_type;        /* protocol identifier, f.e ETH_P_IP
191                                          *  NOTE:  For VLANs, this will be the
192                                          *  encapuslated type. --BLG
193                                          */
194         int             hh_len;         /* length of header */
195         int             (*hh_output)(struct sk_buff *skb);
196         rwlock_t        hh_lock;
197 
198         /* cached hardware header; allow for machine alignment needs.        */
199 #define HH_DATA_MOD     16
200 #define HH_DATA_OFF(__len) \
201         (HH_DATA_MOD - ((__len) & (HH_DATA_MOD - 1)))
202 #define HH_DATA_ALIGN(__len) \
203         (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
204         unsigned long   hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
205 };
206 
207 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
208  * Alternative is:
209  *   dev->hard_header_len ? (dev->hard_header_len +
210  *                           (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
211  *
212  * We could use other alignment values, but we must maintain the
213  * relationship HH alignment <= LL alignment.
214  */
215 #define LL_RESERVED_SPACE(dev) \
216         (((dev)->hard_header_len&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
217 
218 /* These flag bits are private to the generic network queueing
219  * layer, they may not be explicitly referenced by any other
220  * code.
221  */
222 
223 enum netdev_state_t
224 {
225         __LINK_STATE_XOFF=0,
226         __LINK_STATE_START,
227         __LINK_STATE_PRESENT,
228         __LINK_STATE_SCHED,
229         __LINK_STATE_NOCARRIER,
230         __LINK_STATE_RX_SCHED,
231         __LINK_STATE_LINKWATCH_PENDING
232 };
233 
234 
235 /*
236  * This structure holds at boot time configured netdevice settings. They
237  * are then used in the device probing. 
238  */
239 struct netdev_boot_setup {
240         char name[IFNAMSIZ];
241         struct ifmap map;
242 };
243 #define NETDEV_BOOT_SETUP_MAX 8
244 
245 
246 /*
247  *      The DEVICE structure.
248  *      Actually, this whole structure is a big mistake.  It mixes I/O
249  *      data with strictly "high-level" data, and it has to know about
250  *      almost every data structure used in the INET module.
251  *
252  *      FIXME: cleanup struct net_device such that network protocol info
253  *      moves out.
254  */
255 
256 struct net_device
257 {
258 
259         /*
260          * This is the first field of the "visible" part of this structure
261          * (i.e. as seen by users in the "Space.c" file).  It is the name
262          * the interface.
263          */
264         char                    name[IFNAMSIZ];
265 
266         /*
267          *      I/O specific fields
268          *      FIXME: Merge these and struct ifmap into one
269          */
270         unsigned long           mem_end;        /* shared mem end       */
271         unsigned long           mem_start;      /* shared mem start     */
272         unsigned long           base_addr;      /* device I/O address   */
273         unsigned int            irq;            /* device IRQ number    */
274 
275         /*
276          *      Some hardware also needs these fields, but they are not
277          *      part of the usual set specified in Space.c.
278          */
279 
280         unsigned char           if_port;        /* Selectable AUI, TP,..*/
281         unsigned char           dma;            /* DMA channel          */
282 
283         unsigned long           state;
284 
285         struct net_device       *next;
286         
287         /* The device initialization function. Called only once. */
288         int                     (*init)(struct net_device *dev);
289 
290         /* ------- Fields preinitialized in Space.c finish here ------- */
291 
292         struct net_device       *next_sched;
293 
294         /* Interface index. Unique device identifier    */
295         int                     ifindex;
296         int                     iflink;
297 
298 
299         struct net_device_stats* (*get_stats)(struct net_device *dev);
300         struct iw_statistics*   (*get_wireless_stats)(struct net_device *dev);
301 
302         /* List of functions to handle Wireless Extensions (instead of ioctl).
303          * See <net/iw_handler.h> for details. Jean II */
304         struct iw_handler_def * wireless_handlers;
305 
306         struct ethtool_ops *ethtool_ops;
307 
308         /*
309          * This marks the end of the "visible" part of the structure. All
310          * fields hereafter are internal to the system, and may change at
311          * will (read: may be cleaned up at will).
312          */
313 
314         /* These may be needed for future network-power-down code. */
315         unsigned long           trans_start;    /* Time (in jiffies) of last Tx */
316         unsigned long           last_rx;        /* Time of last Rx      */
317 
318         unsigned short          flags;  /* interface flags (a la BSD)   */
319         unsigned short          gflags;
320         unsigned short          priv_flags; /* Like 'flags' but invisible to userspace. */
321         unsigned short          unused_alignment_fixer; /* Because we need priv_flags,
322                                                          * and we want to be 32-bit aligned.
323                                                          */
324 
325         unsigned                mtu;    /* interface MTU value          */
326         unsigned short          type;   /* interface hardware type      */
327         unsigned short          hard_header_len;        /* hardware hdr length  */
328         void                    *priv;  /* pointer to private data      */
329 
330         struct net_device       *master; /* Pointer to master device of a group,
331                                           * which this device is member of.
332                                           */
333 
334         /* Interface address info. */
335         unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
336         unsigned char           dev_addr[MAX_ADDR_LEN]; /* hw address   */
337         unsigned char           addr_len;       /* hardware address length      */
338 
339         struct dev_mc_list      *mc_list;       /* Multicast mac addresses      */
340         int                     mc_count;       /* Number of installed mcasts   */
341         int                     promiscuity;
342         int                     allmulti;
343 
344         int                     watchdog_timeo;
345         struct timer_list       watchdog_timer;
346 
347         /* Protocol specific pointers */
348         
349         void                    *atalk_ptr;     /* AppleTalk link       */
350         void                    *ip_ptr;        /* IPv4 specific data   */  
351         void                    *dn_ptr;        /* DECnet specific data */
352         void                    *ip6_ptr;       /* IPv6 specific data */
353         void                    *ec_ptr;        /* Econet specific data */
354         void                    *ax25_ptr;      /* AX.25 specific data */
355 
356         struct list_head        poll_list;      /* Link to poll list    */
357         int                     quota;
358         int                     weight;
359 
360         struct Qdisc            *qdisc;
361         struct Qdisc            *qdisc_sleeping;
362         struct Qdisc            *qdisc_list;
363         struct Qdisc            *qdisc_ingress;
364         unsigned long           tx_queue_len;   /* Max frames per queue allowed */
365 
366         /* hard_start_xmit synchronizer */
367         spinlock_t              xmit_lock;
368         /* cpu id of processor entered to hard_start_xmit or -1,
369            if nobody entered there.
370          */
371         int                     xmit_lock_owner;
372         /* device queue lock */
373         spinlock_t              queue_lock;
374         /* Number of references to this device */
375         atomic_t                refcnt;
376         /* delayed register/unregister */
377         struct list_head        todo_list;
378 
379         /* register/unregister state machine */
380         enum { NETREG_UNINITIALIZED=0,
381                NETREG_REGISTERING,      /* called register_netdevice */
382                NETREG_REGISTERED,       /* completed register todo */
383                NETREG_UNREGISTERING,    /* called unregister_netdevice */
384                NETREG_UNREGISTERED,     /* completed unregister todo */
385                NETREG_RELEASED,         /* called free_netdev */
386         } reg_state;
387 
388         /* Net device features */
389         int                     features;
390 #define NETIF_F_SG              1       /* Scatter/gather IO. */
391 #define NETIF_F_IP_CSUM         2       /* Can checksum only TCP/UDP over IPv4. */
392 #define NETIF_F_NO_CSUM         4       /* Does not require checksum. F.e. loopack. */
393 #define NETIF_F_HW_CSUM         8       /* Can checksum all the packets. */
394 #define NETIF_F_HIGHDMA         32      /* Can DMA to high memory. */
395 #define NETIF_F_FRAGLIST        64      /* Scatter/gather IO. */
396 #define NETIF_F_HW_VLAN_TX      128     /* Transmit VLAN hw acceleration */
397 #define NETIF_F_HW_VLAN_RX      256     /* Receive VLAN hw acceleration */
398 #define NETIF_F_HW_VLAN_FILTER  512     /* Receive filtering on VLAN */
399 #define NETIF_F_VLAN_CHALLENGED 1024    /* Device cannot handle VLAN packets */
400 #define NETIF_F_TSO             2048    /* Can offload TCP/IP segmentation */
401 
402         /* Called after device is detached from network. */
403         void                    (*uninit)(struct net_device *dev);
404         /* Called after last user reference disappears. */
405         void                    (*destructor)(struct net_device *dev);
406 
407         /* Pointers to interface service routines.      */
408         int                     (*open)(struct net_device *dev);
409         int                     (*stop)(struct net_device *dev);
410         int                     (*hard_start_xmit) (struct sk_buff *skb,
411                                                     struct net_device *dev);
412 #define HAVE_NETDEV_POLL
413         int                     (*poll) (struct net_device *dev, int *quota);
414         int                     (*hard_header) (struct sk_buff *skb,
415                                                 struct net_device *dev,
416                                                 unsigned short type,
417                                                 void *daddr,
418                                                 void *saddr,
419                                                 unsigned len);
420         int                     (*rebuild_header)(struct sk_buff *skb);
421 #define HAVE_MULTICAST                   
422         void                    (*set_multicast_list)(struct net_device *dev);
423 #define HAVE_SET_MAC_ADDR                
424         int                     (*set_mac_address)(struct net_device *dev,
425                                                    void *addr);
426 #define HAVE_PRIVATE_IOCTL
427         int                     (*do_ioctl)(struct net_device *dev,
428                                             struct ifreq *ifr, int cmd);
429 #define HAVE_SET_CONFIG
430         int                     (*set_config)(struct net_device *dev,
431                                               struct ifmap *map);
432 #define HAVE_HEADER_CACHE
433         int                     (*hard_header_cache)(struct neighbour *neigh,
434                                                      struct hh_cache *hh);
435         void                    (*header_cache_update)(struct hh_cache *hh,
436                                                        struct net_device *dev,
437                                                        unsigned char *  haddr);
438 #define HAVE_CHANGE_MTU
439         int                     (*change_mtu)(struct net_device *dev, int new_mtu);
440 
441 #define HAVE_TX_TIMEOUT
442         void                    (*tx_timeout) (struct net_device *dev);
443 
444         void                    (*vlan_rx_register)(struct net_device *dev,
445                                                     struct vlan_group *grp);
446         void                    (*vlan_rx_add_vid)(struct net_device *dev,
447                                                    unsigned short vid);
448         void                    (*vlan_rx_kill_vid)(struct net_device *dev,
449                                                     unsigned short vid);
450 
451         int                     (*hard_header_parse)(struct sk_buff *skb,
452                                                      unsigned char *haddr);
453         int                     (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
454         int                     (*accept_fastpath)(struct net_device *, struct dst_entry*);
455 
456         /* bridge stuff */
457         struct net_bridge_port  *br_port;
458 
459 #ifdef CONFIG_NET_FASTROUTE
460 #define NETDEV_FASTROUTE_HMASK 0xF
461         /* Semi-private data. Keep it at the end of device struct. */
462         rwlock_t                fastpath_lock;
463         struct dst_entry        *fastpath[NETDEV_FASTROUTE_HMASK+1];
464 #endif
465 #ifdef CONFIG_NET_DIVERT
466         /* this will get initialized at each interface type init routine */
467         struct divert_blk       *divert;
468 #endif /* CONFIG_NET_DIVERT */
469 
470         /* class/net/name entry */
471         struct class_device     class_dev;
472         struct net_device_stats* (*last_stats)(struct net_device *);
473 };
474 
475 #define SET_MODULE_OWNER(dev) do { } while (0)
476 /* Set the sysfs physical device reference for the network logical device
477  * if set prior to registration will cause a symlink during initialization.
478  */
479 #define SET_NETDEV_DEV(net, pdev)       ((net)->class_dev.dev = (pdev))
480 
481 struct packet_type {
482         unsigned short          type;   /* This is really htons(ether_type).    */
483         struct net_device               *dev;   /* NULL is wildcarded here              */
484         int                     (*func) (struct sk_buff *, struct net_device *,
485                                          struct packet_type *);
486         void                    *af_packet_priv;
487         struct list_head        list;
488 };
489 
490 #include <linux/interrupt.h>
491 #include <linux/notifier.h>
492 
493 extern struct net_device                loopback_dev;           /* The loopback */
494 extern struct net_device                *dev_base;              /* All devices */
495 extern rwlock_t                         dev_base_lock;          /* Device list lock */
496 
497 extern int                      netdev_boot_setup_add(char *name, struct ifmap *map);
498 extern int                      netdev_boot_setup_check(struct net_device *dev);
499 extern struct net_device    *dev_getbyhwaddr(unsigned short type, char *hwaddr);
500 extern struct net_device *__dev_getfirstbyhwtype(unsigned short type);
501 extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
502 extern void             dev_add_pack(struct packet_type *pt);
503 extern void             dev_remove_pack(struct packet_type *pt);
504 extern void             __dev_remove_pack(struct packet_type *pt);
505 extern int              __dev_get(const char *name);
506 static inline int __deprecated dev_get(const char *name)
507 {
508         return __dev_get(name);
509 }
510 extern struct net_device        *dev_get_by_flags(unsigned short flags,
511                                                   unsigned short mask);
512 extern struct net_device        *__dev_get_by_flags(unsigned short flags,
513                                                     unsigned short mask);
514 extern struct net_device        *dev_get_by_name(const char *name);
515 extern struct net_device        *__dev_get_by_name(const char *name);
516 extern struct net_device        *__dev_alloc(const char *name, int *err);
517 static inline __deprecated struct net_device *dev_alloc(const char *name, int *err)
518 {
519         return __dev_alloc(name, err);
520 }
521 extern int              dev_alloc_name(struct net_device *dev, const char *name);
522 extern int              dev_open(struct net_device *dev);
523 extern int              dev_close(struct net_device *dev);
524 extern int              dev_queue_xmit(struct sk_buff *skb);
525 extern int              register_netdevice(struct net_device *dev);
526 extern int              unregister_netdevice(struct net_device *dev);
527 extern void             free_netdev(struct net_device *dev);
528 extern void             synchronize_net(void);
529 extern int              register_netdevice_notifier(struct notifier_block *nb);
530 extern int              unregister_netdevice_notifier(struct notifier_block *nb);
531 extern int              call_netdevice_notifiers(unsigned long val, void *v);
532 extern int              dev_new_index(void);
533 extern struct net_device        *dev_get_by_index(int ifindex);
534 extern struct net_device        *__dev_get_by_index(int ifindex);
535 extern int              dev_restart(struct net_device *dev);
536 
537 typedef int gifconf_func_t(struct net_device * dev, char * bufptr, int len);
538 extern int              register_gifconf(unsigned int family, gifconf_func_t * gifconf);
539 static inline int unregister_gifconf(unsigned int family)
540 {
541         return register_gifconf(family, 0);
542 }
543 
544 /*
545  * Incoming packets are placed on per-cpu queues so that
546  * no locking is needed.
547  */
548 
549 struct softnet_data
550 {
551         int                     throttle;
552         int                     cng_level;
553         int                     avg_blog;
554         struct sk_buff_head     input_pkt_queue;
555         struct list_head        poll_list;
556         struct net_device       *output_queue;
557         struct sk_buff          *completion_queue;
558 
559         struct net_device       backlog_dev;    /* Sorry. 8) */
560 };
561 
562 DECLARE_PER_CPU(struct softnet_data,softnet_data);
563 
564 #define HAVE_NETIF_QUEUE
565 
566 static inline void __netif_schedule(struct net_device *dev)
567 {
568         if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
569                 unsigned long flags;
570                 struct softnet_data *sd;
571 
572                 local_irq_save(flags);
573                 sd = &__get_cpu_var(softnet_data);
574                 dev->next_sched = sd->output_queue;
575                 sd->output_queue = dev;
576                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
577                 local_irq_restore(flags);
578         }
579 }
580 
581 static inline void netif_schedule(struct net_device *dev)
582 {
583         if (!test_bit(__LINK_STATE_XOFF, &dev->state))
584                 __netif_schedule(dev);
585 }
586 
587 static inline void netif_start_queue(struct net_device *dev)
588 {
589         clear_bit(__LINK_STATE_XOFF, &dev->state);
590 }
591 
592 static inline void netif_wake_queue(struct net_device *dev)
593 {
594         if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
595                 __netif_schedule(dev);
596 }
597 
598 static inline void netif_stop_queue(struct net_device *dev)
599 {
600         set_bit(__LINK_STATE_XOFF, &dev->state);
601 }
602 
603 static inline int netif_queue_stopped(const struct net_device *dev)
604 {
605         return test_bit(__LINK_STATE_XOFF, &dev->state);
606 }
607 
608 static inline int netif_running(const struct net_device *dev)
609 {
610         return test_bit(__LINK_STATE_START, &dev->state);
611 }
612 
613 
614 /* Use this variant when it is known for sure that it
615  * is executing from interrupt context.
616  */
617 static inline void dev_kfree_skb_irq(struct sk_buff *skb)
618 {
619         if (atomic_dec_and_test(&skb->users)) {
620                 struct softnet_data *sd;
621                 unsigned long flags;
622 
623                 local_irq_save(flags);
624                 sd = &__get_cpu_var(softnet_data);
625                 skb->next = sd->completion_queue;
626                 sd->completion_queue = skb;
627                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
628                 local_irq_restore(flags);
629         }
630 }
631 
632 /* Use this variant in places where it could be invoked
633  * either from interrupt or non-interrupt context.
634  */
635 static inline void dev_kfree_skb_any(struct sk_buff *skb)
636 {
637         if (in_irq())
638                 dev_kfree_skb_irq(skb);
639         else
640                 dev_kfree_skb(skb);
641 }
642 
643 #define HAVE_NETIF_RX 1
644 extern int              netif_rx(struct sk_buff *skb);
645 #define HAVE_NETIF_RECEIVE_SKB 1
646 extern int              netif_receive_skb(struct sk_buff *skb);
647 extern int              dev_ioctl(unsigned int cmd, void *);
648 extern int              dev_ethtool(struct ifreq *);
649 extern unsigned         dev_get_flags(const struct net_device *);
650 extern int              dev_change_flags(struct net_device *, unsigned);
651 extern int              dev_set_mtu(struct net_device *, int);
652 extern void             dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
653 
654 extern void             dev_init(void);
655 
656 extern int              netdev_nit;
657 
658 /* Post buffer to the network code from _non interrupt_ context.
659  * see net/core/dev.c for netif_rx description.
660  */
661 static inline int netif_rx_ni(struct sk_buff *skb)
662 {
663        int err = netif_rx(skb);
664        if (softirq_pending(smp_processor_id()))
665                do_softirq();
666        return err;
667 }
668 
669 /* Called by rtnetlink.c:rtnl_unlock() */
670 extern void netdev_run_todo(void);
671 
672 static inline void dev_put(struct net_device *dev)
673 {
674         atomic_dec(&dev->refcnt);
675 }
676 
677 #define __dev_put(dev) atomic_dec(&(dev)->refcnt)
678 #define dev_hold(dev) atomic_inc(&(dev)->refcnt)
679 
680 /* Carrier loss detection, dial on demand. The functions netif_carrier_on
681  * and _off may be called from IRQ context, but it is caller
682  * who is responsible for serialization of these calls.
683  */
684 
685 extern void linkwatch_fire_event(struct net_device *dev);
686 
687 static inline int netif_carrier_ok(const struct net_device *dev)
688 {
689         return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
690 }
691 
692 extern void __netdev_watchdog_up(struct net_device *dev);
693 
694 static inline void netif_carrier_on(struct net_device *dev)
695 {
696         if (test_and_clear_bit(__LINK_STATE_NOCARRIER, &dev->state))
697                 linkwatch_fire_event(dev);
698         if (netif_running(dev))
699                 __netdev_watchdog_up(dev);
700 }
701 
702 static inline void netif_carrier_off(struct net_device *dev)
703 {
704         if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state))
705                 linkwatch_fire_event(dev);
706 }
707 
708 /* Hot-plugging. */
709 static inline int netif_device_present(struct net_device *dev)
710 {
711         return test_bit(__LINK_STATE_PRESENT, &dev->state);
712 }
713 
714 static inline void netif_device_detach(struct net_device *dev)
715 {
716         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
717             netif_running(dev)) {
718                 netif_stop_queue(dev);
719         }
720 }
721 
722 static inline void netif_device_attach(struct net_device *dev)
723 {
724         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
725             netif_running(dev)) {
726                 netif_wake_queue(dev);
727                 __netdev_watchdog_up(dev);
728         }
729 }
730 
731 /*
732  * Network interface message level settings
733  */
734 #define HAVE_NETIF_MSG 1
735 
736 enum {
737         NETIF_MSG_DRV           = 0x0001,
738         NETIF_MSG_PROBE         = 0x0002,
739         NETIF_MSG_LINK          = 0x0004,
740         NETIF_MSG_TIMER         = 0x0008,
741         NETIF_MSG_IFDOWN        = 0x0010,
742         NETIF_MSG_IFUP          = 0x0020,
743         NETIF_MSG_RX_ERR        = 0x0040,
744         NETIF_MSG_TX_ERR        = 0x0080,
745         NETIF_MSG_TX_QUEUED     = 0x0100,
746         NETIF_MSG_INTR          = 0x0200,
747         NETIF_MSG_TX_DONE       = 0x0400,
748         NETIF_MSG_RX_STATUS     = 0x0800,
749         NETIF_MSG_PKTDATA       = 0x1000,
750         NETIF_MSG_HW            = 0x2000,
751         NETIF_MSG_WOL           = 0x4000,
752 };
753 
754 #define netif_msg_drv(p)        ((p)->msg_enable & NETIF_MSG_DRV)
755 #define netif_msg_probe(p)      ((p)->msg_enable & NETIF_MSG_PROBE)
756 #define netif_msg_link(p)       ((p)->msg_enable & NETIF_MSG_LINK)
757 #define netif_msg_timer(p)      ((p)->msg_enable & NETIF_MSG_TIMER)
758 #define netif_msg_ifdown(p)     ((p)->msg_enable & NETIF_MSG_IFDOWN)
759 #define netif_msg_ifup(p)       ((p)->msg_enable & NETIF_MSG_IFUP)
760 #define netif_msg_rx_err(p)     ((p)->msg_enable & NETIF_MSG_RX_ERR)
761 #define netif_msg_tx_err(p)     ((p)->msg_enable & NETIF_MSG_TX_ERR)
762 #define netif_msg_tx_queued(p)  ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
763 #define netif_msg_intr(p)       ((p)->msg_enable & NETIF_MSG_INTR)
764 #define netif_msg_tx_done(p)    ((p)->msg_enable & NETIF_MSG_TX_DONE)
765 #define netif_msg_rx_status(p)  ((p)->msg_enable & NETIF_MSG_RX_STATUS)
766 #define netif_msg_pktdata(p)    ((p)->msg_enable & NETIF_MSG_PKTDATA)
767 #define netif_msg_hw(p)         ((p)->msg_enable & NETIF_MSG_HW)
768 #define netif_msg_wol(p)        ((p)->msg_enable & NETIF_MSG_WOL)
769 
770 /* Schedule rx intr now? */
771 
772 static inline int netif_rx_schedule_prep(struct net_device *dev)
773 {
774         return netif_running(dev) &&
775                 !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
776 }
777 
778 /* Add interface to tail of rx poll list. This assumes that _prep has
779  * already been called and returned 1.
780  */
781 
782 static inline void __netif_rx_schedule(struct net_device *dev)
783 {
784         unsigned long flags;
785 
786         local_irq_save(flags);
787         dev_hold(dev);
788         list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
789         if (dev->quota < 0)
790                 dev->quota += dev->weight;
791         else
792                 dev->quota = dev->weight;
793         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
794         local_irq_restore(flags);
795 }
796 
797 /* Try to reschedule poll. Called by irq handler. */
798 
799 static inline void netif_rx_schedule(struct net_device *dev)
800 {
801         if (netif_rx_schedule_prep(dev))
802                 __netif_rx_schedule(dev);
803 }
804 
805 /* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().
806  * Do not inline this?
807  */
808 static inline int netif_rx_reschedule(struct net_device *dev, int undo)
809 {
810         if (netif_rx_schedule_prep(dev)) {
811                 unsigned long flags;
812 
813                 dev->quota += undo;
814 
815                 local_irq_save(flags);
816                 list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
817                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
818                 local_irq_restore(flags);
819                 return 1;
820         }
821         return 0;
822 }
823 
824 /* Remove interface from poll list: it must be in the poll list
825  * on current cpu. This primitive is called by dev->poll(), when
826  * it completes the work. The device cannot be out of poll list at this
827  * moment, it is BUG().
828  */
829 static inline void netif_rx_complete(struct net_device *dev)
830 {
831         unsigned long flags;
832 
833         local_irq_save(flags);
834         if (!test_bit(__LINK_STATE_RX_SCHED, &dev->state)) BUG();
835         list_del(&dev->poll_list);
836         smp_mb__before_clear_bit();
837         clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
838         local_irq_restore(flags);
839 }
840 
841 static inline void netif_poll_disable(struct net_device *dev)
842 {
843         while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
844                 /* No hurry. */
845                 current->state = TASK_INTERRUPTIBLE;
846                 schedule_timeout(1);
847         }
848 }
849 
850 static inline void netif_poll_enable(struct net_device *dev)
851 {
852         clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
853 }
854 
855 /* same as netif_rx_complete, except that local_irq_save(flags)
856  * has already been issued
857  */
858 static inline void __netif_rx_complete(struct net_device *dev)
859 {
860         if (!test_bit(__LINK_STATE_RX_SCHED, &dev->state)) BUG();
861         list_del(&dev->poll_list);
862         smp_mb__before_clear_bit();
863         clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
864 }
865 
866 static inline void netif_tx_disable(struct net_device *dev)
867 {
868         spin_lock_bh(&dev->xmit_lock);
869         netif_stop_queue(dev);
870         spin_unlock_bh(&dev->xmit_lock);
871 }
872 
873 /* These functions live elsewhere (drivers/net/net_init.c, but related) */
874 
875 extern void             ether_setup(struct net_device *dev);
876 extern void             fddi_setup(struct net_device *dev);
877 extern void             tr_setup(struct net_device *dev);
878 extern void             fc_setup(struct net_device *dev);
879 extern void             fc_freedev(struct net_device *dev);
880 /* Support for loadable net-drivers */
881 extern struct net_device *alloc_netdev(int sizeof_priv, const char *name,
882                                        void (*setup)(struct net_device *));
883 extern int              register_netdev(struct net_device *dev);
884 extern void             unregister_netdev(struct net_device *dev);
885 /* Functions used for multicast support */
886 extern void             dev_mc_upload(struct net_device *dev);
887 extern int              dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
888 extern int              dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
889 extern void             dev_mc_discard(struct net_device *dev);
890 extern void             dev_set_promiscuity(struct net_device *dev, int inc);
891 extern void             dev_set_allmulti(struct net_device *dev, int inc);
892 extern void             netdev_state_change(struct net_device *dev);
893 /* Load a device via the kmod */
894 extern void             dev_load(const char *name);
895 extern void             dev_mcast_init(void);
896 extern int              netdev_register_fc(struct net_device *dev, void (*stimul)(struct net_device *dev));
897 extern void             netdev_unregister_fc(int bit);
898 extern int              netdev_max_backlog;
899 extern int              weight_p;
900 extern unsigned long    netdev_fc_xoff;
901 extern atomic_t netdev_dropping;
902 extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
903 extern struct sk_buff * skb_checksum_help(struct sk_buff *skb);
904 #ifdef CONFIG_NET_FASTROUTE
905 extern int              netdev_fastroute;
906 extern int              netdev_fastroute_obstacles;
907 extern void             dev_clear_fastroute(struct net_device *dev);
908 #endif
909 
910 #ifdef CONFIG_SYSCTL
911 extern char *net_sysctl_strdup(const char *s);
912 #endif
913 
914 #endif /* __KERNEL__ */
915 
916 #endif  /* _LINUX_DEV_H */
917 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp