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