linux/include/linux/netdevice.h
<<
>>
Prefs
   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/pm_qos.h>
  29#include <linux/timer.h>
  30#include <linux/bug.h>
  31#include <linux/delay.h>
  32#include <linux/atomic.h>
  33#include <linux/prefetch.h>
  34#include <asm/cache.h>
  35#include <asm/byteorder.h>
  36
  37#include <linux/percpu.h>
  38#include <linux/rculist.h>
  39#include <linux/dmaengine.h>
  40#include <linux/workqueue.h>
  41#include <linux/dynamic_queue_limits.h>
  42
  43#include <linux/ethtool.h>
  44#include <net/net_namespace.h>
  45#include <net/dsa.h>
  46#ifdef CONFIG_DCB
  47#include <net/dcbnl.h>
  48#endif
  49#include <net/netprio_cgroup.h>
  50
  51#include <linux/netdev_features.h>
  52#include <linux/neighbour.h>
  53#include <uapi/linux/netdevice.h>
  54
  55struct netpoll_info;
  56struct device;
  57struct phy_device;
  58/* 802.11 specific */
  59struct wireless_dev;
  60/* 802.15.4 specific */
  61struct wpan_dev;
  62
  63void netdev_set_default_ethtool_ops(struct net_device *dev,
  64                                    const struct ethtool_ops *ops);
  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
 103enum 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};
 109typedef 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 */
 115static inline bool dev_xmit_complete(int rc)
 116{
 117        /*
 118         * Positive cases with an skb consumed by a driver:
 119         * - successful transmission (rc == NETDEV_TX_OK)
 120         * - error while transmitting (rc < 0)
 121         * - error while queueing to a different device (rc & NET_XMIT_MASK)
 122         */
 123        if (likely(rc < NET_XMIT_MASK))
 124                return true;
 125
 126        return false;
 127}
 128
 129/*
 130 *      Compute the worst case header length according to the protocols
 131 *      used.
 132 */
 133
 134#if defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
 135# if defined(CONFIG_MAC80211_MESH)
 136#  define LL_MAX_HEADER 128
 137# else
 138#  define LL_MAX_HEADER 96
 139# endif
 140#else
 141# define LL_MAX_HEADER 32
 142#endif
 143
 144#if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
 145    !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)
 146#define MAX_HEADER LL_MAX_HEADER
 147#else
 148#define MAX_HEADER (LL_MAX_HEADER + 48)
 149#endif
 150
 151/*
 152 *      Old network device statistics. Fields are native words
 153 *      (unsigned long) so they can be read and written atomically.
 154 */
 155
 156struct net_device_stats {
 157        unsigned long   rx_packets;
 158        unsigned long   tx_packets;
 159        unsigned long   rx_bytes;
 160        unsigned long   tx_bytes;
 161        unsigned long   rx_errors;
 162        unsigned long   tx_errors;
 163        unsigned long   rx_dropped;
 164        unsigned long   tx_dropped;
 165        unsigned long   multicast;
 166        unsigned long   collisions;
 167        unsigned long   rx_length_errors;
 168        unsigned long   rx_over_errors;
 169        unsigned long   rx_crc_errors;
 170        unsigned long   rx_frame_errors;
 171        unsigned long   rx_fifo_errors;
 172        unsigned long   rx_missed_errors;
 173        unsigned long   tx_aborted_errors;
 174        unsigned long   tx_carrier_errors;
 175        unsigned long   tx_fifo_errors;
 176        unsigned long   tx_heartbeat_errors;
 177        unsigned long   tx_window_errors;
 178        unsigned long   rx_compressed;
 179        unsigned long   tx_compressed;
 180};
 181
 182
 183#include <linux/cache.h>
 184#include <linux/skbuff.h>
 185
 186#ifdef CONFIG_RPS
 187#include <linux/static_key.h>
 188extern struct static_key rps_needed;
 189#endif
 190
 191struct neighbour;
 192struct neigh_parms;
 193struct sk_buff;
 194
 195struct netdev_hw_addr {
 196        struct list_head        list;
 197        unsigned char           addr[MAX_ADDR_LEN];
 198        unsigned char           type;
 199#define NETDEV_HW_ADDR_T_LAN            1
 200#define NETDEV_HW_ADDR_T_SAN            2
 201#define NETDEV_HW_ADDR_T_SLAVE          3
 202#define NETDEV_HW_ADDR_T_UNICAST        4
 203#define NETDEV_HW_ADDR_T_MULTICAST      5
 204        bool                    global_use;
 205        int                     sync_cnt;
 206        int                     refcount;
 207        int                     synced;
 208        struct rcu_head         rcu_head;
 209};
 210
 211struct netdev_hw_addr_list {
 212        struct list_head        list;
 213        int                     count;
 214};
 215
 216#define netdev_hw_addr_list_count(l) ((l)->count)
 217#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
 218#define netdev_hw_addr_list_for_each(ha, l) \
 219        list_for_each_entry(ha, &(l)->list, list)
 220
 221#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
 222#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
 223#define netdev_for_each_uc_addr(ha, dev) \
 224        netdev_hw_addr_list_for_each(ha, &(dev)->uc)
 225
 226#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
 227#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
 228#define netdev_for_each_mc_addr(ha, dev) \
 229        netdev_hw_addr_list_for_each(ha, &(dev)->mc)
 230
 231struct hh_cache {
 232        u16             hh_len;
 233        u16             __pad;
 234        seqlock_t       hh_lock;
 235
 236        /* cached hardware header; allow for machine alignment needs.        */
 237#define HH_DATA_MOD     16
 238#define HH_DATA_OFF(__len) \
 239        (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
 240#define HH_DATA_ALIGN(__len) \
 241        (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
 242        unsigned long   hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
 243};
 244
 245/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
 246 * Alternative is:
 247 *   dev->hard_header_len ? (dev->hard_header_len +
 248 *                           (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
 249 *
 250 * We could use other alignment values, but we must maintain the
 251 * relationship HH alignment <= LL alignment.
 252 */
 253#define LL_RESERVED_SPACE(dev) \
 254        ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 255#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
 256        ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 257
 258struct header_ops {
 259        int     (*create) (struct sk_buff *skb, struct net_device *dev,
 260                           unsigned short type, const void *daddr,
 261                           const void *saddr, unsigned int len);
 262        int     (*parse)(const struct sk_buff *skb, unsigned char *haddr);
 263        int     (*rebuild)(struct sk_buff *skb);
 264        int     (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
 265        void    (*cache_update)(struct hh_cache *hh,
 266                                const struct net_device *dev,
 267                                const unsigned char *haddr);
 268};
 269
 270/* These flag bits are private to the generic network queueing
 271 * layer, they may not be explicitly referenced by any other
 272 * code.
 273 */
 274
 275enum netdev_state_t {
 276        __LINK_STATE_START,
 277        __LINK_STATE_PRESENT,
 278        __LINK_STATE_NOCARRIER,
 279        __LINK_STATE_LINKWATCH_PENDING,
 280        __LINK_STATE_DORMANT,
 281};
 282
 283
 284/*
 285 * This structure holds at boot time configured netdevice settings. They
 286 * are then used in the device probing.
 287 */
 288struct netdev_boot_setup {
 289        char name[IFNAMSIZ];
 290        struct ifmap map;
 291};
 292#define NETDEV_BOOT_SETUP_MAX 8
 293
 294int __init netdev_boot_setup(char *str);
 295
 296/*
 297 * Structure for NAPI scheduling similar to tasklet but with weighting
 298 */
 299struct napi_struct {
 300        /* The poll_list must only be managed by the entity which
 301         * changes the state of the NAPI_STATE_SCHED bit.  This means
 302         * whoever atomically sets that bit can add this napi_struct
 303         * to the per-cpu poll_list, and whoever clears that bit
 304         * can remove from the list right before clearing the bit.
 305         */
 306        struct list_head        poll_list;
 307
 308        unsigned long           state;
 309        int                     weight;
 310        unsigned int            gro_count;
 311        int                     (*poll)(struct napi_struct *, int);
 312#ifdef CONFIG_NETPOLL
 313        spinlock_t              poll_lock;
 314        int                     poll_owner;
 315#endif
 316        struct net_device       *dev;
 317        struct sk_buff          *gro_list;
 318        struct sk_buff          *skb;
 319        struct hrtimer          timer;
 320        struct list_head        dev_list;
 321        struct hlist_node       napi_hash_node;
 322        unsigned int            napi_id;
 323};
 324
 325enum {
 326        NAPI_STATE_SCHED,       /* Poll is scheduled */
 327        NAPI_STATE_DISABLE,     /* Disable pending */
 328        NAPI_STATE_NPSVC,       /* Netpoll - don't dequeue from poll_list */
 329        NAPI_STATE_HASHED,      /* In NAPI hash */
 330};
 331
 332enum gro_result {
 333        GRO_MERGED,
 334        GRO_MERGED_FREE,
 335        GRO_HELD,
 336        GRO_NORMAL,
 337        GRO_DROP,
 338};
 339typedef enum gro_result gro_result_t;
 340
 341/*
 342 * enum rx_handler_result - Possible return values for rx_handlers.
 343 * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
 344 * further.
 345 * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
 346 * case skb->dev was changed by rx_handler.
 347 * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
 348 * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called.
 349 *
 350 * rx_handlers are functions called from inside __netif_receive_skb(), to do
 351 * special processing of the skb, prior to delivery to protocol handlers.
 352 *
 353 * Currently, a net_device can only have a single rx_handler registered. Trying
 354 * to register a second rx_handler will return -EBUSY.
 355 *
 356 * To register a rx_handler on a net_device, use netdev_rx_handler_register().
 357 * To unregister a rx_handler on a net_device, use
 358 * netdev_rx_handler_unregister().
 359 *
 360 * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
 361 * do with the skb.
 362 *
 363 * If the rx_handler consumed to skb in some way, it should return
 364 * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
 365 * the skb to be delivered in some other ways.
 366 *
 367 * If the rx_handler changed skb->dev, to divert the skb to another
 368 * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
 369 * new device will be called if it exists.
 370 *
 371 * If the rx_handler consider the skb should be ignored, it should return
 372 * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
 373 * are registered on exact device (ptype->dev == skb->dev).
 374 *
 375 * If the rx_handler didn't changed skb->dev, but want the skb to be normally
 376 * delivered, it should return RX_HANDLER_PASS.
 377 *
 378 * A device without a registered rx_handler will behave as if rx_handler
 379 * returned RX_HANDLER_PASS.
 380 */
 381
 382enum rx_handler_result {
 383        RX_HANDLER_CONSUMED,
 384        RX_HANDLER_ANOTHER,
 385        RX_HANDLER_EXACT,
 386        RX_HANDLER_PASS,
 387};
 388typedef enum rx_handler_result rx_handler_result_t;
 389typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
 390
 391void __napi_schedule(struct napi_struct *n);
 392void __napi_schedule_irqoff(struct napi_struct *n);
 393
 394static inline bool napi_disable_pending(struct napi_struct *n)
 395{
 396        return test_bit(NAPI_STATE_DISABLE, &n->state);
 397}
 398
 399/**
 400 *      napi_schedule_prep - check if napi can be scheduled
 401 *      @n: napi context
 402 *
 403 * Test if NAPI routine is already running, and if not mark
 404 * it as running.  This is used as a condition variable
 405 * insure only one NAPI poll instance runs.  We also make
 406 * sure there is no pending NAPI disable.
 407 */
 408static inline bool napi_schedule_prep(struct napi_struct *n)
 409{
 410        return !napi_disable_pending(n) &&
 411                !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
 412}
 413
 414/**
 415 *      napi_schedule - schedule NAPI poll
 416 *      @n: napi context
 417 *
 418 * Schedule NAPI poll routine to be called if it is not already
 419 * running.
 420 */
 421static inline void napi_schedule(struct napi_struct *n)
 422{
 423        if (napi_schedule_prep(n))
 424                __napi_schedule(n);
 425}
 426
 427/**
 428 *      napi_schedule_irqoff - schedule NAPI poll
 429 *      @n: napi context
 430 *
 431 * Variant of napi_schedule(), assuming hard irqs are masked.
 432 */
 433static inline void napi_schedule_irqoff(struct napi_struct *n)
 434{
 435        if (napi_schedule_prep(n))
 436                __napi_schedule_irqoff(n);
 437}
 438
 439/* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
 440static inline bool napi_reschedule(struct napi_struct *napi)
 441{
 442        if (napi_schedule_prep(napi)) {
 443                __napi_schedule(napi);
 444                return true;
 445        }
 446        return false;
 447}
 448
 449void __napi_complete(struct napi_struct *n);
 450void napi_complete_done(struct napi_struct *n, int work_done);
 451/**
 452 *      napi_complete - NAPI processing complete
 453 *      @n: napi context
 454 *
 455 * Mark NAPI processing as complete.
 456 * Consider using napi_complete_done() instead.
 457 */
 458static inline void napi_complete(struct napi_struct *n)
 459{
 460        return napi_complete_done(n, 0);
 461}
 462
 463/**
 464 *      napi_by_id - lookup a NAPI by napi_id
 465 *      @napi_id: hashed napi_id
 466 *
 467 * lookup @napi_id in napi_hash table
 468 * must be called under rcu_read_lock()
 469 */
 470struct napi_struct *napi_by_id(unsigned int napi_id);
 471
 472/**
 473 *      napi_hash_add - add a NAPI to global hashtable
 474 *      @napi: napi context
 475 *
 476 * generate a new napi_id and store a @napi under it in napi_hash
 477 */
 478void napi_hash_add(struct napi_struct *napi);
 479
 480/**
 481 *      napi_hash_del - remove a NAPI from global table
 482 *      @napi: napi context
 483 *
 484 * Warning: caller must observe rcu grace period
 485 * before freeing memory containing @napi
 486 */
 487void napi_hash_del(struct napi_struct *napi);
 488
 489/**
 490 *      napi_disable - prevent NAPI from scheduling
 491 *      @n: napi context
 492 *
 493 * Stop NAPI from being scheduled on this context.
 494 * Waits till any outstanding processing completes.
 495 */
 496void napi_disable(struct napi_struct *n);
 497
 498/**
 499 *      napi_enable - enable NAPI scheduling
 500 *      @n: napi context
 501 *
 502 * Resume NAPI from being scheduled on this context.
 503 * Must be paired with napi_disable.
 504 */
 505static inline void napi_enable(struct napi_struct *n)
 506{
 507        BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
 508        smp_mb__before_atomic();
 509        clear_bit(NAPI_STATE_SCHED, &n->state);
 510}
 511
 512#ifdef CONFIG_SMP
 513/**
 514 *      napi_synchronize - wait until NAPI is not running
 515 *      @n: napi context
 516 *
 517 * Wait until NAPI is done being scheduled on this context.
 518 * Waits till any outstanding processing completes but
 519 * does not disable future activations.
 520 */
 521static inline void napi_synchronize(const struct napi_struct *n)
 522{
 523        while (test_bit(NAPI_STATE_SCHED, &n->state))
 524                msleep(1);
 525}
 526#else
 527# define napi_synchronize(n)    barrier()
 528#endif
 529
 530enum netdev_queue_state_t {
 531        __QUEUE_STATE_DRV_XOFF,
 532        __QUEUE_STATE_STACK_XOFF,
 533        __QUEUE_STATE_FROZEN,
 534};
 535
 536#define QUEUE_STATE_DRV_XOFF    (1 << __QUEUE_STATE_DRV_XOFF)
 537#define QUEUE_STATE_STACK_XOFF  (1 << __QUEUE_STATE_STACK_XOFF)
 538#define QUEUE_STATE_FROZEN      (1 << __QUEUE_STATE_FROZEN)
 539
 540#define QUEUE_STATE_ANY_XOFF    (QUEUE_STATE_DRV_XOFF | QUEUE_STATE_STACK_XOFF)
 541#define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
 542                                        QUEUE_STATE_FROZEN)
 543#define QUEUE_STATE_DRV_XOFF_OR_FROZEN (QUEUE_STATE_DRV_XOFF | \
 544                                        QUEUE_STATE_FROZEN)
 545
 546/*
 547 * __QUEUE_STATE_DRV_XOFF is used by drivers to stop the transmit queue.  The
 548 * netif_tx_* functions below are used to manipulate this flag.  The
 549 * __QUEUE_STATE_STACK_XOFF flag is used by the stack to stop the transmit
 550 * queue independently.  The netif_xmit_*stopped functions below are called
 551 * to check if the queue has been stopped by the driver or stack (either
 552 * of the XOFF bits are set in the state).  Drivers should not need to call
 553 * netif_xmit*stopped functions, they should only be using netif_tx_*.
 554 */
 555
 556struct netdev_queue {
 557/*
 558 * read mostly part
 559 */
 560        struct net_device       *dev;
 561        struct Qdisc __rcu      *qdisc;
 562        struct Qdisc            *qdisc_sleeping;
 563#ifdef CONFIG_SYSFS
 564        struct kobject          kobj;
 565#endif
 566#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
 567        int                     numa_node;
 568#endif
 569/*
 570 * write mostly part
 571 */
 572        spinlock_t              _xmit_lock ____cacheline_aligned_in_smp;
 573        int                     xmit_lock_owner;
 574        /*
 575         * please use this field instead of dev->trans_start
 576         */
 577        unsigned long           trans_start;
 578
 579        /*
 580         * Number of TX timeouts for this queue
 581         * (/sys/class/net/DEV/Q/trans_timeout)
 582         */
 583        unsigned long           trans_timeout;
 584
 585        unsigned long           state;
 586
 587#ifdef CONFIG_BQL
 588        struct dql              dql;
 589#endif
 590} ____cacheline_aligned_in_smp;
 591
 592static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
 593{
 594#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
 595        return q->numa_node;
 596#else
 597        return NUMA_NO_NODE;
 598#endif
 599}
 600
 601static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
 602{
 603#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
 604        q->numa_node = node;
 605#endif
 606}
 607
 608#ifdef CONFIG_RPS
 609/*
 610 * This structure holds an RPS map which can be of variable length.  The
 611 * map is an array of CPUs.
 612 */
 613struct rps_map {
 614        unsigned int len;
 615        struct rcu_head rcu;
 616        u16 cpus[0];
 617};
 618#define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + ((_num) * sizeof(u16)))
 619
 620/*
 621 * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
 622 * tail pointer for that CPU's input queue at the time of last enqueue, and
 623 * a hardware filter index.
 624 */
 625struct rps_dev_flow {
 626        u16 cpu;
 627        u16 filter;
 628        unsigned int last_qtail;
 629};
 630#define RPS_NO_FILTER 0xffff
 631
 632/*
 633 * The rps_dev_flow_table structure contains a table of flow mappings.
 634 */
 635struct rps_dev_flow_table {
 636        unsigned int mask;
 637        struct rcu_head rcu;
 638        struct rps_dev_flow flows[0];
 639};
 640#define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
 641    ((_num) * sizeof(struct rps_dev_flow)))
 642
 643/*
 644 * The rps_sock_flow_table contains mappings of flows to the last CPU
 645 * on which they were processed by the application (set in recvmsg).
 646 */
 647struct rps_sock_flow_table {
 648        unsigned int mask;
 649        u16 ents[0];
 650};
 651#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
 652    ((_num) * sizeof(u16)))
 653
 654#define RPS_NO_CPU 0xffff
 655
 656static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
 657                                        u32 hash)
 658{
 659        if (table && hash) {
 660                unsigned int cpu, index = hash & table->mask;
 661
 662                /* We only give a hint, preemption can change cpu under us */
 663                cpu = raw_smp_processor_id();
 664
 665                if (table->ents[index] != cpu)
 666                        table->ents[index] = cpu;
 667        }
 668}
 669
 670static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
 671                                       u32 hash)
 672{
 673        if (table && hash)
 674                table->ents[hash & table->mask] = RPS_NO_CPU;
 675}
 676
 677extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
 678
 679#ifdef CONFIG_RFS_ACCEL
 680bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id,
 681                         u16 filter_id);
 682#endif
 683#endif /* CONFIG_RPS */
 684
 685/* This structure contains an instance of an RX queue. */
 686struct netdev_rx_queue {
 687#ifdef CONFIG_RPS
 688        struct rps_map __rcu            *rps_map;
 689        struct rps_dev_flow_table __rcu *rps_flow_table;
 690#endif
 691        struct kobject                  kobj;
 692        struct net_device               *dev;
 693} ____cacheline_aligned_in_smp;
 694
 695/*
 696 * RX queue sysfs structures and functions.
 697 */
 698struct rx_queue_attribute {
 699        struct attribute attr;
 700        ssize_t (*show)(struct netdev_rx_queue *queue,
 701            struct rx_queue_attribute *attr, char *buf);
 702        ssize_t (*store)(struct netdev_rx_queue *queue,
 703            struct rx_queue_attribute *attr, const char *buf, size_t len);
 704};
 705
 706#ifdef CONFIG_XPS
 707/*
 708 * This structure holds an XPS map which can be of variable length.  The
 709 * map is an array of queues.
 710 */
 711struct xps_map {
 712        unsigned int len;
 713        unsigned int alloc_len;
 714        struct rcu_head rcu;
 715        u16 queues[0];
 716};
 717#define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16)))
 718#define XPS_MIN_MAP_ALLOC ((L1_CACHE_BYTES - sizeof(struct xps_map))    \
 719    / sizeof(u16))
 720
 721/*
 722 * This structure holds all XPS maps for device.  Maps are indexed by CPU.
 723 */
 724struct xps_dev_maps {
 725        struct rcu_head rcu;
 726        struct xps_map __rcu *cpu_map[0];
 727};
 728#define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) +                \
 729    (nr_cpu_ids * sizeof(struct xps_map *)))
 730#endif /* CONFIG_XPS */
 731
 732#define TC_MAX_QUEUE    16
 733#define TC_BITMASK      15
 734/* HW offloaded queuing disciplines txq count and offset maps */
 735struct netdev_tc_txq {
 736        u16 count;
 737        u16 offset;
 738};
 739
 740#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
 741/*
 742 * This structure is to hold information about the device
 743 * configured to run FCoE protocol stack.
 744 */
 745struct netdev_fcoe_hbainfo {
 746        char    manufacturer[64];
 747        char    serial_number[64];
 748        char    hardware_version[64];
 749        char    driver_version[64];
 750        char    optionrom_version[64];
 751        char    firmware_version[64];
 752        char    model[256];
 753        char    model_description[256];
 754};
 755#endif
 756
 757#define MAX_PHYS_ITEM_ID_LEN 32
 758
 759/* This structure holds a unique identifier to identify some
 760 * physical item (port for example) used by a netdevice.
 761 */
 762struct netdev_phys_item_id {
 763        unsigned char id[MAX_PHYS_ITEM_ID_LEN];
 764        unsigned char id_len;
 765};
 766
 767typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
 768                                       struct sk_buff *skb);
 769
 770/*
 771 * This structure defines the management hooks for network devices.
 772 * The following hooks can be defined; unless noted otherwise, they are
 773 * optional and can be filled with a null pointer.
 774 *
 775 * int (*ndo_init)(struct net_device *dev);
 776 *     This function is called once when network device is registered.
 777 *     The network device can use this to any late stage initializaton
 778 *     or semantic validattion. It can fail with an error code which will
 779 *     be propogated back to register_netdev
 780 *
 781 * void (*ndo_uninit)(struct net_device *dev);
 782 *     This function is called when device is unregistered or when registration
 783 *     fails. It is not called if init fails.
 784 *
 785 * int (*ndo_open)(struct net_device *dev);
 786 *     This function is called when network device transistions to the up
 787 *     state.
 788 *
 789 * int (*ndo_stop)(struct net_device *dev);
 790 *     This function is called when network device transistions to the down
 791 *     state.
 792 *
 793 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
 794 *                               struct net_device *dev);
 795 *      Called when a packet needs to be transmitted.
 796 *      Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
 797 *        (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
 798 *      Required can not be NULL.
 799 *
 800 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
 801 *                         void *accel_priv, select_queue_fallback_t fallback);
 802 *      Called to decide which queue to when device supports multiple
 803 *      transmit queues.
 804 *
 805 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
 806 *      This function is called to allow device receiver to make
 807 *      changes to configuration when multicast or promiscious is enabled.
 808 *
 809 * void (*ndo_set_rx_mode)(struct net_device *dev);
 810 *      This function is called device changes address list filtering.
 811 *      If driver handles unicast address filtering, it should set
 812 *      IFF_UNICAST_FLT to its priv_flags.
 813 *
 814 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
 815 *      This function  is called when the Media Access Control address
 816 *      needs to be changed. If this interface is not defined, the
 817 *      mac address can not be changed.
 818 *
 819 * int (*ndo_validate_addr)(struct net_device *dev);
 820 *      Test if Media Access Control address is valid for the device.
 821 *
 822 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
 823 *      Called when a user request an ioctl which can't be handled by
 824 *      the generic interface code. If not defined ioctl's return
 825 *      not supported error code.
 826 *
 827 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
 828 *      Used to set network devices bus interface parameters. This interface
 829 *      is retained for legacy reason, new devices should use the bus
 830 *      interface (PCI) for low level management.
 831 *
 832 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
 833 *      Called when a user wants to change the Maximum Transfer Unit
 834 *      of a device. If not defined, any request to change MTU will
 835 *      will return an error.
 836 *
 837 * void (*ndo_tx_timeout)(struct net_device *dev);
 838 *      Callback uses when the transmitter has not made any progress
 839 *      for dev->watchdog ticks.
 840 *
 841 * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
 842 *                      struct rtnl_link_stats64 *storage);
 843 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
 844 *      Called when a user wants to get the network device usage
 845 *      statistics. Drivers must do one of the following:
 846 *      1. Define @ndo_get_stats64 to fill in a zero-initialised
 847 *         rtnl_link_stats64 structure passed by the caller.
 848 *      2. Define @ndo_get_stats to update a net_device_stats structure
 849 *         (which should normally be dev->stats) and return a pointer to
 850 *         it. The structure may be changed asynchronously only if each
 851 *         field is written atomically.
 852 *      3. Update dev->stats asynchronously and atomically, and define
 853 *         neither operation.
 854 *
 855 * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16 vid);
 856 *      If device support VLAN filtering this function is called when a
 857 *      VLAN id is registered.
 858 *
 859 * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, __be16 proto, u16 vid);
 860 *      If device support VLAN filtering this function is called when a
 861 *      VLAN id is unregistered.
 862 *
 863 * void (*ndo_poll_controller)(struct net_device *dev);
 864 *
 865 *      SR-IOV management functions.
 866 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
 867 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
 868 * int (*ndo_set_vf_rate)(struct net_device *dev, int vf, int min_tx_rate,
 869 *                        int max_tx_rate);
 870 * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);
 871 * int (*ndo_get_vf_config)(struct net_device *dev,
 872 *                          int vf, struct ifla_vf_info *ivf);
 873 * int (*ndo_set_vf_link_state)(struct net_device *dev, int vf, int link_state);
 874 * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
 875 *                        struct nlattr *port[]);
 876 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
 877 * int (*ndo_setup_tc)(struct net_device *dev, u8 tc)
 878 *      Called to setup 'tc' number of traffic classes in the net device. This
 879 *      is always called from the stack with the rtnl lock held and netif tx
 880 *      queues stopped. This allows the netdevice to perform queue management
 881 *      safely.
 882 *
 883 *      Fiber Channel over Ethernet (FCoE) offload functions.
 884 * int (*ndo_fcoe_enable)(struct net_device *dev);
 885 *      Called when the FCoE protocol stack wants to start using LLD for FCoE
 886 *      so the underlying device can perform whatever needed configuration or
 887 *      initialization to support acceleration of FCoE traffic.
 888 *
 889 * int (*ndo_fcoe_disable)(struct net_device *dev);
 890 *      Called when the FCoE protocol stack wants to stop using LLD for FCoE
 891 *      so the underlying device can perform whatever needed clean-ups to
 892 *      stop supporting acceleration of FCoE traffic.
 893 *
 894 * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
 895 *                           struct scatterlist *sgl, unsigned int sgc);
 896 *      Called when the FCoE Initiator wants to initialize an I/O that
 897 *      is a possible candidate for Direct Data Placement (DDP). The LLD can
 898 *      perform necessary setup and returns 1 to indicate the device is set up
 899 *      successfully to perform DDP on this I/O, otherwise this returns 0.
 900 *
 901 * int (*ndo_fcoe_ddp_done)(struct net_device *dev,  u16 xid);
 902 *      Called when the FCoE Initiator/Target is done with the DDPed I/O as
 903 *      indicated by the FC exchange id 'xid', so the underlying device can
 904 *      clean up and reuse resources for later DDP requests.
 905 *
 906 * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
 907 *                            struct scatterlist *sgl, unsigned int sgc);
 908 *      Called when the FCoE Target wants to initialize an I/O that
 909 *      is a possible candidate for Direct Data Placement (DDP). The LLD can
 910 *      perform necessary setup and returns 1 to indicate the device is set up
 911 *      successfully to perform DDP on this I/O, otherwise this returns 0.
 912 *
 913 * int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
 914 *                             struct netdev_fcoe_hbainfo *hbainfo);
 915 *      Called when the FCoE Protocol stack wants information on the underlying
 916 *      device. This information is utilized by the FCoE protocol stack to
 917 *      register attributes with Fiber Channel management service as per the
 918 *      FC-GS Fabric Device Management Information(FDMI) specification.
 919 *
 920 * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
 921 *      Called when the underlying device wants to override default World Wide
 922 *      Name (WWN) generation mechanism in FCoE protocol stack to pass its own
 923 *      World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
 924 *      protocol stack to use.
 925 *
 926 *      RFS acceleration.
 927 * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
 928 *                          u16 rxq_index, u32 flow_id);
 929 *      Set hardware filter for RFS.  rxq_index is the target queue index;
 930 *      flow_id is a flow ID to be passed to rps_may_expire_flow() later.
 931 *      Return the filter ID on success, or a negative error code.
 932 *
 933 *      Slave management functions (for bridge, bonding, etc).
 934 * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
 935 *      Called to make another netdev an underling.
 936 *
 937 * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
 938 *      Called to release previously enslaved netdev.
 939 *
 940 *      Feature/offload setting functions.
 941 * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
 942 *              netdev_features_t features);
 943 *      Adjusts the requested feature flags according to device-specific
 944 *      constraints, and returns the resulting flags. Must not modify
 945 *      the device state.
 946 *
 947 * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features);
 948 *      Called to update device configuration to new features. Passed
 949 *      feature set might be less than what was returned by ndo_fix_features()).
 950 *      Must return >0 or -errno if it changed dev->features itself.
 951 *
 952 * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[],
 953 *                    struct net_device *dev,
 954 *                    const unsigned char *addr, u16 vid, u16 flags)
 955 *      Adds an FDB entry to dev for addr.
 956 * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
 957 *                    struct net_device *dev,
 958 *                    const unsigned char *addr, u16 vid)
 959 *      Deletes the FDB entry from dev coresponding to addr.
 960 * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
 961 *                     struct net_device *dev, struct net_device *filter_dev,
 962 *                     int idx)
 963 *      Used to add FDB entries to dump requests. Implementers should add
 964 *      entries to skb and update idx with the number of entries.
 965 *
 966 * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh)
 967 * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq,
 968 *                           struct net_device *dev, u32 filter_mask)
 969 *
 970 * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier);
 971 *      Called to change device carrier. Soft-devices (like dummy, team, etc)
 972 *      which do not represent real hardware may define this to allow their
 973 *      userspace components to manage their virtual carrier state. Devices
 974 *      that determine carrier state from physical hardware properties (eg
 975 *      network cables) or protocol-dependent mechanisms (eg
 976 *      USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
 977 *
 978 * int (*ndo_get_phys_port_id)(struct net_device *dev,
 979 *                             struct netdev_phys_item_id *ppid);
 980 *      Called to get ID of physical port of this device. If driver does
 981 *      not implement this, it is assumed that the hw is not able to have
 982 *      multiple net devices on single physical port.
 983 *
 984 * void (*ndo_add_vxlan_port)(struct  net_device *dev,
 985 *                            sa_family_t sa_family, __be16 port);
 986 *      Called by vxlan to notiy a driver about the UDP port and socket
 987 *      address family that vxlan is listnening to. It is called only when
 988 *      a new port starts listening. The operation is protected by the
 989 *      vxlan_net->sock_lock.
 990 *
 991 * void (*ndo_del_vxlan_port)(struct  net_device *dev,
 992 *                            sa_family_t sa_family, __be16 port);
 993 *      Called by vxlan to notify the driver about a UDP port and socket
 994 *      address family that vxlan is not listening to anymore. The operation
 995 *      is protected by the vxlan_net->sock_lock.
 996 *
 997 * void* (*ndo_dfwd_add_station)(struct net_device *pdev,
 998 *                               struct net_device *dev)
 999 *      Called by upper layer devices to accelerate switching or other
1000 *      station functionality into hardware. 'pdev is the lowerdev
1001 *      to use for the offload and 'dev' is the net device that will
1002 *      back the offload. Returns a pointer to the private structure
1003 *      the upper layer will maintain.
1004 * void (*ndo_dfwd_del_station)(struct net_device *pdev, void *priv)
1005 *      Called by upper layer device to delete the station created
1006 *      by 'ndo_dfwd_add_station'. 'pdev' is the net device backing
1007 *      the station and priv is the structure returned by the add
1008 *      operation.
1009 * netdev_tx_t (*ndo_dfwd_start_xmit)(struct sk_buff *skb,
1010 *                                    struct net_device *dev,
1011 *                                    void *priv);
1012 *      Callback to use for xmit over the accelerated station. This
1013 *      is used in place of ndo_start_xmit on accelerated net
1014 *      devices.
1015 * netdev_features_t (*ndo_features_check) (struct sk_buff *skb,
1016 *                                          struct net_device *dev
1017 *                                          netdev_features_t features);
1018 *      Called by core transmit path to determine if device is capable of
1019 *      performing offload operations on a given packet. This is to give
1020 *      the device an opportunity to implement any restrictions that cannot
1021 *      be otherwise expressed by feature flags. The check is called with
1022 *      the set of features that the stack has calculated and it returns
1023 *      those the driver believes to be appropriate.
1024 *
1025 * int (*ndo_switch_parent_id_get)(struct net_device *dev,
1026 *                                 struct netdev_phys_item_id *psid);
1027 *      Called to get an ID of the switch chip this port is part of.
1028 *      If driver implements this, it indicates that it represents a port
1029 *      of a switch chip.
1030 * int (*ndo_switch_port_stp_update)(struct net_device *dev, u8 state);
1031 *      Called to notify switch device port of bridge port STP
1032 *      state change.
1033 */
1034struct net_device_ops {
1035        int                     (*ndo_init)(struct net_device *dev);
1036        void                    (*ndo_uninit)(struct net_device *dev);
1037        int                     (*ndo_open)(struct net_device *dev);
1038        int                     (*ndo_stop)(struct net_device *dev);
1039        netdev_tx_t             (*ndo_start_xmit) (struct sk_buff *skb,
1040                                                   struct net_device *dev);
1041        u16                     (*ndo_select_queue)(struct net_device *dev,
1042                                                    struct sk_buff *skb,
1043                                                    void *accel_priv,
1044                                                    select_queue_fallback_t fallback);
1045        void                    (*ndo_change_rx_flags)(struct net_device *dev,
1046                                                       int flags);
1047        void                    (*ndo_set_rx_mode)(struct net_device *dev);
1048        int                     (*ndo_set_mac_address)(struct net_device *dev,
1049                                                       void *addr);
1050        int                     (*ndo_validate_addr)(struct net_device *dev);
1051        int                     (*ndo_do_ioctl)(struct net_device *dev,
1052                                                struct ifreq *ifr, int cmd);
1053        int                     (*ndo_set_config)(struct net_device *dev,
1054                                                  struct ifmap *map);
1055        int                     (*ndo_change_mtu)(struct net_device *dev,
1056                                                  int new_mtu);
1057        int                     (*ndo_neigh_setup)(struct net_device *dev,
1058                                                   struct neigh_parms *);
1059        void                    (*ndo_tx_timeout) (struct net_device *dev);
1060
1061        struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
1062                                                     struct rtnl_link_stats64 *storage);
1063        struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
1064
1065        int                     (*ndo_vlan_rx_add_vid)(struct net_device *dev,
1066                                                       __be16 proto, u16 vid);
1067        int                     (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
1068                                                        __be16 proto, u16 vid);
1069#ifdef CONFIG_NET_POLL_CONTROLLER
1070        void                    (*ndo_poll_controller)(struct net_device *dev);
1071        int                     (*ndo_netpoll_setup)(struct net_device *dev,
1072                                                     struct netpoll_info *info);
1073        void                    (*ndo_netpoll_cleanup)(struct net_device *dev);
1074#endif
1075#ifdef CONFIG_NET_RX_BUSY_POLL
1076        int                     (*ndo_busy_poll)(struct napi_struct *dev);
1077#endif
1078        int                     (*ndo_set_vf_mac)(struct net_device *dev,
1079                                                  int queue, u8 *mac);
1080        int                     (*ndo_set_vf_vlan)(struct net_device *dev,
1081                                                   int queue, u16 vlan, u8 qos);
1082        int                     (*ndo_set_vf_rate)(struct net_device *dev,
1083                                                   int vf, int min_tx_rate,
1084                                                   int max_tx_rate);
1085        int                     (*ndo_set_vf_spoofchk)(struct net_device *dev,
1086                                                       int vf, bool setting);
1087        int                     (*ndo_get_vf_config)(struct net_device *dev,
1088                                                     int vf,
1089                                                     struct ifla_vf_info *ivf);
1090        int                     (*ndo_set_vf_link_state)(struct net_device *dev,
1091                                                         int vf, int link_state);
1092        int                     (*ndo_set_vf_port)(struct net_device *dev,
1093                                                   int vf,
1094                                                   struct nlattr *port[]);
1095        int                     (*ndo_get_vf_port)(struct net_device *dev,
1096                                                   int vf, struct sk_buff *skb);
1097        int                     (*ndo_setup_tc)(struct net_device *dev, u8 tc);
1098#if IS_ENABLED(CONFIG_FCOE)
1099        int                     (*ndo_fcoe_enable)(struct net_device *dev);
1100        int                     (*ndo_fcoe_disable)(struct net_device *dev);
1101        int                     (*ndo_fcoe_ddp_setup)(struct net_device *dev,
1102                                                      u16 xid,
1103                                                      struct scatterlist *sgl,
1104                                                      unsigned int sgc);
1105        int                     (*ndo_fcoe_ddp_done)(struct net_device *dev,
1106                                                     u16 xid);
1107        int                     (*ndo_fcoe_ddp_target)(struct net_device *dev,
1108                                                       u16 xid,
1109                                                       struct scatterlist *sgl,
1110                                                       unsigned int sgc);
1111        int                     (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
1112                                                        struct netdev_fcoe_hbainfo *hbainfo);
1113#endif
1114
1115#if IS_ENABLED(CONFIG_LIBFCOE)
1116#define NETDEV_FCOE_WWNN 0
1117#define NETDEV_FCOE_WWPN 1
1118        int                     (*ndo_fcoe_get_wwn)(struct net_device *dev,
1119                                                    u64 *wwn, int type);
1120#endif
1121
1122#ifdef CONFIG_RFS_ACCEL
1123        int                     (*ndo_rx_flow_steer)(struct net_device *dev,
1124                                                     const struct sk_buff *skb,
1125                                                     u16 rxq_index,
1126                                                     u32 flow_id);
1127#endif
1128        int                     (*ndo_add_slave)(struct net_device *dev,
1129                                                 struct net_device *slave_dev);
1130        int                     (*ndo_del_slave)(struct net_device *dev,
1131                                                 struct net_device *slave_dev);
1132        netdev_features_t       (*ndo_fix_features)(struct net_device *dev,
1133                                                    netdev_features_t features);
1134        int                     (*ndo_set_features)(struct net_device *dev,
1135                                                    netdev_features_t features);
1136        int                     (*ndo_neigh_construct)(struct neighbour *n);
1137        void                    (*ndo_neigh_destroy)(struct neighbour *n);
1138
1139        int                     (*ndo_fdb_add)(struct ndmsg *ndm,
1140                                               struct nlattr *tb[],
1141                                               struct net_device *dev,
1142                                               const unsigned char *addr,
1143                                               u16 vid,
1144                                               u16 flags);
1145        int                     (*ndo_fdb_del)(struct ndmsg *ndm,
1146                                               struct nlattr *tb[],
1147                                               struct net_device *dev,
1148                                               const unsigned char *addr,
1149                                               u16 vid);
1150        int                     (*ndo_fdb_dump)(struct sk_buff *skb,
1151                                                struct netlink_callback *cb,
1152                                                struct net_device *dev,
1153                                                struct net_device *filter_dev,
1154                                                int idx);
1155
1156        int                     (*ndo_bridge_setlink)(struct net_device *dev,
1157                                                      struct nlmsghdr *nlh);
1158        int                     (*ndo_bridge_getlink)(struct sk_buff *skb,
1159                                                      u32 pid, u32 seq,
1160                                                      struct net_device *dev,
1161                                                      u32 filter_mask);
1162        int                     (*ndo_bridge_dellink)(struct net_device *dev,
1163                                                      struct nlmsghdr *nlh);
1164        int                     (*ndo_change_carrier)(struct net_device *dev,
1165                                                      bool new_carrier);
1166        int                     (*ndo_get_phys_port_id)(struct net_device *dev,
1167                                                        struct netdev_phys_item_id *ppid);
1168        void                    (*ndo_add_vxlan_port)(struct  net_device *dev,
1169                                                      sa_family_t sa_family,
1170                                                      __be16 port);
1171        void                    (*ndo_del_vxlan_port)(struct  net_device *dev,
1172                                                      sa_family_t sa_family,
1173                                                      __be16 port);
1174
1175        void*                   (*ndo_dfwd_add_station)(struct net_device *pdev,
1176                                                        struct net_device *dev);
1177        void                    (*ndo_dfwd_del_station)(struct net_device *pdev,
1178                                                        void *priv);
1179
1180        netdev_tx_t             (*ndo_dfwd_start_xmit) (struct sk_buff *skb,
1181                                                        struct net_device *dev,
1182                                                        void *priv);
1183        int                     (*ndo_get_lock_subclass)(struct net_device *dev);
1184        netdev_features_t       (*ndo_features_check) (struct sk_buff *skb,
1185                                                       struct net_device *dev,
1186                                                       netdev_features_t features);
1187#ifdef CONFIG_NET_SWITCHDEV
1188        int                     (*ndo_switch_parent_id_get)(struct net_device *dev,
1189                                                            struct netdev_phys_item_id *psid);
1190        int                     (*ndo_switch_port_stp_update)(struct net_device *dev,
1191                                                              u8 state);
1192#endif
1193};
1194
1195/**
1196 * enum net_device_priv_flags - &struct net_device priv_flags
1197 *
1198 * These are the &struct net_device, they are only set internally
1199 * by drivers and used in the kernel. These flags are invisible to
1200 * userspace, this means that the order of these flags can change
1201 * during any kernel release.
1202 *
1203 * You should have a pretty good reason to be extending these flags.
1204 *
1205 * @IFF_802_1Q_VLAN: 802.1Q VLAN device
1206 * @IFF_EBRIDGE: Ethernet bridging device
1207 * @IFF_SLAVE_INACTIVE: bonding slave not the curr. active
1208 * @IFF_MASTER_8023AD: bonding master, 802.3ad
1209 * @IFF_MASTER_ALB: bonding master, balance-alb
1210 * @IFF_BONDING: bonding master or slave
1211 * @IFF_SLAVE_NEEDARP: need ARPs for validation
1212 * @IFF_ISATAP: ISATAP interface (RFC4214)
1213 * @IFF_MASTER_ARPMON: bonding master, ARP mon in use
1214 * @IFF_WAN_HDLC: WAN HDLC device
1215 * @IFF_XMIT_DST_RELEASE: dev_hard_start_xmit() is allowed to
1216 *      release skb->dst
1217 * @IFF_DONT_BRIDGE: disallow bridging this ether dev
1218 * @IFF_DISABLE_NETPOLL: disable netpoll at run-time
1219 * @IFF_MACVLAN_PORT: device used as macvlan port
1220 * @IFF_BRIDGE_PORT: device used as bridge port
1221 * @IFF_OVS_DATAPATH: device used as Open vSwitch datapath port
1222 * @IFF_TX_SKB_SHARING: The interface supports sharing skbs on transmit
1223 * @IFF_UNICAST_FLT: Supports unicast filtering
1224 * @IFF_TEAM_PORT: device used as team port
1225 * @IFF_SUPP_NOFCS: device supports sending custom FCS
1226 * @IFF_LIVE_ADDR_CHANGE: device supports hardware address
1227 *      change when it's running
1228 * @IFF_MACVLAN: Macvlan device
1229 */
1230enum netdev_priv_flags {
1231        IFF_802_1Q_VLAN                 = 1<<0,
1232        IFF_EBRIDGE                     = 1<<1,
1233        IFF_SLAVE_INACTIVE              = 1<<2,
1234        IFF_MASTER_8023AD               = 1<<3,
1235        IFF_MASTER_ALB                  = 1<<4,
1236        IFF_BONDING                     = 1<<5,
1237        IFF_SLAVE_NEEDARP               = 1<<6,
1238        IFF_ISATAP                      = 1<<7,
1239        IFF_MASTER_ARPMON               = 1<<8,
1240        IFF_WAN_HDLC                    = 1<<9,
1241        IFF_XMIT_DST_RELEASE            = 1<<10,
1242        IFF_DONT_BRIDGE                 = 1<<11,
1243        IFF_DISABLE_NETPOLL             = 1<<12,
1244        IFF_MACVLAN_PORT                = 1<<13,
1245        IFF_BRIDGE_PORT                 = 1<<14,
1246        IFF_OVS_DATAPATH                = 1<<15,
1247        IFF_TX_SKB_SHARING              = 1<<16,
1248        IFF_UNICAST_FLT                 = 1<<17,
1249        IFF_TEAM_PORT                   = 1<<18,
1250        IFF_SUPP_NOFCS                  = 1<<19,
1251        IFF_LIVE_ADDR_CHANGE            = 1<<20,
1252        IFF_MACVLAN                     = 1<<21,
1253        IFF_XMIT_DST_RELEASE_PERM       = 1<<22,
1254        IFF_IPVLAN_MASTER               = 1<<23,
1255        IFF_IPVLAN_SLAVE                = 1<<24,
1256};
1257
1258#define IFF_802_1Q_VLAN                 IFF_802_1Q_VLAN
1259#define IFF_EBRIDGE                     IFF_EBRIDGE
1260#define IFF_SLAVE_INACTIVE              IFF_SLAVE_INACTIVE
1261#define IFF_MASTER_8023AD               IFF_MASTER_8023AD
1262#define IFF_MASTER_ALB                  IFF_MASTER_ALB
1263#define IFF_BONDING                     IFF_BONDING
1264#define IFF_SLAVE_NEEDARP               IFF_SLAVE_NEEDARP
1265#define IFF_ISATAP                      IFF_ISATAP
1266#define IFF_MASTER_ARPMON               IFF_MASTER_ARPMON
1267#define IFF_WAN_HDLC                    IFF_WAN_HDLC
1268#define IFF_XMIT_DST_RELEASE            IFF_XMIT_DST_RELEASE
1269#define IFF_DONT_BRIDGE                 IFF_DONT_BRIDGE
1270#define IFF_DISABLE_NETPOLL             IFF_DISABLE_NETPOLL
1271#define IFF_MACVLAN_PORT                IFF_MACVLAN_PORT
1272#define IFF_BRIDGE_PORT                 IFF_BRIDGE_PORT
1273#define IFF_OVS_DATAPATH                IFF_OVS_DATAPATH
1274#define IFF_TX_SKB_SHARING              IFF_TX_SKB_SHARING
1275#define IFF_UNICAST_FLT                 IFF_UNICAST_FLT
1276#define IFF_TEAM_PORT                   IFF_TEAM_PORT
1277#define IFF_SUPP_NOFCS                  IFF_SUPP_NOFCS
1278#define IFF_LIVE_ADDR_CHANGE            IFF_LIVE_ADDR_CHANGE
1279#define IFF_MACVLAN                     IFF_MACVLAN
1280#define IFF_XMIT_DST_RELEASE_PERM       IFF_XMIT_DST_RELEASE_PERM
1281#define IFF_IPVLAN_MASTER               IFF_IPVLAN_MASTER
1282#define IFF_IPVLAN_SLAVE                IFF_IPVLAN_SLAVE
1283
1284/**
1285 *      struct net_device - The DEVICE structure.
1286 *              Actually, this whole structure is a big mistake.  It mixes I/O
1287 *              data with strictly "high-level" data, and it has to know about
1288 *              almost every data structure used in the INET module.
1289 *
1290 *      @name:  This is the first field of the "visible" part of this structure
1291 *              (i.e. as seen by users in the "Space.c" file).  It is the name
1292 *              of the interface.
1293 *
1294 *      @name_hlist:    Device name hash chain, please keep it close to name[]
1295 *      @ifalias:       SNMP alias
1296 *      @mem_end:       Shared memory end
1297 *      @mem_start:     Shared memory start
1298 *      @base_addr:     Device I/O address
1299 *      @irq:           Device IRQ number
1300 *
1301 *      @state:         Generic network queuing layer state, see netdev_state_t
1302 *      @dev_list:      The global list of network devices
1303 *      @napi_list:     List entry, that is used for polling napi devices
1304 *      @unreg_list:    List entry, that is used, when we are unregistering the
1305 *                      device, see the function unregister_netdev
1306 *      @close_list:    List entry, that is used, when we are closing the device
1307 *
1308 *      @adj_list:      Directly linked devices, like slaves for bonding
1309 *      @all_adj_list:  All linked devices, *including* neighbours
1310 *      @features:      Currently active device features
1311 *      @hw_features:   User-changeable features
1312 *
1313 *      @wanted_features:       User-requested features
1314 *      @vlan_features:         Mask of features inheritable by VLAN devices
1315 *
1316 *      @hw_enc_features:       Mask of features inherited by encapsulating devices
1317 *                              This field indicates what encapsulation
1318 *                              offloads the hardware is capable of doing,
1319 *                              and drivers will need to set them appropriately.
1320 *
1321 *      @mpls_features: Mask of features inheritable by MPLS
1322 *
1323 *      @ifindex:       interface index
1324 *      @iflink:        unique device identifier
1325 *
1326 *      @stats:         Statistics struct, which was left as a legacy, use
1327 *                      rtnl_link_stats64 instead
1328 *
1329 *      @rx_dropped:    Dropped packets by core network,
1330 *                      do not use this in drivers
1331 *      @tx_dropped:    Dropped packets by core network,
1332 *                      do not use this in drivers
1333 *
1334 *      @carrier_changes:       Stats to monitor carrier on<->off transitions
1335 *
1336 *      @wireless_handlers:     List of functions to handle Wireless Extensions,
1337 *                              instead of ioctl,
1338 *                              see <net/iw_handler.h> for details.
1339 *      @wireless_data: Instance data managed by the core of wireless extensions
1340 *
1341 *      @netdev_ops:    Includes several pointers to callbacks,
1342 *                      if one wants to override the ndo_*() functions
1343 *      @ethtool_ops:   Management operations
1344 *      @fwd_ops:       Management operations
1345 *      @header_ops:    Includes callbacks for creating,parsing,rebuilding,etc
1346 *                      of Layer 2 headers.
1347 *
1348 *      @flags:         Interface flags (a la BSD)
1349 *      @priv_flags:    Like 'flags' but invisible to userspace,
1350 *                      see if.h for the definitions
1351 *      @gflags:        Global flags ( kept as legacy )
1352 *      @padded:        How much padding added by alloc_netdev()
1353 *      @operstate:     RFC2863 operstate
1354 *      @link_mode:     Mapping policy to operstate
1355 *      @if_port:       Selectable AUI, TP, ...
1356 *      @dma:           DMA channel
1357 *      @mtu:           Interface MTU value
1358 *      @type:          Interface hardware type
1359 *      @hard_header_len: Hardware header length
1360 *
1361 *      @needed_headroom: Extra headroom the hardware may need, but not in all
1362 *                        cases can this be guaranteed
1363 *      @needed_tailroom: Extra tailroom the hardware may need, but not in all
1364 *                        cases can this be guaranteed. Some cases also use
1365 *                        LL_MAX_HEADER instead to allocate the skb
1366 *
1367 *      interface address info:
1368 *
1369 *      @perm_addr:             Permanent hw address
1370 *      @addr_assign_type:      Hw address assignment type
1371 *      @addr_len:              Hardware address length
1372 *      @neigh_priv_len;        Used in neigh_alloc(),
1373 *                              initialized only in atm/clip.c
1374 *      @dev_id:                Used to differentiate devices that share
1375 *                              the same link layer address
1376 *      @dev_port:              Used to differentiate devices that share
1377 *                              the same function
1378 *      @addr_list_lock:        XXX: need comments on this one
1379 *      @uc:                    unicast mac addresses
1380 *      @mc:                    multicast mac addresses
1381 *      @dev_addrs:             list of device hw addresses
1382 *      @queues_kset:           Group of all Kobjects in the Tx and RX queues
1383 *      @uc_promisc:            Counter, that indicates, that promiscuous mode
1384 *                              has been enabled due to the need to listen to
1385 *                              additional unicast addresses in a device that
1386 *                              does not implement ndo_set_rx_mode()
1387 *      @promiscuity:           Number of times, the NIC is told to work in
1388 *                              Promiscuous mode, if it becomes 0 the NIC will
1389 *                              exit from working in Promiscuous mode
1390 *      @allmulti:              Counter, enables or disables allmulticast mode
1391 *
1392 *      @vlan_info:     VLAN info
1393 *      @dsa_ptr:       dsa specific data
1394 *      @tipc_ptr:      TIPC specific data
1395 *      @atalk_ptr:     AppleTalk link
1396 *      @ip_ptr:        IPv4 specific data
1397 *      @dn_ptr:        DECnet specific data
1398 *      @ip6_ptr:       IPv6 specific data
1399 *      @ax25_ptr:      AX.25 specific data
1400 *      @ieee80211_ptr: IEEE 802.11 specific data, assign before registering
1401 *
1402 *      @last_rx:       Time of last Rx
1403 *      @dev_addr:      Hw address (before bcast,
1404 *                      because most packets are unicast)
1405 *
1406 *      @_rx:                   Array of RX queues
1407 *      @num_rx_queues:         Number of RX queues
1408 *                              allocated at register_netdev() time
1409 *      @real_num_rx_queues:    Number of RX queues currently active in device
1410 *
1411 *      @rx_handler:            handler for received packets
1412 *      @rx_handler_data:       XXX: need comments on this one
1413 *      @ingress_queue:         XXX: need comments on this one
1414 *      @broadcast:             hw bcast address
1415 *
1416 *      @_tx:                   Array of TX queues
1417 *      @num_tx_queues:         Number of TX queues allocated at alloc_netdev_mq() time
1418 *      @real_num_tx_queues:    Number of TX queues currently active in device
1419 *      @qdisc:                 Root qdisc from userspace point of view
1420 *      @tx_queue_len:          Max frames per queue allowed
1421 *      @tx_global_lock:        XXX: need comments on this one
1422 *
1423 *      @xps_maps:      XXX: need comments on this one
1424 *
1425 *      @rx_cpu_rmap:   CPU reverse-mapping for RX completion interrupts,
1426 *                      indexed by RX queue number. Assigned by driver.
1427 *                      This must only be set if the ndo_rx_flow_steer
1428 *                      operation is defined
1429 *
1430 *      @trans_start:           Time (in jiffies) of last Tx
1431 *      @watchdog_timeo:        Represents the timeout that is used by
1432 *                              the watchdog ( see dev_watchdog() )
1433 *      @watchdog_timer:        List of timers
1434 *
1435 *      @pcpu_refcnt:           Number of references to this device
1436 *      @todo_list:             Delayed register/unregister
1437 *      @index_hlist:           Device index hash chain
1438 *      @link_watch_list:       XXX: need comments on this one
1439 *
1440 *      @reg_state:             Register/unregister state machine
1441 *      @dismantle:             Device is going to be freed
1442 *      @rtnl_link_state:       This enum represents the phases of creating
1443 *                              a new link
1444 *
1445 *      @destructor:            Called from unregister,
1446 *                              can be used to call free_netdev
1447 *      @npinfo:                XXX: need comments on this one
1448 *      @nd_net:                Network namespace this network device is inside
1449 *
1450 *      @ml_priv:       Mid-layer private
1451 *      @lstats:        Loopback statistics
1452 *      @tstats:        Tunnel statistics
1453 *      @dstats:        Dummy statistics
1454 *      @vstats:        Virtual ethernet statistics
1455 *
1456 *      @garp_port:     GARP
1457 *      @mrp_port:      MRP
1458 *
1459 *      @dev:           Class/net/name entry
1460 *      @sysfs_groups:  Space for optional device, statistics and wireless
1461 *                      sysfs groups
1462 *
1463 *      @sysfs_rx_queue_group:  Space for optional per-rx queue attributes
1464 *      @rtnl_link_ops: Rtnl_link_ops
1465 *
1466 *      @gso_max_size:  Maximum size of generic segmentation offload
1467 *      @gso_max_segs:  Maximum number of segments that can be passed to the
1468 *                      NIC for GSO
1469 *      @gso_min_segs:  Minimum number of segments that can be passed to the
1470 *                      NIC for GSO
1471 *
1472 *      @dcbnl_ops:     Data Center Bridging netlink ops
1473 *      @num_tc:        Number of traffic classes in the net device
1474 *      @tc_to_txq:     XXX: need comments on this one
1475 *      @prio_tc_map    XXX: need comments on this one
1476 *
1477 *      @fcoe_ddp_xid:  Max exchange id for FCoE LRO by ddp
1478 *
1479 *      @priomap:       XXX: need comments on this one
1480 *      @phydev:        Physical device may attach itself
1481 *                      for hardware timestamping
1482 *
1483 *      @qdisc_tx_busylock:     XXX: need comments on this one
1484 *
1485 *      @group:         The group, that the device belongs to
1486 *      @pm_qos_req:    Power Management QoS object
1487 *
1488 *      FIXME: cleanup struct net_device such that network protocol info
1489 *      moves out.
1490 */
1491
1492struct net_device {
1493        char                    name[IFNAMSIZ];
1494        struct hlist_node       name_hlist;
1495        char                    *ifalias;
1496        /*
1497         *      I/O specific fields
1498         *      FIXME: Merge these and struct ifmap into one
1499         */
1500        unsigned long           mem_end;
1501        unsigned long           mem_start;
1502        unsigned long           base_addr;
1503        int                     irq;
1504
1505        /*
1506         *      Some hardware also needs these fields (state,dev_list,
1507         *      napi_list,unreg_list,close_list) but they are not
1508         *      part of the usual set specified in Space.c.
1509         */
1510
1511        unsigned long           state;
1512
1513        struct list_head        dev_list;
1514        struct list_head        napi_list;
1515        struct list_head        unreg_list;
1516        struct list_head        close_list;
1517
1518        struct {
1519                struct list_head upper;
1520                struct list_head lower;
1521        } adj_list;
1522
1523        struct {
1524                struct list_head upper;
1525                struct list_head lower;
1526        } all_adj_list;
1527
1528        netdev_features_t       features;
1529        netdev_features_t       hw_features;
1530        netdev_features_t       wanted_features;
1531        netdev_features_t       vlan_features;
1532        netdev_features_t       hw_enc_features;
1533        netdev_features_t       mpls_features;
1534
1535        int                     ifindex;
1536        int                     iflink;
1537
1538        struct net_device_stats stats;
1539
1540        atomic_long_t           rx_dropped;
1541        atomic_long_t           tx_dropped;
1542
1543        atomic_t                carrier_changes;
1544
1545#ifdef CONFIG_WIRELESS_EXT
1546        const struct iw_handler_def *   wireless_handlers;
1547        struct iw_public_data * wireless_data;
1548#endif
1549        const struct net_device_ops *netdev_ops;
1550        const struct ethtool_ops *ethtool_ops;
1551        const struct forwarding_accel_ops *fwd_ops;
1552
1553        const struct header_ops *header_ops;
1554
1555        unsigned int            flags;
1556        unsigned int            priv_flags;
1557
1558        unsigned short          gflags;
1559        unsigned short          padded;
1560
1561        unsigned char           operstate;
1562        unsigned char           link_mode;
1563
1564        unsigned char           if_port;
1565        unsigned char           dma;
1566
1567        unsigned int            mtu;
1568        unsigned short          type;
1569        unsigned short          hard_header_len;
1570
1571        unsigned short          needed_headroom;
1572        unsigned short          needed_tailroom;
1573
1574        /* Interface address info. */
1575        unsigned char           perm_addr[MAX_ADDR_LEN];
1576        unsigned char           addr_assign_type;
1577        unsigned char           addr_len;
1578        unsigned short          neigh_priv_len;
1579        unsigned short          dev_id;
1580        unsigned short          dev_port;
1581        spinlock_t              addr_list_lock;
1582        struct netdev_hw_addr_list      uc;
1583        struct netdev_hw_addr_list      mc;
1584        struct netdev_hw_addr_list      dev_addrs;
1585
1586#ifdef CONFIG_SYSFS
1587        struct kset             *queues_kset;
1588#endif
1589
1590        unsigned char           name_assign_type;
1591
1592        bool                    uc_promisc;
1593        unsigned int            promiscuity;
1594        unsigned int            allmulti;
1595
1596
1597        /* Protocol specific pointers */
1598
1599#if IS_ENABLED(CONFIG_VLAN_8021Q)
1600        struct vlan_info __rcu  *vlan_info;
1601#endif
1602#if IS_ENABLED(CONFIG_NET_DSA)
1603        struct dsa_switch_tree  *dsa_ptr;
1604#endif
1605#if IS_ENABLED(CONFIG_TIPC)
1606        struct tipc_bearer __rcu *tipc_ptr;
1607#endif
1608        void                    *atalk_ptr;
1609        struct in_device __rcu  *ip_ptr;
1610        struct dn_dev __rcu     *dn_ptr;
1611        struct inet6_dev __rcu  *ip6_ptr;
1612        void                    *ax25_ptr;
1613        struct wireless_dev     *ieee80211_ptr;
1614        struct wpan_dev         *ieee802154_ptr;
1615
1616/*
1617 * Cache lines mostly used on receive path (including eth_type_trans())
1618 */
1619        unsigned long           last_rx;
1620
1621        /* Interface address info used in eth_type_trans() */
1622        unsigned char           *dev_addr;
1623
1624
1625#ifdef CONFIG_SYSFS
1626        struct netdev_rx_queue  *_rx;
1627
1628        unsigned int            num_rx_queues;
1629        unsigned int            real_num_rx_queues;
1630
1631#endif
1632
1633        unsigned long           gro_flush_timeout;
1634        rx_handler_func_t __rcu *rx_handler;
1635        void __rcu              *rx_handler_data;
1636
1637        struct netdev_queue __rcu *ingress_queue;
1638        unsigned char           broadcast[MAX_ADDR_LEN];
1639
1640
1641/*
1642 * Cache lines mostly used on transmit path
1643 */
1644        struct netdev_queue     *_tx ____cacheline_aligned_in_smp;
1645        unsigned int            num_tx_queues;
1646        unsigned int            real_num_tx_queues;
1647        struct Qdisc            *qdisc;
1648        unsigned long           tx_queue_len;
1649        spinlock_t              tx_global_lock;
1650
1651#ifdef CONFIG_XPS
1652        struct xps_dev_maps __rcu *xps_maps;
1653#endif
1654#ifdef CONFIG_RFS_ACCEL
1655        struct cpu_rmap         *rx_cpu_rmap;
1656#endif
1657
1658        /* These may be needed for future network-power-down code. */
1659
1660        /*
1661         * trans_start here is expensive for high speed devices on SMP,
1662         * please use netdev_queue->trans_start instead.
1663         */
1664        unsigned long           trans_start;
1665
1666        int                     watchdog_timeo;
1667        struct timer_list       watchdog_timer;
1668
1669        int __percpu            *pcpu_refcnt;
1670        struct list_head        todo_list;
1671
1672        struct hlist_node       index_hlist;
1673        struct list_head        link_watch_list;
1674
1675        enum { NETREG_UNINITIALIZED=0,
1676               NETREG_REGISTERED,       /* completed register_netdevice */
1677               NETREG_UNREGISTERING,    /* called unregister_netdevice */
1678               NETREG_UNREGISTERED,     /* completed unregister todo */
1679               NETREG_RELEASED,         /* called free_netdev */
1680               NETREG_DUMMY,            /* dummy device for NAPI poll */
1681        } reg_state:8;
1682
1683        bool dismantle;
1684
1685        enum {
1686                RTNL_LINK_INITIALIZED,
1687                RTNL_LINK_INITIALIZING,
1688        } rtnl_link_state:16;
1689
1690        void (*destructor)(struct net_device *dev);
1691
1692#ifdef CONFIG_NETPOLL
1693        struct netpoll_info __rcu       *npinfo;
1694#endif
1695
1696#ifdef CONFIG_NET_NS
1697        struct net              *nd_net;
1698#endif
1699
1700        /* mid-layer private */
1701        union {
1702                void                                    *ml_priv;
1703                struct pcpu_lstats __percpu             *lstats;
1704                struct pcpu_sw_netstats __percpu        *tstats;
1705                struct pcpu_dstats __percpu             *dstats;
1706                struct pcpu_vstats __percpu             *vstats;
1707        };
1708
1709        struct garp_port __rcu  *garp_port;
1710        struct mrp_port __rcu   *mrp_port;
1711
1712        struct device   dev;
1713        const struct attribute_group *sysfs_groups[4];
1714        const struct attribute_group *sysfs_rx_queue_group;
1715
1716        const struct rtnl_link_ops *rtnl_link_ops;
1717
1718        /* for setting kernel sock attribute on TCP connection setup */
1719#define GSO_MAX_SIZE            65536
1720        unsigned int            gso_max_size;
1721#define GSO_MAX_SEGS            65535
1722        u16                     gso_max_segs;
1723        u16                     gso_min_segs;
1724#ifdef CONFIG_DCB
1725        const struct dcbnl_rtnl_ops *dcbnl_ops;
1726#endif
1727        u8 num_tc;
1728        struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
1729        u8 prio_tc_map[TC_BITMASK + 1];
1730
1731#if IS_ENABLED(CONFIG_FCOE)
1732        unsigned int            fcoe_ddp_xid;
1733#endif
1734#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
1735        struct netprio_map __rcu *priomap;
1736#endif
1737        struct phy_device *phydev;
1738        struct lock_class_key *qdisc_tx_busylock;
1739        int group;
1740        struct pm_qos_request   pm_qos_req;
1741};
1742#define to_net_dev(d) container_of(d, struct net_device, dev)
1743
1744#define NETDEV_ALIGN            32
1745
1746static inline
1747int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
1748{
1749        return dev->prio_tc_map[prio & TC_BITMASK];
1750}
1751
1752static inline
1753int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
1754{
1755        if (tc >= dev->num_tc)
1756                return -EINVAL;
1757
1758        dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
1759        return 0;
1760}
1761
1762static inline
1763void netdev_reset_tc(struct net_device *dev)
1764{
1765        dev->num_tc = 0;
1766        memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
1767        memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
1768}
1769
1770static inline
1771int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
1772{
1773        if (tc >= dev->num_tc)
1774                return -EINVAL;
1775
1776        dev->tc_to_txq[tc].count = count;
1777        dev->tc_to_txq[tc].offset = offset;
1778        return 0;
1779}
1780
1781static inline
1782int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
1783{
1784        if (num_tc > TC_MAX_QUEUE)
1785                return -EINVAL;
1786
1787        dev->num_tc = num_tc;
1788        return 0;
1789}
1790
1791static inline
1792int netdev_get_num_tc(struct net_device *dev)
1793{
1794        return dev->num_tc;
1795}
1796
1797static inline
1798struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
1799                                         unsigned int index)
1800{
1801        return &dev->_tx[index];
1802}
1803
1804static inline struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
1805                                                    const struct sk_buff *skb)
1806{
1807        return netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
1808}
1809
1810static inline void netdev_for_each_tx_queue(struct net_device *dev,
1811                                            void (*f)(struct net_device *,
1812                                                      struct netdev_queue *,
1813                                                      void *),
1814                                            void *arg)
1815{
1816        unsigned int i;
1817
1818        for (i = 0; i < dev->num_tx_queues; i++)
1819                f(dev, &dev->_tx[i], arg);
1820}
1821
1822struct netdev_queue *netdev_pick_tx(struct net_device *dev,
1823                                    struct sk_buff *skb,
1824                                    void *accel_priv);
1825
1826/*
1827 * Net namespace inlines
1828 */
1829static inline
1830struct net *dev_net(const struct net_device *dev)
1831{
1832        return read_pnet(&dev->nd_net);
1833}
1834
1835static inline
1836void dev_net_set(struct net_device *dev, struct net *net)
1837{
1838#ifdef CONFIG_NET_NS
1839        release_net(dev->nd_net);
1840        dev->nd_net = hold_net(net);
1841#endif
1842}
1843
1844static inline bool netdev_uses_dsa(struct net_device *dev)
1845{
1846#if IS_ENABLED(CONFIG_NET_DSA)
1847        if (dev->dsa_ptr != NULL)
1848                return dsa_uses_tagged_protocol(dev->dsa_ptr);
1849#endif
1850        return false;
1851}
1852
1853/**
1854 *      netdev_priv - access network device private data
1855 *      @dev: network device
1856 *
1857 * Get network device private data
1858 */
1859static inline void *netdev_priv(const struct net_device *dev)
1860{
1861        return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
1862}
1863
1864/* Set the sysfs physical device reference for the network logical device
1865 * if set prior to registration will cause a symlink during initialization.
1866 */
1867#define SET_NETDEV_DEV(net, pdev)       ((net)->dev.parent = (pdev))
1868
1869/* Set the sysfs device type for the network logical device to allow
1870 * fine-grained identification of different network device types. For
1871 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
1872 */
1873#define SET_NETDEV_DEVTYPE(net, devtype)        ((net)->dev.type = (devtype))
1874
1875/* Default NAPI poll() weight
1876 * Device drivers are strongly advised to not use bigger value
1877 */
1878#define NAPI_POLL_WEIGHT 64
1879
1880/**
1881 *      netif_napi_add - initialize a napi context
1882 *      @dev:  network device
1883 *      @napi: napi context
1884 *      @poll: polling function
1885 *      @weight: default weight
1886 *
1887 * netif_napi_add() must be used to initialize a napi context prior to calling
1888 * *any* of the other napi related functions.
1889 */
1890void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
1891                    int (*poll)(struct napi_struct *, int), int weight);
1892
1893/**
1894 *  netif_napi_del - remove a napi context
1895 *  @napi: napi context
1896 *
1897 *  netif_napi_del() removes a napi context from the network device napi list
1898 */
1899void netif_napi_del(struct napi_struct *napi);
1900
1901struct napi_gro_cb {
1902        /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
1903        void *frag0;
1904
1905        /* Length of frag0. */
1906        unsigned int frag0_len;
1907
1908        /* This indicates where we are processing relative to skb->data. */
1909        int data_offset;
1910
1911        /* This is non-zero if the packet cannot be merged with the new skb. */
1912        u16     flush;
1913
1914        /* Save the IP ID here and check when we get to the transport layer */
1915        u16     flush_id;
1916
1917        /* Number of segments aggregated. */
1918        u16     count;
1919
1920        /* This is non-zero if the packet may be of the same flow. */
1921        u8      same_flow;
1922
1923        /* Free the skb? */
1924        u8      free;
1925#define NAPI_GRO_FREE             1
1926#define NAPI_GRO_FREE_STOLEN_HEAD 2
1927
1928        /* jiffies when first packet was created/queued */
1929        unsigned long age;
1930
1931        /* Used in ipv6_gro_receive() and foo-over-udp */
1932        u16     proto;
1933
1934        /* Used in udp_gro_receive */
1935        u8      udp_mark:1;
1936
1937        /* GRO checksum is valid */
1938        u8      csum_valid:1;
1939
1940        /* Number of checksums via CHECKSUM_UNNECESSARY */
1941        u8      csum_cnt:3;
1942
1943        /* Used in foo-over-udp, set in udp[46]_gro_receive */
1944        u8      is_ipv6:1;
1945
1946        /* used to support CHECKSUM_COMPLETE for tunneling protocols */
1947        __wsum  csum;
1948
1949        /* used in skb_gro_receive() slow path */
1950        struct sk_buff *last;
1951};
1952
1953#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
1954
1955struct packet_type {
1956        __be16                  type;   /* This is really htons(ether_type). */
1957        struct net_device       *dev;   /* NULL is wildcarded here           */
1958        int                     (*func) (struct sk_buff *,
1959                                         struct net_device *,
1960                                         struct packet_type *,
1961                                         struct net_device *);
1962        bool                    (*id_match)(struct packet_type *ptype,
1963                                            struct sock *sk);
1964        void                    *af_packet_priv;
1965        struct list_head        list;
1966};
1967
1968struct offload_callbacks {
1969        struct sk_buff          *(*gso_segment)(struct sk_buff *skb,
1970                                                netdev_features_t features);
1971        struct sk_buff          **(*gro_receive)(struct sk_buff **head,
1972                                               struct sk_buff *skb);
1973        int                     (*gro_complete)(struct sk_buff *skb, int nhoff);
1974};
1975
1976struct packet_offload {
1977        __be16                   type;  /* This is really htons(ether_type). */
1978        struct offload_callbacks callbacks;
1979        struct list_head         list;
1980};
1981
1982struct udp_offload {
1983        __be16                   port;
1984        u8                       ipproto;
1985        struct offload_callbacks callbacks;
1986};
1987
1988/* often modified stats are per cpu, other are shared (netdev->stats) */
1989struct pcpu_sw_netstats {
1990        u64     rx_packets;
1991        u64     rx_bytes;
1992        u64     tx_packets;
1993        u64     tx_bytes;
1994        struct u64_stats_sync   syncp;
1995};
1996
1997#define netdev_alloc_pcpu_stats(type)                           \
1998({                                                              \
1999        typeof(type) __percpu *pcpu_stats = alloc_percpu(type); \
2000        if (pcpu_stats) {                                       \
2001                int i;                                          \
2002                for_each_possible_cpu(i) {                      \
2003                        typeof(type) *stat;                     \
2004                        stat = per_cpu_ptr(pcpu_stats, i);      \
2005                        u64_stats_init(&stat->syncp);           \
2006                }                                               \
2007        }                                                       \
2008        pcpu_stats;                                             \
2009})
2010
2011#include <linux/notifier.h>
2012
2013/* netdevice notifier chain. Please remember to update the rtnetlink
2014 * notification exclusion list in rtnetlink_event() when adding new
2015 * types.
2016 */
2017#define NETDEV_UP       0x0001  /* For now you can't veto a device up/down */
2018#define NETDEV_DOWN     0x0002
2019#define NETDEV_REBOOT   0x0003  /* Tell a protocol stack a network interface
2020                                   detected a hardware crash and restarted
2021                                   - we can use this eg to kick tcp sessions
2022                                   once done */
2023#define NETDEV_CHANGE   0x0004  /* Notify device state change */
2024#define NETDEV_REGISTER 0x0005
2025#define NETDEV_UNREGISTER       0x0006
2026#define NETDEV_CHANGEMTU        0x0007 /* notify after mtu change happened */
2027#define NETDEV_CHANGEADDR       0x0008
2028#define NETDEV_GOING_DOWN       0x0009
2029#define NETDEV_CHANGENAME       0x000A
2030#define NETDEV_FEAT_CHANGE      0x000B
2031#define NETDEV_BONDING_FAILOVER 0x000C
2032#define NETDEV_PRE_UP           0x000D
2033#define NETDEV_PRE_TYPE_CHANGE  0x000E
2034#define NETDEV_POST_TYPE_CHANGE 0x000F
2035#define NETDEV_POST_INIT        0x0010
2036#define NETDEV_UNREGISTER_FINAL 0x0011
2037#define NETDEV_RELEASE          0x0012
2038#define NETDEV_NOTIFY_PEERS     0x0013
2039#define NETDEV_JOIN             0x0014
2040#define NETDEV_CHANGEUPPER      0x0015
2041#define NETDEV_RESEND_IGMP      0x0016
2042#define NETDEV_PRECHANGEMTU     0x0017 /* notify before mtu change happened */
2043#define NETDEV_CHANGEINFODATA   0x0018
2044
2045int register_netdevice_notifier(struct notifier_block *nb);
2046int unregister_netdevice_notifier(struct notifier_block *nb);
2047
2048struct netdev_notifier_info {
2049        struct net_device *dev;
2050};
2051
2052struct netdev_notifier_change_info {
2053        struct netdev_notifier_info info; /* must be first */
2054        unsigned int flags_changed;
2055};
2056
2057static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
2058                                             struct net_device *dev)
2059{
2060        info->dev = dev;
2061}
2062
2063static inline struct net_device *
2064netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
2065{
2066        return info->dev;
2067}
2068
2069int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
2070
2071
2072extern rwlock_t                         dev_base_lock;          /* Device list lock */
2073
2074#define for_each_netdev(net, d)         \
2075                list_for_each_entry(d, &(net)->dev_base_head, dev_list)
2076#define for_each_netdev_reverse(net, d) \
2077                list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
2078#define for_each_netdev_rcu(net, d)             \
2079                list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
2080#define for_each_netdev_safe(net, d, n) \
2081                list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
2082#define for_each_netdev_continue(net, d)                \
2083                list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
2084#define for_each_netdev_continue_rcu(net, d)            \
2085        list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
2086#define for_each_netdev_in_bond_rcu(bond, slave)        \
2087                for_each_netdev_rcu(&init_net, slave)   \
2088                        if (netdev_master_upper_dev_get_rcu(slave) == (bond))
2089#define net_device_entry(lh)    list_entry(lh, struct net_device, dev_list)
2090
2091static inline struct net_device *next_net_device(struct net_device *dev)
2092{
2093        struct list_head *lh;
2094        struct net *net;
2095
2096        net = dev_net(dev);
2097        lh = dev->dev_list.next;
2098        return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2099}
2100
2101static inline struct net_device *next_net_device_rcu(struct net_device *dev)
2102{
2103        struct list_head *lh;
2104        struct net *net;
2105
2106        net = dev_net(dev);
2107        lh = rcu_dereference(list_next_rcu(&dev->dev_list));
2108        return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2109}
2110
2111static inline struct net_device *first_net_device(struct net *net)
2112{
2113        return list_empty(&net->dev_base_head) ? NULL :
2114                net_device_entry(net->dev_base_head.next);
2115}
2116
2117static inline struct net_device *first_net_device_rcu(struct net *net)
2118{
2119        struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
2120
2121        return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2122}
2123
2124int netdev_boot_setup_check(struct net_device *dev);
2125unsigned long netdev_boot_base(const char *prefix, int unit);
2126struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
2127                                       const char *hwaddr);
2128struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
2129struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
2130void dev_add_pack(struct packet_type *pt);
2131void dev_remove_pack(struct packet_type *pt);
2132void __dev_remove_pack(struct packet_type *pt);
2133void dev_add_offload(struct packet_offload *po);
2134void dev_remove_offload(struct packet_offload *po);
2135
2136struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
2137                                      unsigned short mask);
2138struct net_device *dev_get_by_name(struct net *net, const char *name);
2139struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
2140struct net_device *__dev_get_by_name(struct net *net, const char *name);
2141int dev_alloc_name(struct net_device *dev, const char *name);
2142int dev_open(struct net_device *dev);
2143int dev_close(struct net_device *dev);
2144void dev_disable_lro(struct net_device *dev);
2145int dev_loopback_xmit(struct sk_buff *newskb);
2146int dev_queue_xmit(struct sk_buff *skb);
2147int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv);
2148int register_netdevice(struct net_device *dev);
2149void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
2150void unregister_netdevice_many(struct list_head *head);
2151static inline void unregister_netdevice(struct net_device *dev)
2152{
2153        unregister_netdevice_queue(dev, NULL);
2154}
2155
2156int netdev_refcnt_read(const struct net_device *dev);
2157void free_netdev(struct net_device *dev);
2158void netdev_freemem(struct net_device *dev);
2159void synchronize_net(void);
2160int init_dummy_netdev(struct net_device *dev);
2161
2162struct net_device *dev_get_by_index(struct net *net, int ifindex);
2163struct net_device *__dev_get_by_index(struct net *net, int ifindex);
2164struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
2165int netdev_get_name(struct net *net, char *name, int ifindex);
2166int dev_restart(struct net_device *dev);
2167int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb);
2168
2169static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
2170{
2171        return NAPI_GRO_CB(skb)->data_offset;
2172}
2173
2174static inline unsigned int skb_gro_len(const struct sk_buff *skb)
2175{
2176        return skb->len - NAPI_GRO_CB(skb)->data_offset;
2177}
2178
2179static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
2180{
2181        NAPI_GRO_CB(skb)->data_offset += len;
2182}
2183
2184static inline void *skb_gro_header_fast(struct sk_buff *skb,
2185                                        unsigned int offset)
2186{
2187        return NAPI_GRO_CB(skb)->frag0 + offset;
2188}
2189
2190static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
2191{
2192        return NAPI_GRO_CB(skb)->frag0_len < hlen;
2193}
2194
2195static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
2196                                        unsigned int offset)
2197{
2198        if (!pskb_may_pull(skb, hlen))
2199                return NULL;
2200
2201        NAPI_GRO_CB(skb)->frag0 = NULL;
2202        NAPI_GRO_CB(skb)->frag0_len = 0;
2203        return skb->data + offset;
2204}
2205
2206static inline void *skb_gro_network_header(struct sk_buff *skb)
2207{
2208        return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
2209               skb_network_offset(skb);
2210}
2211
2212static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
2213                                        const void *start, unsigned int len)
2214{
2215        if (NAPI_GRO_CB(skb)->csum_valid)
2216                NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
2217                                                  csum_partial(start, len, 0));
2218}
2219
2220/* GRO checksum functions. These are logical equivalents of the normal
2221 * checksum functions (in skbuff.h) except that they operate on the GRO
2222 * offsets and fields in sk_buff.
2223 */
2224
2225__sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
2226
2227static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
2228                                                      bool zero_okay,
2229                                                      __sum16 check)
2230{
2231        return (skb->ip_summed != CHECKSUM_PARTIAL &&
2232                NAPI_GRO_CB(skb)->csum_cnt == 0 &&
2233                (!zero_okay || check));
2234}
2235
2236static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
2237                                                           __wsum psum)
2238{
2239        if (NAPI_GRO_CB(skb)->csum_valid &&
2240            !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
2241                return 0;
2242
2243        NAPI_GRO_CB(skb)->csum = psum;
2244
2245        return __skb_gro_checksum_complete(skb);
2246}
2247
2248static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
2249{
2250        if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
2251                /* Consume a checksum from CHECKSUM_UNNECESSARY */
2252                NAPI_GRO_CB(skb)->csum_cnt--;
2253        } else {
2254                /* Update skb for CHECKSUM_UNNECESSARY and csum_level when we
2255                 * verified a new top level checksum or an encapsulated one
2256                 * during GRO. This saves work if we fallback to normal path.
2257                 */
2258                __skb_incr_checksum_unnecessary(skb);
2259        }
2260}
2261
2262#define __skb_gro_checksum_validate(skb, proto, zero_okay, check,       \
2263                                    compute_pseudo)                     \
2264({                                                                      \
2265        __sum16 __ret = 0;                                              \
2266        if (__skb_gro_checksum_validate_needed(skb, zero_okay, check))  \
2267                __ret = __skb_gro_checksum_validate_complete(skb,       \
2268                                compute_pseudo(skb, proto));            \
2269        if (__ret)                                                      \
2270                __skb_mark_checksum_bad(skb);                           \
2271        else                                                            \
2272                skb_gro_incr_csum_unnecessary(skb);                     \
2273        __ret;                                                          \
2274})
2275
2276#define skb_gro_checksum_validate(skb, proto, compute_pseudo)           \
2277        __skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)
2278
2279#define skb_gro_checksum_validate_zero_check(skb, proto, check,         \
2280                                             compute_pseudo)            \
2281        __skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)
2282
2283#define skb_gro_checksum_simple_validate(skb)                           \
2284        __skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)
2285
2286static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
2287{
2288        return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
2289                !NAPI_GRO_CB(skb)->csum_valid);
2290}
2291
2292static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
2293                                              __sum16 check, __wsum pseudo)
2294{
2295        NAPI_GRO_CB(skb)->csum = ~pseudo;
2296        NAPI_GRO_CB(skb)->csum_valid = 1;
2297}
2298
2299#define skb_gro_checksum_try_convert(skb, proto, check, compute_pseudo) \
2300do {                                                                    \
2301        if (__skb_gro_checksum_convert_check(skb))                      \
2302                __skb_gro_checksum_convert(skb, check,                  \
2303                                           compute_pseudo(skb, proto)); \
2304} while (0)
2305
2306static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
2307                                  unsigned short type,
2308                                  const void *daddr, const void *saddr,
2309                                  unsigned int len)
2310{
2311        if (!dev->header_ops || !dev->header_ops->create)
2312                return 0;
2313
2314        return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
2315}
2316
2317static inline int dev_parse_header(const struct sk_buff *skb,
2318                                   unsigned char *haddr)
2319{
2320        const struct net_device *dev = skb->dev;
2321
2322        if (!dev->header_ops || !dev->header_ops->parse)
2323                return 0;
2324        return dev->header_ops->parse(skb, haddr);
2325}
2326
2327static inline int dev_rebuild_header(struct sk_buff *skb)
2328{
2329        const struct net_device *dev = skb->dev;
2330
2331        if (!dev->header_ops || !dev->header_ops->rebuild)
2332                return 0;
2333        return dev->header_ops->rebuild(skb);
2334}
2335
2336typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
2337int register_gifconf(unsigned int family, gifconf_func_t *gifconf);
2338static inline int unregister_gifconf(unsigned int family)
2339{
2340        return register_gifconf(family, NULL);
2341}
2342
2343#ifdef CONFIG_NET_FLOW_LIMIT
2344#define FLOW_LIMIT_HISTORY      (1 << 7)  /* must be ^2 and !overflow buckets */
2345struct sd_flow_limit {
2346        u64                     count;
2347        unsigned int            num_buckets;
2348        unsigned int            history_head;
2349        u16                     history[FLOW_LIMIT_HISTORY];
2350        u8                      buckets[];
2351};
2352
2353extern int netdev_flow_limit_table_len;
2354#endif /* CONFIG_NET_FLOW_LIMIT */
2355
2356/*
2357 * Incoming packets are placed on per-cpu queues
2358 */
2359struct softnet_data {
2360        struct list_head        poll_list;
2361        struct sk_buff_head     process_queue;
2362
2363        /* stats */
2364        unsigned int            processed;
2365        unsigned int            time_squeeze;
2366        unsigned int            cpu_collision;
2367        unsigned int            received_rps;
2368#ifdef CONFIG_RPS
2369        struct softnet_data     *rps_ipi_list;
2370#endif
2371#ifdef CONFIG_NET_FLOW_LIMIT
2372        struct sd_flow_limit __rcu *flow_limit;
2373#endif
2374        struct Qdisc            *output_queue;
2375        struct Qdisc            **output_queue_tailp;
2376        struct sk_buff          *completion_queue;
2377
2378#ifdef CONFIG_RPS
2379        /* Elements below can be accessed between CPUs for RPS */
2380        struct call_single_data csd ____cacheline_aligned_in_smp;
2381        struct softnet_data     *rps_ipi_next;
2382        unsigned int            cpu;
2383        unsigned int            input_queue_head;
2384        unsigned int            input_queue_tail;
2385#endif
2386        unsigned int            dropped;
2387        struct sk_buff_head     input_pkt_queue;
2388        struct napi_struct      backlog;
2389
2390};
2391
2392static inline void input_queue_head_incr(struct softnet_data *sd)
2393{
2394#ifdef CONFIG_RPS
2395        sd->input_queue_head++;
2396#endif
2397}
2398
2399static inline void input_queue_tail_incr_save(struct softnet_data *sd,
2400                                              unsigned int *qtail)
2401{
2402#ifdef CONFIG_RPS
2403        *qtail = ++sd->input_queue_tail;
2404#endif
2405}
2406
2407DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
2408
2409void __netif_schedule(struct Qdisc *q);
2410void netif_schedule_queue(struct netdev_queue *txq);
2411
2412static inline void netif_tx_schedule_all(struct net_device *dev)
2413{
2414        unsigned int i;
2415
2416        for (i = 0; i < dev->num_tx_queues; i++)
2417                netif_schedule_queue(netdev_get_tx_queue(dev, i));
2418}
2419
2420static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
2421{
2422        clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
2423}
2424
2425/**
2426 *      netif_start_queue - allow transmit
2427 *      @dev: network device
2428 *
2429 *      Allow upper layers to call the device hard_start_xmit routine.
2430 */
2431static inline void netif_start_queue(struct net_device *dev)
2432{
2433        netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
2434}
2435
2436static inline void netif_tx_start_all_queues(struct net_device *dev)
2437{
2438        unsigned int i;
2439
2440        for (i = 0; i < dev->num_tx_queues; i++) {
2441                struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2442                netif_tx_start_queue(txq);
2443        }
2444}
2445
2446void netif_tx_wake_queue(struct netdev_queue *dev_queue);
2447
2448/**
2449 *      netif_wake_queue - restart transmit
2450 *      @dev: network device
2451 *
2452 *      Allow upper layers to call the device hard_start_xmit routine.
2453 *      Used for flow control when transmit resources are available.
2454 */
2455static inline void netif_wake_queue(struct net_device *dev)
2456{
2457        netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
2458}
2459
2460static inline void netif_tx_wake_all_queues(struct net_device *dev)
2461{
2462        unsigned int i;
2463
2464        for (i = 0; i < dev->num_tx_queues; i++) {
2465                struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2466                netif_tx_wake_queue(txq);
2467        }
2468}
2469
2470static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
2471{
2472        if (WARN_ON(!dev_queue)) {
2473                pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
2474                return;
2475        }
2476        set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
2477}
2478
2479/**
2480 *      netif_stop_queue - stop transmitted packets
2481 *      @dev: network device
2482 *
2483 *      Stop upper layers calling the device hard_start_xmit routine.
2484 *      Used for flow control when transmit resources are unavailable.
2485 */
2486static inline void netif_stop_queue(struct net_device *dev)
2487{
2488        netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
2489}
2490
2491static inline void netif_tx_stop_all_queues(struct net_device *dev)
2492{
2493        unsigned int i;
2494
2495        for (i = 0; i < dev->num_tx_queues; i++) {
2496                struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2497                netif_tx_stop_queue(txq);
2498        }
2499}
2500
2501static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
2502{
2503        return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
2504}
2505
2506/**
2507 *      netif_queue_stopped - test if transmit queue is flowblocked
2508 *      @dev: network device
2509 *
2510 *      Test if transmit queue on device is currently unable to send.
2511 */
2512static inline bool netif_queue_stopped(const struct net_device *dev)
2513{
2514        return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
2515}
2516
2517static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
2518{
2519        return dev_queue->state & QUEUE_STATE_ANY_XOFF;
2520}
2521
2522static inline bool
2523netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
2524{
2525        return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
2526}
2527
2528static inline bool
2529netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
2530{
2531        return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
2532}
2533
2534/**
2535 *      netdev_txq_bql_enqueue_prefetchw - prefetch bql data for write
2536 *      @dev_queue: pointer to transmit queue
2537 *
2538 * BQL enabled drivers might use this helper in their ndo_start_xmit(),
2539 * to give appropriate hint to the cpu.
2540 */
2541static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
2542{
2543#ifdef CONFIG_BQL
2544        prefetchw(&dev_queue->dql.num_queued);
2545#endif
2546}
2547
2548/**
2549 *      netdev_txq_bql_complete_prefetchw - prefetch bql data for write
2550 *      @dev_queue: pointer to transmit queue
2551 *
2552 * BQL enabled drivers might use this helper in their TX completion path,
2553 * to give appropriate hint to the cpu.
2554 */
2555static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
2556{
2557#ifdef CONFIG_BQL
2558        prefetchw(&dev_queue->dql.limit);
2559#endif
2560}
2561
2562static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
2563                                        unsigned int bytes)
2564{
2565#ifdef CONFIG_BQL
2566        dql_queued(&dev_queue->dql, bytes);
2567
2568        if (likely(dql_avail(&dev_queue->dql) >= 0))
2569                return;
2570
2571        set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
2572
2573        /*
2574         * The XOFF flag must be set before checking the dql_avail below,
2575         * because in netdev_tx_completed_queue we update the dql_completed
2576         * before checking the XOFF flag.
2577         */
2578        smp_mb();
2579
2580        /* check again in case another CPU has just made room avail */
2581        if (unlikely(dql_avail(&dev_queue->dql) >= 0))
2582                clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
2583#endif
2584}
2585
2586/**
2587 *      netdev_sent_queue - report the number of bytes queued to hardware
2588 *      @dev: network device
2589 *      @bytes: number of bytes queued to the hardware device queue
2590 *
2591 *      Report the number of bytes queued for sending/completion to the network
2592 *      device hardware queue. @bytes should be a good approximation and should
2593 *      exactly match netdev_completed_queue() @bytes
2594 */
2595static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
2596{
2597        netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes);
2598}
2599
2600static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
2601                                             unsigned int pkts, unsigned int bytes)
2602{
2603#ifdef CONFIG_BQL
2604        if (unlikely(!bytes))
2605                return;
2606
2607        dql_completed(&dev_queue->dql, bytes);
2608
2609        /*
2610         * Without the memory barrier there is a small possiblity that
2611         * netdev_tx_sent_queue will miss the update and cause the queue to
2612         * be stopped forever
2613         */
2614        smp_mb();
2615
2616        if (dql_avail(&dev_queue->dql) < 0)
2617                return;
2618
2619        if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
2620                netif_schedule_queue(dev_queue);
2621#endif
2622}
2623
2624/**
2625 *      netdev_completed_queue - report bytes and packets completed by device
2626 *      @dev: network device
2627 *      @pkts: actual number of packets sent over the medium
2628 *      @bytes: actual number of bytes sent over the medium
2629 *
2630 *      Report the number of bytes and packets transmitted by the network device
2631 *      hardware queue over the physical medium, @bytes must exactly match the
2632 *      @bytes amount passed to netdev_sent_queue()
2633 */
2634static inline void netdev_completed_queue(struct net_device *dev,
2635                                          unsigned int pkts, unsigned int bytes)
2636{
2637        netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes);
2638}
2639
2640static inline void netdev_tx_reset_queue(struct netdev_queue *q)
2641{
2642#ifdef CONFIG_BQL
2643        clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
2644        dql_reset(&q->dql);
2645#endif
2646}
2647
2648/**
2649 *      netdev_reset_queue - reset the packets and bytes count of a network device
2650 *      @dev_queue: network device
2651 *
2652 *      Reset the bytes and packet count of a network device and clear the
2653 *      software flow control OFF bit for this network device
2654 */
2655static inline void netdev_reset_queue(struct net_device *dev_queue)
2656{
2657        netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0));
2658}
2659
2660/**
2661 *      netdev_cap_txqueue - check if selected tx queue exceeds device queues
2662 *      @dev: network device
2663 *      @queue_index: given tx queue index
2664 *
2665 *      Returns 0 if given tx queue index >= number of device tx queues,
2666 *      otherwise returns the originally passed tx queue index.
2667 */
2668static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
2669{
2670        if (unlikely(queue_index >= dev->real_num_tx_queues)) {
2671                net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
2672                                     dev->name, queue_index,
2673                                     dev->real_num_tx_queues);
2674                return 0;
2675        }
2676
2677        return queue_index;
2678}
2679
2680/**
2681 *      netif_running - test if up
2682 *      @dev: network device
2683 *
2684 *      Test if the device has been brought up.
2685 */
2686static inline bool netif_running(const struct net_device *dev)
2687{
2688        return test_bit(__LINK_STATE_START, &dev->state);
2689}
2690
2691/*
2692 * Routines to manage the subqueues on a device.  We only need start
2693 * stop, and a check if it's stopped.  All other device management is
2694 * done at the overall netdevice level.
2695 * Also test the device if we're multiqueue.
2696 */
2697
2698/**
2699 *      netif_start_subqueue - allow sending packets on subqueue
2700 *      @dev: network device
2701 *      @queue_index: sub queue index
2702 *
2703 * Start individual transmit queue of a device with multiple transmit queues.
2704 */
2705static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
2706{
2707        struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
2708
2709        netif_tx_start_queue(txq);
2710}
2711
2712/**
2713 *      netif_stop_subqueue - stop sending packets on subqueue
2714 *      @dev: network device
2715 *      @queue_index: sub queue index
2716 *
2717 * Stop individual transmit queue of a device with multiple transmit queues.
2718 */
2719static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
2720{
2721        struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
2722        netif_tx_stop_queue(txq);
2723}
2724
2725/**
2726 *      netif_subqueue_stopped - test status of subqueue
2727 *      @dev: network device
2728 *      @queue_index: sub queue index
2729 *
2730 * Check individual transmit queue of a device with multiple transmit queues.
2731 */
2732static inline bool __netif_subqueue_stopped(const struct net_device *dev,
2733                                            u16 queue_index)
2734{
2735        struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
2736
2737        return netif_tx_queue_stopped(txq);
2738}
2739
2740static inline bool netif_subqueue_stopped(const struct net_device *dev,
2741                                          struct sk_buff *skb)
2742{
2743        return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
2744}
2745
2746void netif_wake_subqueue(struct net_device *dev, u16 queue_index);
2747
2748#ifdef CONFIG_XPS
2749int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
2750                        u16 index);
2751#else
2752static inline int netif_set_xps_queue(struct net_device *dev,
2753                                      const struct cpumask *mask,
2754                                      u16 index)
2755{
2756        return 0;
2757}
2758#endif
2759
2760/*
2761 * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
2762 * as a distribution range limit for the returned value.
2763 */
2764static inline u16 skb_tx_hash(const struct net_device *dev,
2765                              struct sk_buff *skb)
2766{
2767        return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
2768}
2769
2770/**
2771 *      netif_is_multiqueue - test if device has multiple transmit queues
2772 *      @dev: network device
2773 *
2774 * Check if device has multiple transmit queues
2775 */
2776static inline bool netif_is_multiqueue(const struct net_device *dev)
2777{
2778        return dev->num_tx_queues > 1;
2779}
2780
2781int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
2782
2783#ifdef CONFIG_SYSFS
2784int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq);
2785#else
2786static inline int netif_set_real_num_rx_queues(struct net_device *dev,
2787                                                unsigned int rxq)
2788{
2789        return 0;
2790}
2791#endif
2792
2793#ifdef CONFIG_SYSFS
2794static inline unsigned int get_netdev_rx_queue_index(
2795                struct netdev_rx_queue *queue)
2796{
2797        struct net_device *dev = queue->dev;
2798        int index = queue - dev->_rx;
2799
2800        BUG_ON(index >= dev->num_rx_queues);
2801        return index;
2802}
2803#endif
2804
2805#define DEFAULT_MAX_NUM_RSS_QUEUES      (8)
2806int netif_get_num_default_rss_queues(void);
2807
2808enum skb_free_reason {
2809        SKB_REASON_CONSUMED,
2810        SKB_REASON_DROPPED,
2811};
2812
2813void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason);
2814void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason);
2815
2816/*
2817 * It is not allowed to call kfree_skb() or consume_skb() from hardware
2818 * interrupt context or with hardware interrupts being disabled.
2819 * (in_irq() || irqs_disabled())
2820 *
2821 * We provide four helpers that can be used in following contexts :
2822 *
2823 * dev_kfree_skb_irq(skb) when caller drops a packet from irq context,
2824 *  replacing kfree_skb(skb)
2825 *
2826 * dev_consume_skb_irq(skb) when caller consumes a packet from irq context.
2827 *  Typically used in place of consume_skb(skb) in TX completion path
2828 *
2829 * dev_kfree_skb_any(skb) when caller doesn't know its current irq context,
2830 *  replacing kfree_skb(skb)
2831 *
2832 * dev_consume_skb_any(skb) when caller doesn't know its current irq context,
2833 *  and consumed a packet. Used in place of consume_skb(skb)
2834 */
2835static inline void dev_kfree_skb_irq(struct sk_buff *skb)
2836{
2837        __dev_kfree_skb_irq(skb, SKB_REASON_DROPPED);
2838}
2839
2840static inline void dev_consume_skb_irq(struct sk_buff *skb)
2841{
2842        __dev_kfree_skb_irq(skb, SKB_REASON_CONSUMED);
2843}
2844
2845static inline void dev_kfree_skb_any(struct sk_buff *skb)
2846{
2847        __dev_kfree_skb_any(skb, SKB_REASON_DROPPED);
2848}
2849
2850static inline void dev_consume_skb_any(struct sk_buff *skb)
2851{
2852        __dev_kfree_skb_any(skb, SKB_REASON_CONSUMED);
2853}
2854
2855int netif_rx(struct sk_buff *skb);
2856int netif_rx_ni(struct sk_buff *skb);
2857int netif_receive_skb(struct sk_buff *skb);
2858gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
2859void napi_gro_flush(struct napi_struct *napi, bool flush_old);
2860struct sk_buff *napi_get_frags(struct napi_struct *napi);
2861gro_result_t napi_gro_frags(struct napi_struct *napi);
2862struct packet_offload *gro_find_receive_by_type(__be16 type);
2863struct packet_offload *gro_find_complete_by_type(__be16 type);
2864
2865static inline void napi_free_frags(struct napi_struct *napi)
2866{
2867        kfree_skb(napi->skb);
2868        napi->skb = NULL;
2869}
2870
2871int netdev_rx_handler_register(struct net_device *dev,
2872                               rx_handler_func_t *rx_handler,
2873                               void *rx_handler_data);
2874void netdev_rx_handler_unregister(struct net_device *dev);
2875
2876bool dev_valid_name(const char *name);
2877int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
2878int dev_ethtool(struct net *net, struct ifreq *);
2879unsigned int dev_get_flags(const struct net_device *);
2880int __dev_change_flags(struct net_device *, unsigned int flags);
2881int dev_change_flags(struct net_device *, unsigned int);
2882void __dev_notify_flags(struct net_device *, unsigned int old_flags,
2883                        unsigned int gchanges);
2884int dev_change_name(struct net_device *, const char *);
2885int dev_set_alias(struct net_device *, const char *, size_t);
2886int dev_change_net_namespace(struct net_device *, struct net *, const char *);
2887int dev_set_mtu(struct net_device *, int);
2888void dev_set_group(struct net_device *, int);
2889int dev_set_mac_address(struct net_device *, struct sockaddr *);
2890int dev_change_carrier(struct net_device *, bool new_carrier);
2891int dev_get_phys_port_id(struct net_device *dev,
2892                         struct netdev_phys_item_id *ppid);
2893struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev);
2894struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
2895                                    struct netdev_queue *txq, int *ret);
2896int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
2897int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
2898bool is_skb_forwardable(struct net_device *dev, struct sk_buff *skb);
2899
2900extern int              netdev_budget;
2901
2902/* Called by rtnetlink.c:rtnl_unlock() */
2903void netdev_run_todo(void);
2904
2905/**
2906 *      dev_put - release reference to device
2907 *      @dev: network device
2908 *
2909 * Release reference to device to allow it to be freed.
2910 */
2911static inline void dev_put(struct net_device *dev)
2912{
2913        this_cpu_dec(*dev->pcpu_refcnt);
2914}
2915
2916/**
2917 *      dev_hold - get reference to device
2918 *      @dev: network device
2919 *
2920 * Hold reference to device to keep it from being freed.
2921 */
2922static inline void dev_hold(struct net_device *dev)
2923{
2924        this_cpu_inc(*dev->pcpu_refcnt);
2925}
2926
2927/* Carrier loss detection, dial on demand. The functions netif_carrier_on
2928 * and _off may be called from IRQ context, but it is caller
2929 * who is responsible for serialization of these calls.
2930 *
2931 * The name carrier is inappropriate, these functions should really be
2932 * called netif_lowerlayer_*() because they represent the state of any
2933 * kind of lower layer not just hardware media.
2934 */
2935
2936void linkwatch_init_dev(struct net_device *dev);
2937void linkwatch_fire_event(struct net_device *dev);
2938void linkwatch_forget_dev(struct net_device *dev);
2939
2940/**
2941 *      netif_carrier_ok - test if carrier present
2942 *      @dev: network device
2943 *
2944 * Check if carrier is present on device
2945 */
2946static inline bool netif_carrier_ok(const struct net_device *dev)
2947{
2948        return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
2949}
2950
2951unsigned long dev_trans_start(struct net_device *dev);
2952
2953void __netdev_watchdog_up(struct net_device *dev);
2954
2955void netif_carrier_on(struct net_device *dev);
2956
2957void netif_carrier_off(struct net_device *dev);
2958
2959/**
2960 *      netif_dormant_on - mark device as dormant.
2961 *      @dev: network device
2962 *
2963 * Mark device as dormant (as per RFC2863).
2964 *
2965 * The dormant state indicates that the relevant interface is not
2966 * actually in a condition to pass packets (i.e., it is not 'up') but is
2967 * in a "pending" state, waiting for some external event.  For "on-
2968 * demand" interfaces, this new state identifies the situation where the
2969 * interface is waiting for events to place it in the up state.
2970 *
2971 */
2972static inline void netif_dormant_on(struct net_device *dev)
2973{
2974        if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
2975                linkwatch_fire_event(dev);
2976}
2977
2978/**
2979 *      netif_dormant_off - set device as not dormant.
2980 *      @dev: network device
2981 *
2982 * Device is not in dormant state.
2983 */
2984static inline void netif_dormant_off(struct net_device *dev)
2985{
2986        if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
2987                linkwatch_fire_event(dev);
2988}
2989
2990/**
2991 *      netif_dormant - test if carrier present
2992 *      @dev: network device
2993 *
2994 * Check if carrier is present on device
2995 */
2996static inline bool netif_dormant(const struct net_device *dev)
2997{
2998        return test_bit(__LINK_STATE_DORMANT, &dev->state);
2999}
3000
3001
3002/**
3003 *      netif_oper_up - test if device is operational
3004 *      @dev: network device
3005 *
3006 * Check if carrier is operational
3007 */
3008static inline bool netif_oper_up(const struct net_device *dev)
3009{
3010        return (dev->operstate == IF_OPER_UP ||
3011                dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
3012}
3013
3014/**
3015 *      netif_device_present - is device available or removed
3016 *      @dev: network device
3017 *
3018 * Check if device has not been removed from system.
3019 */
3020static inline bool netif_device_present(struct net_device *dev)
3021{
3022        return test_bit(__LINK_STATE_PRESENT, &dev->state);
3023}
3024
3025void netif_device_detach(struct net_device *dev);
3026
3027void netif_device_attach(struct net_device *dev);
3028
3029/*
3030 * Network interface message level settings
3031 */
3032
3033enum {
3034        NETIF_MSG_DRV           = 0x0001,
3035        NETIF_MSG_PROBE         = 0x0002,
3036        NETIF_MSG_LINK          = 0x0004,
3037        NETIF_MSG_TIMER         = 0x0008,
3038        NETIF_MSG_IFDOWN        = 0x0010,
3039        NETIF_MSG_IFUP          = 0x0020,
3040        NETIF_MSG_RX_ERR        = 0x0040,
3041        NETIF_MSG_TX_ERR        = 0x0080,
3042        NETIF_MSG_TX_QUEUED     = 0x0100,
3043        NETIF_MSG_INTR          = 0x0200,
3044        NETIF_MSG_TX_DONE       = 0x0400,
3045        NETIF_MSG_RX_STATUS     = 0x0800,
3046        NETIF_MSG_PKTDATA       = 0x1000,
3047        NETIF_MSG_HW            = 0x2000,
3048        NETIF_MSG_WOL           = 0x4000,
3049};
3050
3051#define netif_msg_drv(p)        ((p)->msg_enable & NETIF_MSG_DRV)
3052#define netif_msg_probe(p)      ((p)->msg_enable & NETIF_MSG_PROBE)
3053#define netif_msg_link(p)       ((p)->msg_enable & NETIF_MSG_LINK)
3054#define netif_msg_timer(p)      ((p)->msg_enable & NETIF_MSG_TIMER)
3055#define netif_msg_ifdown(p)     ((p)->msg_enable & NETIF_MSG_IFDOWN)
3056#define netif_msg_ifup(p)       ((p)->msg_enable & NETIF_MSG_IFUP)
3057#define netif_msg_rx_err(p)     ((p)->msg_enable & NETIF_MSG_RX_ERR)
3058#define netif_msg_tx_err(p)     ((p)->msg_enable & NETIF_MSG_TX_ERR)
3059#define netif_msg_tx_queued(p)  ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
3060#define netif_msg_intr(p)       ((p)->msg_enable & NETIF_MSG_INTR)
3061#define netif_msg_tx_done(p)    ((p)->msg_enable & NETIF_MSG_TX_DONE)
3062#define netif_msg_rx_status(p)  ((p)->msg_enable & NETIF_MSG_RX_STATUS)
3063#define netif_msg_pktdata(p)    ((p)->msg_enable & NETIF_MSG_PKTDATA)
3064#define netif_msg_hw(p)         ((p)->msg_enable & NETIF_MSG_HW)
3065#define netif_msg_wol(p)        ((p)->msg_enable & NETIF_MSG_WOL)
3066
3067static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
3068{
3069        /* use default */
3070        if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
3071                return default_msg_enable_bits;
3072        if (debug_value == 0)   /* no output */
3073                return 0;
3074        /* set low N bits */
3075        return (1 << debug_value) - 1;
3076}
3077
3078static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
3079{
3080        spin_lock(&txq->_xmit_lock);
3081        txq->xmit_lock_owner = cpu;
3082}
3083
3084static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
3085{
3086        spin_lock_bh(&txq->_xmit_lock);
3087        txq->xmit_lock_owner = smp_processor_id();
3088}
3089
3090static inline bool __netif_tx_trylock(struct netdev_queue *txq)
3091{
3092        bool ok = spin_trylock(&txq->_xmit_lock);
3093        if (likely(ok))
3094                txq->xmit_lock_owner = smp_processor_id();
3095        return ok;
3096}
3097
3098static inline void __netif_tx_unlock(struct netdev_queue *txq)
3099{
3100        txq->xmit_lock_owner = -1;
3101        spin_unlock(&txq->_xmit_lock);
3102}
3103
3104static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
3105{
3106        txq->xmit_lock_owner = -1;
3107        spin_unlock_bh(&txq->_xmit_lock);
3108}
3109
3110static inline void txq_trans_update(struct netdev_queue *txq)
3111{
3112        if (txq->xmit_lock_owner != -1)
3113                txq->trans_start = jiffies;
3114}
3115
3116/**
3117 *      netif_tx_lock - grab network device transmit lock
3118 *      @dev: network device
3119 *
3120 * Get network device transmit lock
3121 */
3122static inline void netif_tx_lock(struct net_device *dev)
3123{
3124        unsigned int i;
3125        int cpu;
3126
3127        spin_lock(&dev->tx_global_lock);
3128        cpu = smp_processor_id();
3129        for (i = 0; i < dev->num_tx_queues; i++) {
3130                struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
3131
3132                /* We are the only thread of execution doing a
3133                 * freeze, but we have to grab the _xmit_lock in
3134                 * order to synchronize with threads which are in
3135                 * the ->hard_start_xmit() handler and already
3136                 * checked the frozen bit.
3137                 */
3138                __netif_tx_lock(txq, cpu);
3139                set_bit(__QUEUE_STATE_FROZEN, &txq->state);
3140                __netif_tx_unlock(txq);
3141        }
3142}
3143
3144static inline void netif_tx_lock_bh(struct net_device *dev)
3145{
3146        local_bh_disable();
3147        netif_tx_lock(dev);
3148}
3149
3150static inline void netif_tx_unlock(struct net_device *dev)
3151{
3152        unsigned int i;
3153
3154        for (i = 0; i < dev->num_tx_queues; i++) {
3155                struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
3156
3157                /* No need to grab the _xmit_lock here.  If the
3158                 * queue is not stopped for another reason, we
3159                 * force a schedule.
3160                 */
3161                clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
3162                netif_schedule_queue(txq);
3163        }
3164        spin_unlock(&dev->tx_global_lock);
3165}
3166
3167static inline void netif_tx_unlock_bh(struct net_device *dev)
3168{
3169        netif_tx_unlock(dev);
3170        local_bh_enable();
3171}
3172
3173#define HARD_TX_LOCK(dev, txq, cpu) {                   \
3174        if ((dev->features & NETIF_F_LLTX) == 0) {      \
3175                __netif_tx_lock(txq, cpu);              \
3176        }                                               \
3177}
3178
3179#define HARD_TX_TRYLOCK(dev, txq)                       \
3180        (((dev->features & NETIF_F_LLTX) == 0) ?        \
3181                __netif_tx_trylock(txq) :               \
3182                true )
3183
3184#define HARD_TX_UNLOCK(dev, txq) {                      \
3185        if ((dev->features & NETIF_F_LLTX) == 0) {      \
3186                __netif_tx_unlock(txq);                 \
3187        }                                               \
3188}
3189
3190static inline void netif_tx_disable(struct net_device *dev)
3191{
3192        unsigned int i;
3193        int cpu;
3194
3195        local_bh_disable();
3196        cpu = smp_processor_id();
3197        for (i = 0; i < dev->num_tx_queues; i++) {
3198                struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
3199
3200                __netif_tx_lock(txq, cpu);
3201                netif_tx_stop_queue(txq);
3202                __netif_tx_unlock(txq);
3203        }
3204        local_bh_enable();
3205}
3206
3207static inline void netif_addr_lock(struct net_device *dev)
3208{
3209        spin_lock(&dev->addr_list_lock);
3210}
3211
3212static inline void netif_addr_lock_nested(struct net_device *dev)
3213{
3214        int subclass = SINGLE_DEPTH_NESTING;
3215
3216        if (dev->netdev_ops->ndo_get_lock_subclass)
3217                subclass = dev->netdev_ops->ndo_get_lock_subclass(dev);
3218
3219        spin_lock_nested(&dev->addr_list_lock, subclass);
3220}
3221
3222static inline void netif_addr_lock_bh(struct net_device *dev)
3223{
3224        spin_lock_bh(&dev->addr_list_lock);
3225}
3226
3227static inline void netif_addr_unlock(struct net_device *dev)
3228{
3229        spin_unlock(&dev->addr_list_lock);
3230}
3231
3232static inline void netif_addr_unlock_bh(struct net_device *dev)
3233{
3234        spin_unlock_bh(&dev->addr_list_lock);
3235}
3236
3237/*
3238 * dev_addrs walker. Should be used only for read access. Call with
3239 * rcu_read_lock held.
3240 */
3241#define for_each_dev_addr(dev, ha) \
3242                list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
3243
3244/* These functions live elsewhere (drivers/net/net_init.c, but related) */
3245
3246void ether_setup(struct net_device *dev);
3247
3248/* Support for loadable net-drivers */
3249struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
3250                                    unsigned char name_assign_type,
3251                                    void (*setup)(struct net_device *),
3252                                    unsigned int txqs, unsigned int rxqs);
3253#define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
3254        alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)
3255
3256#define alloc_netdev_mq(sizeof_priv, name, name_assign_type, setup, count) \
3257        alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, count, \
3258                         count)
3259
3260int register_netdev(struct net_device *dev);
3261void unregister_netdev(struct net_device *dev);
3262
3263/* General hardware address lists handling functions */
3264int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
3265                   struct netdev_hw_addr_list *from_list, int addr_len);
3266void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
3267                      struct netdev_hw_addr_list *from_list, int addr_len);
3268int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
3269                       struct net_device *dev,
3270                       int (*sync)(struct net_device *, const unsigned char *),
3271                       int (*unsync)(struct net_device *,
3272                                     const unsigned char *));
3273void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
3274                          struct net_device *dev,
3275                          int (*unsync)(struct net_device *,
3276                                        const unsigned char *));
3277void __hw_addr_init(struct netdev_hw_addr_list *list);
3278
3279/* Functions used for device addresses handling */
3280int dev_addr_add(struct net_device *dev, const unsigned char *addr,
3281                 unsigned char addr_type);
3282int dev_addr_del(struct net_device *dev, const unsigned char *addr,
3283                 unsigned char addr_type);
3284void dev_addr_flush(struct net_device *dev);
3285int dev_addr_init(struct net_device *dev);
3286
3287/* Functions used for unicast addresses handling */
3288int dev_uc_add(struct net_device *dev, const unsigned char *addr);
3289int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
3290int dev_uc_del(struct net_device *dev, const unsigned char *addr);
3291int dev_uc_sync(struct net_device *to, struct net_device *from);
3292int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
3293void dev_uc_unsync(struct net_device *to, struct net_device *from);
3294void dev_uc_flush(struct net_device *dev);
3295void dev_uc_init(struct net_device *dev);
3296
3297/**
3298 *  __dev_uc_sync - Synchonize device's unicast list
3299 *  @dev:  device to sync
3300 *  @sync: function to call if address should be added
3301 *  @unsync: function to call if address should be removed
3302 *
3303 *  Add newly added addresses to the interface, and release
3304 *  addresses that have been deleted.
3305 **/
3306static inline int __dev_uc_sync(struct net_device *dev,
3307                                int (*sync)(struct net_device *,
3308                                            const unsigned char *),
3309                                int (*unsync)(struct net_device *,
3310                                              const unsigned char *))
3311{
3312        return __hw_addr_sync_dev(&dev->uc, dev, sync, unsync);
3313}
3314
3315/**
3316 *  __dev_uc_unsync - Remove synchronized addresses from device
3317 *  @dev:  device to sync
3318 *  @unsync: function to call if address should be removed
3319 *
3320 *  Remove all addresses that were added to the device by dev_uc_sync().
3321 **/
3322static inline void __dev_uc_unsync(struct net_device *dev,
3323                                   int (*unsync)(struct net_device *,
3324                                                 const unsigned char *))
3325{
3326        __hw_addr_unsync_dev(&dev->uc, dev, unsync);
3327}
3328
3329/* Functions used for multicast addresses handling */
3330int dev_mc_add(struct net_device *dev, const unsigned char *addr);
3331int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
3332int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
3333int dev_mc_del(struct net_device *dev, const unsigned char *addr);
3334int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
3335int dev_mc_sync(struct net_device *to, struct net_device *from);
3336int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
3337void dev_mc_unsync(struct net_device *to, struct net_device *from);
3338void dev_mc_flush(struct net_device *dev);
3339void dev_mc_init(struct net_device *dev);
3340
3341/**
3342 *  __dev_mc_sync - Synchonize device's multicast list
3343 *  @dev:  device to sync
3344 *  @sync: function to call if address should be added
3345 *  @unsync: function to call if address should be removed
3346 *
3347 *  Add newly added addresses to the interface, and release
3348 *  addresses that have been deleted.
3349 **/
3350static inline int __dev_mc_sync(struct net_device *dev,
3351                                int (*sync)(struct net_device *,
3352                                            const unsigned char *),
3353                                int (*unsync)(struct net_device *,
3354                                              const unsigned char *))
3355{
3356        return __hw_addr_sync_dev(&dev->mc, dev, sync, unsync);
3357}
3358
3359/**
3360 *  __dev_mc_unsync - Remove synchronized addresses from device
3361 *  @dev:  device to sync
3362 *  @unsync: function to call if address should be removed
3363 *
3364 *  Remove all addresses that were added to the device by dev_mc_sync().
3365 **/
3366static inline void __dev_mc_unsync(struct net_device *dev,
3367                                   int (*unsync)(struct net_device *,
3368                                                 const unsigned char *))
3369{
3370        __hw_addr_unsync_dev(&dev->mc, dev, unsync);
3371}
3372
3373/* Functions used for secondary unicast and multicast support */
3374void dev_set_rx_mode(struct net_device *dev);
3375void __dev_set_rx_mode(struct net_device *dev);
3376int dev_set_promiscuity(struct net_device *dev, int inc);
3377int dev_set_allmulti(struct net_device *dev, int inc);
3378void netdev_state_change(struct net_device *dev);
3379void netdev_notify_peers(struct net_device *dev);
3380void netdev_features_change(struct net_device *dev);
3381/* Load a device via the kmod */
3382void dev_load(struct net *net, const char *name);
3383struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
3384                                        struct rtnl_link_stats64 *storage);
3385void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
3386                             const struct net_device_stats *netdev_stats);
3387
3388extern int              netdev_max_backlog;
3389extern int              netdev_tstamp_prequeue;
3390extern int              weight_p;
3391extern int              bpf_jit_enable;
3392
3393bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev);
3394struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
3395                                                     struct list_head **iter);
3396struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev,
3397                                                     struct list_head **iter);
3398
3399/* iterate through upper list, must be called under RCU read lock */
3400#define netdev_for_each_upper_dev_rcu(dev, updev, iter) \
3401        for (iter = &(dev)->adj_list.upper, \
3402             updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \
3403             updev; \
3404             updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))
3405
3406/* iterate through upper list, must be called under RCU read lock */
3407#define netdev_for_each_all_upper_dev_rcu(dev, updev, iter) \
3408        for (iter = &(dev)->all_adj_list.upper, \
3409             updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)); \
3410             updev; \
3411             updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)))
3412
3413void *netdev_lower_get_next_private(struct net_device *dev,
3414                                    struct list_head **iter);
3415void *netdev_lower_get_next_private_rcu(struct net_device *dev,
3416                                        struct list_head **iter);
3417
3418#define netdev_for_each_lower_private(dev, priv, iter) \
3419        for (iter = (dev)->adj_list.lower.next, \
3420             priv = netdev_lower_get_next_private(dev, &(iter)); \
3421             priv; \
3422             priv = netdev_lower_get_next_private(dev, &(iter)))
3423
3424#define netdev_for_each_lower_private_rcu(dev, priv, iter) \
3425        for (iter = &(dev)->adj_list.lower, \
3426             priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \
3427             priv; \
3428             priv = netdev_lower_get_next_private_rcu(dev, &(iter)))
3429
3430void *netdev_lower_get_next(struct net_device *dev,
3431                                struct list_head **iter);
3432#define netdev_for_each_lower_dev(dev, ldev, iter) \
3433        for (iter = &(dev)->adj_list.lower, \
3434             ldev = netdev_lower_get_next(dev, &(iter)); \
3435             ldev; \
3436             ldev = netdev_lower_get_next(dev, &(iter)))
3437
3438void *netdev_adjacent_get_private(struct list_head *adj_list);
3439void *netdev_lower_get_first_private_rcu(struct net_device *dev);
3440struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
3441struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
3442int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev);
3443int netdev_master_upper_dev_link(struct net_device *dev,
3444                                 struct net_device *upper_dev);
3445int netdev_master_upper_dev_link_private(struct net_device *dev,
3446                                         struct net_device *upper_dev,
3447                                         void *private);
3448void netdev_upper_dev_unlink(struct net_device *dev,
3449                             struct net_device *upper_dev);
3450void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
3451void *netdev_lower_dev_get_private(struct net_device *dev,
3452                                   struct net_device *lower_dev);
3453
3454/* RSS keys are 40 or 52 bytes long */
3455#define NETDEV_RSS_KEY_LEN 52
3456extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN];
3457void netdev_rss_key_fill(void *buffer, size_t len);
3458
3459int dev_get_nest_level(struct net_device *dev,
3460                       bool (*type_check)(struct net_device *dev));
3461int skb_checksum_help(struct sk_buff *skb);
3462struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
3463                                  netdev_features_t features, bool tx_path);
3464struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
3465                                    netdev_features_t features);
3466
3467static inline
3468struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
3469{
3470        return __skb_gso_segment(skb, features, true);
3471}
3472__be16 skb_network_protocol(struct sk_buff *skb, int *depth);
3473
3474static inline bool can_checksum_protocol(netdev_features_t features,
3475                                         __be16 protocol)
3476{
3477        return ((features & NETIF_F_GEN_CSUM) ||
3478                ((features & NETIF_F_V4_CSUM) &&
3479                 protocol == htons(ETH_P_IP)) ||
3480                ((features & NETIF_F_V6_CSUM) &&
3481                 protocol == htons(ETH_P_IPV6)) ||
3482                ((features & NETIF_F_FCOE_CRC) &&
3483                 protocol == htons(ETH_P_FCOE)));
3484}
3485
3486#ifdef CONFIG_BUG
3487void netdev_rx_csum_fault(struct net_device *dev);
3488#else
3489static inline void netdev_rx_csum_fault(struct net_device *dev)
3490{
3491}
3492#endif
3493/* rx skb timestamps */
3494void net_enable_timestamp(void);
3495void net_disable_timestamp(void);
3496
3497#ifdef CONFIG_PROC_FS
3498int __init dev_proc_init(void);
3499#else
3500#define dev_proc_init() 0
3501#endif
3502
3503static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
3504                                              struct sk_buff *skb, struct net_device *dev,
3505                                              bool more)
3506{
3507        skb->xmit_more = more ? 1 : 0;
3508        return ops->ndo_start_xmit(skb, dev);
3509}
3510
3511static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
3512                                            struct netdev_queue *txq, bool more)
3513{
3514        const struct net_device_ops *ops = dev->netdev_ops;
3515        int rc;
3516
3517        rc = __netdev_start_xmit(ops, skb, dev, more);
3518        if (rc == NETDEV_TX_OK)
3519                txq_trans_update(txq);
3520
3521        return rc;
3522}
3523
3524int netdev_class_create_file_ns(struct class_attribute *class_attr,
3525                                const void *ns);
3526void netdev_class_remove_file_ns(struct class_attribute *class_attr,
3527                                 const void *ns);
3528
3529static inline int netdev_class_create_file(struct class_attribute *class_attr)
3530{
3531        return netdev_class_create_file_ns(class_attr, NULL);
3532}
3533
3534static inline void netdev_class_remove_file(struct class_attribute *class_attr)
3535{
3536        netdev_class_remove_file_ns(class_attr, NULL);
3537}
3538
3539extern struct kobj_ns_type_operations net_ns_type_operations;
3540
3541const char *netdev_drivername(const struct net_device *dev);
3542
3543void linkwatch_run_queue(void);
3544
3545static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
3546                                                          netdev_features_t f2)
3547{
3548        if (f1 & NETIF_F_GEN_CSUM)
3549                f1 |= (NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
3550        if (f2 & NETIF_F_GEN_CSUM)
3551                f2 |= (NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
3552        f1 &= f2;
3553        if (f1 & NETIF_F_GEN_CSUM)
3554                f1 &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
3555
3556        return f1;
3557}
3558
3559static inline netdev_features_t netdev_get_wanted_features(
3560        struct net_device *dev)
3561{
3562        return (dev->features & ~dev->hw_features) | dev->wanted_features;
3563}
3564netdev_features_t netdev_increment_features(netdev_features_t all,
3565        netdev_features_t one, netdev_features_t mask);
3566
3567/* Allow TSO being used on stacked device :
3568 * Performing the GSO segmentation before last device
3569 * is a performance improvement.
3570 */
3571static inline netdev_features_t netdev_add_tso_features(netdev_features_t features,
3572                                                        netdev_features_t mask)
3573{
3574        return netdev_increment_features(features, NETIF_F_ALL_TSO, mask);
3575}
3576
3577int __netdev_update_features(struct net_device *dev);
3578void netdev_update_features(struct net_device *dev);
3579void netdev_change_features(struct net_device *dev);
3580
3581void netif_stacked_transfer_operstate(const struct net_device *rootdev,
3582                                        struct net_device *dev);
3583
3584netdev_features_t netif_skb_features(struct sk_buff *skb);
3585
3586static inline bool net_gso_ok(netdev_features_t features, int gso_type)
3587{
3588        netdev_features_t feature = gso_type << NETIF_F_GSO_SHIFT;
3589
3590        /* check flags correspondence */
3591        BUILD_BUG_ON(SKB_GSO_TCPV4   != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
3592        BUILD_BUG_ON(SKB_GSO_UDP     != (NETIF_F_UFO >> NETIF_F_GSO_SHIFT));
3593        BUILD_BUG_ON(SKB_GSO_DODGY   != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
3594        BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
3595        BUILD_BUG_ON(SKB_GSO_TCPV6   != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
3596        BUILD_BUG_ON(SKB_GSO_FCOE    != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
3597        BUILD_BUG_ON(SKB_GSO_GRE     != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
3598        BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO_SHIFT));
3599        BUILD_BUG_ON(SKB_GSO_IPIP    != (NETIF_F_GSO_IPIP >> NETIF_F_GSO_SHIFT));
3600        BUILD_BUG_ON(SKB_GSO_SIT     != (NETIF_F_GSO_SIT >> NETIF_F_GSO_SHIFT));
3601        BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
3602        BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT));
3603        BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT));
3604
3605        return (features & feature) == feature;
3606}
3607
3608static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
3609{
3610        return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
3611               (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
3612}
3613
3614static inline bool netif_needs_gso(struct net_device *dev, struct sk_buff *skb,
3615                                   netdev_features_t features)
3616{
3617        return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
3618                unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
3619                         (skb->ip_summed != CHECKSUM_UNNECESSARY)));
3620}
3621
3622static inline void netif_set_gso_max_size(struct net_device *dev,
3623                                          unsigned int size)
3624{
3625        dev->gso_max_size = size;
3626}
3627
3628static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol,
3629                                        int pulled_hlen, u16 mac_offset,
3630                                        int mac_len)
3631{
3632        skb->protocol = protocol;
3633        skb->encapsulation = 1;
3634        skb_push(skb, pulled_hlen);
3635        skb_reset_transport_header(skb);
3636        skb->mac_header = mac_offset;
3637        skb->network_header = skb->mac_header + mac_len;
3638        skb->mac_len = mac_len;
3639}
3640
3641static inline bool netif_is_macvlan(struct net_device *dev)
3642{
3643        return dev->priv_flags & IFF_MACVLAN;
3644}
3645
3646static inline bool netif_is_macvlan_port(struct net_device *dev)
3647{
3648        return dev->priv_flags & IFF_MACVLAN_PORT;
3649}
3650
3651static inline bool netif_is_ipvlan(struct net_device *dev)
3652{
3653        return dev->priv_flags & IFF_IPVLAN_SLAVE;
3654}
3655
3656static inline bool netif_is_ipvlan_port(struct net_device *dev)
3657{
3658        return dev->priv_flags & IFF_IPVLAN_MASTER;
3659}
3660
3661static inline bool netif_is_bond_master(struct net_device *dev)
3662{
3663        return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
3664}
3665
3666static inline bool netif_is_bond_slave(struct net_device *dev)
3667{
3668        return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
3669}
3670
3671static inline bool netif_supports_nofcs(struct net_device *dev)
3672{
3673        return dev->priv_flags & IFF_SUPP_NOFCS;
3674}
3675
3676/* This device needs to keep skb dst for qdisc enqueue or ndo_start_xmit() */
3677static inline void netif_keep_dst(struct net_device *dev)
3678{
3679        dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
3680}
3681
3682extern struct pernet_operations __net_initdata loopback_net_ops;
3683
3684/* Logging, debugging and troubleshooting/diagnostic helpers. */
3685
3686/* netdev_printk helpers, similar to dev_printk */
3687
3688static inline const char *netdev_name(const struct net_device *dev)
3689{
3690        if (!dev->name[0] || strchr(dev->name, '%'))
3691                return "(unnamed net_device)";
3692        return dev->name;
3693}
3694
3695static inline const char *netdev_reg_state(const struct net_device *dev)
3696{
3697        switch (dev->reg_state) {
3698        case NETREG_UNINITIALIZED: return " (uninitialized)";
3699        case NETREG_REGISTERED: return "";
3700        case NETREG_UNREGISTERING: return " (unregistering)";
3701        case NETREG_UNREGISTERED: return " (unregistered)";
3702        case NETREG_RELEASED: return " (released)";
3703        case NETREG_DUMMY: return " (dummy)";
3704        }
3705
3706        WARN_ONCE(1, "%s: unknown reg_state %d\n", dev->name, dev->reg_state);
3707        return " (unknown)";
3708}
3709
3710__printf(3, 4)
3711void netdev_printk(const char *level, const struct net_device *dev,
3712                   const char *format, ...);
3713__printf(2, 3)
3714void netdev_emerg(const struct net_device *dev, const char *format, ...);
3715__printf(2, 3)
3716void netdev_alert(const struct net_device *dev, const char *format, ...);
3717__printf(2, 3)
3718void netdev_crit(const struct net_device *dev, const char *format, ...);
3719__printf(2, 3)
3720void netdev_err(const struct net_device *dev, const char *format, ...);
3721__printf(2, 3)
3722void netdev_warn(const struct net_device *dev, const char *format, ...);
3723__printf(2, 3)
3724void netdev_notice(const struct net_device *dev, const char *format, ...);
3725__printf(2, 3)
3726void netdev_info(const struct net_device *dev, const char *format, ...);
3727
3728#define MODULE_ALIAS_NETDEV(device) \
3729        MODULE_ALIAS("netdev-" device)
3730
3731#if defined(CONFIG_DYNAMIC_DEBUG)
3732#define netdev_dbg(__dev, format, args...)                      \
3733do {                                                            \
3734        dynamic_netdev_dbg(__dev, format, ##args);              \
3735} while (0)
3736#elif defined(DEBUG)
3737#define netdev_dbg(__dev, format, args...)                      \
3738        netdev_printk(KERN_DEBUG, __dev, format, ##args)
3739#else
3740#define netdev_dbg(__dev, format, args...)                      \
3741({                                                              \
3742        if (0)                                                  \
3743                netdev_printk(KERN_DEBUG, __dev, format, ##args); \
3744})
3745#endif
3746
3747#if defined(VERBOSE_DEBUG)
3748#define netdev_vdbg     netdev_dbg
3749#else
3750
3751#define netdev_vdbg(dev, format, args...)                       \
3752({                                                              \
3753        if (0)                                                  \
3754                netdev_printk(KERN_DEBUG, dev, format, ##args); \
3755        0;                                                      \
3756})
3757#endif
3758
3759/*
3760 * netdev_WARN() acts like dev_printk(), but with the key difference
3761 * of using a WARN/WARN_ON to get the message out, including the
3762 * file/line information and a backtrace.
3763 */
3764#define netdev_WARN(dev, format, args...)                       \
3765        WARN(1, "netdevice: %s%s\n" format, netdev_name(dev),   \
3766             netdev_reg_state(dev), ##args)
3767
3768/* netif printk helpers, similar to netdev_printk */
3769
3770#define netif_printk(priv, type, level, dev, fmt, args...)      \
3771do {                                                            \
3772        if (netif_msg_##type(priv))                             \
3773                netdev_printk(level, (dev), fmt, ##args);       \
3774} while (0)
3775
3776#define netif_level(level, priv, type, dev, fmt, args...)       \
3777do {                                                            \
3778        if (netif_msg_##type(priv))                             \
3779                netdev_##level(dev, fmt, ##args);               \
3780} while (0)
3781
3782#define netif_emerg(priv, type, dev, fmt, args...)              \
3783        netif_level(emerg, priv, type, dev, fmt, ##args)
3784#define netif_alert(priv, type, dev, fmt, args...)              \
3785        netif_level(alert, priv, type, dev, fmt, ##args)
3786#define netif_crit(priv, type, dev, fmt, args...)               \
3787        netif_level(crit, priv, type, dev, fmt, ##args)
3788#define netif_err(priv, type, dev, fmt, args...)                \
3789        netif_level(err, priv, type, dev, fmt, ##args)
3790#define netif_warn(priv, type, dev, fmt, args...)               \
3791        netif_level(warn, priv, type, dev, fmt, ##args)
3792#define netif_notice(priv, type, dev, fmt, args...)             \
3793        netif_level(notice, priv, type, dev, fmt, ##args)
3794#define netif_info(priv, type, dev, fmt, args...)               \
3795        netif_level(info, priv, type, dev, fmt, ##args)
3796
3797#if defined(CONFIG_DYNAMIC_DEBUG)
3798#define netif_dbg(priv, type, netdev, format, args...)          \
3799do {                                                            \
3800        if (netif_msg_##type(priv))                             \
3801                dynamic_netdev_dbg(netdev, format, ##args);     \
3802} while (0)
3803#elif defined(DEBUG)
3804#define netif_dbg(priv, type, dev, format, args...)             \
3805        netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
3806#else
3807#define netif_dbg(priv, type, dev, format, args...)                     \
3808({                                                                      \
3809        if (0)                                                          \
3810                netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
3811        0;                                                              \
3812})
3813#endif
3814
3815#if defined(VERBOSE_DEBUG)
3816#define netif_vdbg      netif_dbg
3817#else
3818#define netif_vdbg(priv, type, dev, format, args...)            \
3819({                                                              \
3820        if (0)                                                  \
3821                netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
3822        0;                                                      \
3823})
3824#endif
3825
3826/*
3827 *      The list of packet types we will receive (as opposed to discard)
3828 *      and the routines to invoke.
3829 *
3830 *      Why 16. Because with 16 the only overlap we get on a hash of the
3831 *      low nibble of the protocol value is RARP/SNAP/X.25.
3832 *
3833 *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
3834 *             sure which should go first, but I bet it won't make much
3835 *             difference if we are running VLANs.  The good news is that
3836 *             this protocol won't be in the list unless compiled in, so
3837 *             the average user (w/out VLANs) will not be adversely affected.
3838 *             --BLG
3839 *
3840 *              0800    IP
3841 *              8100    802.1Q VLAN
3842 *              0001    802.3
3843 *              0002    AX.25
3844 *              0004    802.2
3845 *              8035    RARP
3846 *              0005    SNAP
3847 *              0805    X.25
3848 *              0806    ARP
3849 *              8137    IPX
3850 *              0009    Localtalk
3851 *              86DD    IPv6
3852 */
3853#define PTYPE_HASH_SIZE (16)
3854#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
3855
3856#endif  /* _LINUX_NETDEVICE_H */
3857
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.