LCOV - code coverage report
Current view: top level - include/linux - netdevice.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 13 13 100.0 %
Date: 2017-01-25 Functions: 0 0 -

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

Generated by: LCOV version 1.10