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