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 55 struct netpoll_info; 56 struct device; 57 struct phy_device; 58 /* 802.11 specific */ 59 struct wireless_dev; 60 /* 802.15.4 specific */ 61 struct wpan_dev; 62 63 void 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 103 enum netdev_tx { 104 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */ 105 NETDEV_TX_OK = 0x00, /* driver took care of packet */ 106 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/ 107 NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */ 108 }; 109 typedef enum netdev_tx netdev_tx_t; 110 111 /* 112 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant; 113 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed. 114 */ 115 static inline bool dev_xmit_complete(int rc) 116 { 117 /* 118 * Positive cases with an skb consumed by a driver: 119 * - successful transmission (rc == NETDEV_TX_OK) 120 * - error while transmitting (rc < 0) 121 * - error while queueing to a different device (rc & NET_XMIT_MASK) 122 */ 123 if (likely(rc < NET_XMIT_MASK)) 124 return true; 125 126 return false; 127 } 128 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 156 struct 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> 188 extern struct static_key rps_needed; 189 #endif 190 191 struct neighbour; 192 struct neigh_parms; 193 struct sk_buff; 194 195 struct 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 211 struct 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 231 struct 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 258 struct 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 275 enum 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 */ 288 struct netdev_boot_setup { 289 char name[IFNAMSIZ]; 290 struct ifmap map; 291 }; 292 #define NETDEV_BOOT_SETUP_MAX 8 293 294 int __init netdev_boot_setup(char *str); 295 296 /* 297 * Structure for NAPI scheduling similar to tasklet but with weighting 298 */ 299 struct 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 325 enum { 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 332 enum gro_result { 333 GRO_MERGED, 334 GRO_MERGED_FREE, 335 GRO_HELD, 336 GRO_NORMAL, 337 GRO_DROP, 338 }; 339 typedef 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 382 enum rx_handler_result { 383 RX_HANDLER_CONSUMED, 384 RX_HANDLER_ANOTHER, 385 RX_HANDLER_EXACT, 386 RX_HANDLER_PASS, 387 }; 388 typedef enum rx_handler_result rx_handler_result_t; 389 typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb); 390 391 void __napi_schedule(struct napi_struct *n); 392 void __napi_schedule_irqoff(struct napi_struct *n); 393 394 static 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 */ 408 static 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 */ 421 static 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 */ 433 static 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(). */ 440 static 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 449 void __napi_complete(struct napi_struct *n); 450 void 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 */ 458 static 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 */ 470 struct 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 */ 478 void 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 */ 487 void 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 */ 496 void 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 */ 505 static 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 */ 521 static 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 530 enum 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 556 struct 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 592 static 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 601 static 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 */ 613 struct 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 */ 625 struct 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 */ 635 struct 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 */ 647 struct 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 656 static 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 670 static 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 677 extern struct rps_sock_flow_table __rcu *rps_sock_flow_table; 678 679 #ifdef CONFIG_RFS_ACCEL 680 bool 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. */ 686 struct 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 */ 698 struct 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 */ 711 struct 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 */ 724 struct 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 */ 735 struct 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 */ 745 struct 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 */ 762 struct netdev_phys_item_id { 763 unsigned char id[MAX_PHYS_ITEM_ID_LEN]; 764 unsigned char id_len; 765 }; 766 767 typedef 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 */ 1034 struct 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 */ 1230 enum 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 1492 struct 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 1746 static inline 1747 int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio) 1748 { 1749 return dev->prio_tc_map[prio & TC_BITMASK]; 1750 } 1751 1752 static inline 1753 int 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 1762 static inline 1763 void 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 1770 static inline 1771 int 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 1781 static inline 1782 int 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 1791 static inline 1792 int netdev_get_num_tc(struct net_device *dev) 1793 { 1794 return dev->num_tc; 1795 } 1796 1797 static inline 1798 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev, 1799 unsigned int index) 1800 { 1801 return &dev->_tx[index]; 1802 } 1803 1804 static 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 1810 static 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 1822 struct 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 */ 1829 static inline 1830 struct net *dev_net(const struct net_device *dev) 1831 { 1832 return read_pnet(&dev->nd_net); 1833 } 1834 1835 static inline 1836 void 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 1844 static 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 */ 1859 static 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 */ 1890 void 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 */ 1899 void netif_napi_del(struct napi_struct *napi); 1900 1901 struct 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 1955 struct 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 1968 struct 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 1976 struct packet_offload { 1977 __be16 type; /* This is really htons(ether_type). */ 1978 struct offload_callbacks callbacks; 1979 struct list_head list; 1980 }; 1981 1982 struct 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) */ 1989 struct 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 2045 int register_netdevice_notifier(struct notifier_block *nb); 2046 int unregister_netdevice_notifier(struct notifier_block *nb); 2047 2048 struct netdev_notifier_info { 2049 struct net_device *dev; 2050 }; 2051 2052 struct netdev_notifier_change_info { 2053 struct netdev_notifier_info info; /* must be first */ 2054 unsigned int flags_changed; 2055 }; 2056 2057 static inline void netdev_notifier_info_init(struct netdev_notifier_info *info, 2058 struct net_device *dev) 2059 { 2060 info->dev = dev; 2061 } 2062 2063 static inline struct net_device * 2064 netdev_notifier_info_to_dev(const struct netdev_notifier_info *info) 2065 { 2066 return info->dev; 2067 } 2068 2069 int call_netdevice_notifiers(unsigned long val, struct net_device *dev); 2070 2071 2072 extern 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 2091 static 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 2101 static 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 2111 static 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 2117 static 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 2124 int netdev_boot_setup_check(struct net_device *dev); 2125 unsigned long netdev_boot_base(const char *prefix, int unit); 2126 struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type, 2127 const char *hwaddr); 2128 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type); 2129 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type); 2130 void dev_add_pack(struct packet_type *pt); 2131 void dev_remove_pack(struct packet_type *pt); 2132 void __dev_remove_pack(struct packet_type *pt); 2133 void dev_add_offload(struct packet_offload *po); 2134 void dev_remove_offload(struct packet_offload *po); 2135 2136 struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags, 2137 unsigned short mask); 2138 struct net_device *dev_get_by_name(struct net *net, const char *name); 2139 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name); 2140 struct net_device *__dev_get_by_name(struct net *net, const char *name); 2141 int dev_alloc_name(struct net_device *dev, const char *name); 2142 int dev_open(struct net_device *dev); 2143 int dev_close(struct net_device *dev); 2144 void dev_disable_lro(struct net_device *dev); 2145 int dev_loopback_xmit(struct sk_buff *newskb); 2146 int dev_queue_xmit(struct sk_buff *skb); 2147 int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv); 2148 int register_netdevice(struct net_device *dev); 2149 void unregister_netdevice_queue(struct net_device *dev, struct list_head *head); 2150 void unregister_netdevice_many(struct list_head *head); 2151 static inline void unregister_netdevice(struct net_device *dev) 2152 { 2153 unregister_netdevice_queue(dev, NULL); 2154 } 2155 2156 int netdev_refcnt_read(const struct net_device *dev); 2157 void free_netdev(struct net_device *dev); 2158 void netdev_freemem(struct net_device *dev); 2159 void synchronize_net(void); 2160 int init_dummy_netdev(struct net_device *dev); 2161 2162 struct net_device *dev_get_by_index(struct net *net, int ifindex); 2163 struct net_device *__dev_get_by_index(struct net *net, int ifindex); 2164 struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex); 2165 int netdev_get_name(struct net *net, char *name, int ifindex); 2166 int dev_restart(struct net_device *dev); 2167 int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb); 2168 2169 static inline unsigned int skb_gro_offset(const struct sk_buff *skb) 2170 { 2171 return NAPI_GRO_CB(skb)->data_offset; 2172 } 2173 2174 static inline unsigned int skb_gro_len(const struct sk_buff *skb) 2175 { 2176 return skb->len - NAPI_GRO_CB(skb)->data_offset; 2177 } 2178 2179 static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len) 2180 { 2181 NAPI_GRO_CB(skb)->data_offset += len; 2182 } 2183 2184 static 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 2190 static 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 2195 static 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 2206 static 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 2212 static 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 2227 static 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 2236 static 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 2248 static 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 2286 static 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 2292 static 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) \ 2300 do { \ 2301 if (__skb_gro_checksum_convert_check(skb)) \ 2302 __skb_gro_checksum_convert(skb, check, \ 2303 compute_pseudo(skb, proto)); \ 2304 } while (0) 2305 2306 static 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 2317 static 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 2327 static 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 2336 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len); 2337 int register_gifconf(unsigned int family, gifconf_func_t *gifconf); 2338 static 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 */ 2345 struct 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 2353 extern int netdev_flow_limit_table_len; 2354 #endif /* CONFIG_NET_FLOW_LIMIT */ 2355 2356 /* 2357 * Incoming packets are placed on per-cpu queues 2358 */ 2359 struct 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 2392 static inline void input_queue_head_incr(struct softnet_data *sd) 2393 { 2394 #ifdef CONFIG_RPS 2395 sd->input_queue_head++; 2396 #endif 2397 } 2398 2399 static 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 2407 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data); 2408 2409 void __netif_schedule(struct Qdisc *q); 2410 void netif_schedule_queue(struct netdev_queue *txq); 2411 2412 static 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 2420 static 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 */ 2431 static inline void netif_start_queue(struct net_device *dev) 2432 { 2433 netif_tx_start_queue(netdev_get_tx_queue(dev, 0)); 2434 } 2435 2436 static 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 2446 void 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 */ 2455 static inline void netif_wake_queue(struct net_device *dev) 2456 { 2457 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0)); 2458 } 2459 2460 static 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 2470 static 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 */ 2486 static inline void netif_stop_queue(struct net_device *dev) 2487 { 2488 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0)); 2489 } 2490 2491 static 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 2501 static 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 */ 2512 static 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 2517 static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue) 2518 { 2519 return dev_queue->state & QUEUE_STATE_ANY_XOFF; 2520 } 2521 2522 static inline bool 2523 netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue) 2524 { 2525 return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN; 2526 } 2527 2528 static inline bool 2529 netif_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 */ 2541 static 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 */ 2555 static 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 2562 static 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 */ 2595 static 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 2600 static 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 */ 2634 static 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 2640 static 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 */ 2655 static 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 */ 2668 static 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 */ 2686 static 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 */ 2705 static 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 */ 2719 static 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 */ 2732 static 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 2740 static 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 2746 void netif_wake_subqueue(struct net_device *dev, u16 queue_index); 2747 2748 #ifdef CONFIG_XPS 2749 int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask, 2750 u16 index); 2751 #else 2752 static 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 */ 2764 static 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 */ 2776 static inline bool netif_is_multiqueue(const struct net_device *dev) 2777 { 2778 return dev->num_tx_queues > 1; 2779 } 2780 2781 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq); 2782 2783 #ifdef CONFIG_SYSFS 2784 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq); 2785 #else 2786 static 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 2794 static 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) 2806 int netif_get_num_default_rss_queues(void); 2807 2808 enum skb_free_reason { 2809 SKB_REASON_CONSUMED, 2810 SKB_REASON_DROPPED, 2811 }; 2812 2813 void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason); 2814 void __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 */ 2835 static inline void dev_kfree_skb_irq(struct sk_buff *skb) 2836 { 2837 __dev_kfree_skb_irq(skb, SKB_REASON_DROPPED); 2838 } 2839 2840 static inline void dev_consume_skb_irq(struct sk_buff *skb) 2841 { 2842 __dev_kfree_skb_irq(skb, SKB_REASON_CONSUMED); 2843 } 2844 2845 static inline void dev_kfree_skb_any(struct sk_buff *skb) 2846 { 2847 __dev_kfree_skb_any(skb, SKB_REASON_DROPPED); 2848 } 2849 2850 static inline void dev_consume_skb_any(struct sk_buff *skb) 2851 { 2852 __dev_kfree_skb_any(skb, SKB_REASON_CONSUMED); 2853 } 2854 2855 int netif_rx(struct sk_buff *skb); 2856 int netif_rx_ni(struct sk_buff *skb); 2857 int netif_receive_skb(struct sk_buff *skb); 2858 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb); 2859 void napi_gro_flush(struct napi_struct *napi, bool flush_old); 2860 struct sk_buff *napi_get_frags(struct napi_struct *napi); 2861 gro_result_t napi_gro_frags(struct napi_struct *napi); 2862 struct packet_offload *gro_find_receive_by_type(__be16 type); 2863 struct packet_offload *gro_find_complete_by_type(__be16 type); 2864 2865 static inline void napi_free_frags(struct napi_struct *napi) 2866 { 2867 kfree_skb(napi->skb); 2868 napi->skb = NULL; 2869 } 2870 2871 int netdev_rx_handler_register(struct net_device *dev, 2872 rx_handler_func_t *rx_handler, 2873 void *rx_handler_data); 2874 void netdev_rx_handler_unregister(struct net_device *dev); 2875 2876 bool dev_valid_name(const char *name); 2877 int dev_ioctl(struct net *net, unsigned int cmd, void __user *); 2878 int dev_ethtool(struct net *net, struct ifreq *); 2879 unsigned int dev_get_flags(const struct net_device *); 2880 int __dev_change_flags(struct net_device *, unsigned int flags); 2881 int dev_change_flags(struct net_device *, unsigned int); 2882 void __dev_notify_flags(struct net_device *, unsigned int old_flags, 2883 unsigned int gchanges); 2884 int dev_change_name(struct net_device *, const char *); 2885 int dev_set_alias(struct net_device *, const char *, size_t); 2886 int dev_change_net_namespace(struct net_device *, struct net *, const char *); 2887 int dev_set_mtu(struct net_device *, int); 2888 void dev_set_group(struct net_device *, int); 2889 int dev_set_mac_address(struct net_device *, struct sockaddr *); 2890 int dev_change_carrier(struct net_device *, bool new_carrier); 2891 int dev_get_phys_port_id(struct net_device *dev, 2892 struct netdev_phys_item_id *ppid); 2893 struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev); 2894 struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev, 2895 struct netdev_queue *txq, int *ret); 2896 int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb); 2897 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb); 2898 bool is_skb_forwardable(struct net_device *dev, struct sk_buff *skb); 2899 2900 extern int netdev_budget; 2901 2902 /* Called by rtnetlink.c:rtnl_unlock() */ 2903 void 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 */ 2911 static 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 */ 2922 static 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 2936 void linkwatch_init_dev(struct net_device *dev); 2937 void linkwatch_fire_event(struct net_device *dev); 2938 void 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 */ 2946 static inline bool netif_carrier_ok(const struct net_device *dev) 2947 { 2948 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state); 2949 } 2950 2951 unsigned long dev_trans_start(struct net_device *dev); 2952 2953 void __netdev_watchdog_up(struct net_device *dev); 2954 2955 void netif_carrier_on(struct net_device *dev); 2956 2957 void 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 */ 2972 static 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 */ 2984 static 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 */ 2996 static 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 */ 3008 static 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 */ 3020 static inline bool netif_device_present(struct net_device *dev) 3021 { 3022 return test_bit(__LINK_STATE_PRESENT, &dev->state); 3023 } 3024 3025 void netif_device_detach(struct net_device *dev); 3026 3027 void netif_device_attach(struct net_device *dev); 3028 3029 /* 3030 * Network interface message level settings 3031 */ 3032 3033 enum { 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 3067 static 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 3078 static 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 3084 static 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 3090 static 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 3098 static inline void __netif_tx_unlock(struct netdev_queue *txq) 3099 { 3100 txq->xmit_lock_owner = -1; 3101 spin_unlock(&txq->_xmit_lock); 3102 } 3103 3104 static 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 3110 static 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 */ 3122 static 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 3144 static inline void netif_tx_lock_bh(struct net_device *dev) 3145 { 3146 local_bh_disable(); 3147 netif_tx_lock(dev); 3148 } 3149 3150 static 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 3167 static 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 3190 static 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 3207 static inline void netif_addr_lock(struct net_device *dev) 3208 { 3209 spin_lock(&dev->addr_list_lock); 3210 } 3211 3212 static 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 3222 static inline void netif_addr_lock_bh(struct net_device *dev) 3223 { 3224 spin_lock_bh(&dev->addr_list_lock); 3225 } 3226 3227 static inline void netif_addr_unlock(struct net_device *dev) 3228 { 3229 spin_unlock(&dev->addr_list_lock); 3230 } 3231 3232 static 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 3246 void ether_setup(struct net_device *dev); 3247 3248 /* Support for loadable net-drivers */ 3249 struct 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 3260 int register_netdev(struct net_device *dev); 3261 void unregister_netdev(struct net_device *dev); 3262 3263 /* General hardware address lists handling functions */ 3264 int __hw_addr_sync(struct netdev_hw_addr_list *to_list, 3265 struct netdev_hw_addr_list *from_list, int addr_len); 3266 void __hw_addr_unsync(struct netdev_hw_addr_list *to_list, 3267 struct netdev_hw_addr_list *from_list, int addr_len); 3268 int __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 *)); 3273 void __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 *)); 3277 void __hw_addr_init(struct netdev_hw_addr_list *list); 3278 3279 /* Functions used for device addresses handling */ 3280 int dev_addr_add(struct net_device *dev, const unsigned char *addr, 3281 unsigned char addr_type); 3282 int dev_addr_del(struct net_device *dev, const unsigned char *addr, 3283 unsigned char addr_type); 3284 void dev_addr_flush(struct net_device *dev); 3285 int dev_addr_init(struct net_device *dev); 3286 3287 /* Functions used for unicast addresses handling */ 3288 int dev_uc_add(struct net_device *dev, const unsigned char *addr); 3289 int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr); 3290 int dev_uc_del(struct net_device *dev, const unsigned char *addr); 3291 int dev_uc_sync(struct net_device *to, struct net_device *from); 3292 int dev_uc_sync_multiple(struct net_device *to, struct net_device *from); 3293 void dev_uc_unsync(struct net_device *to, struct net_device *from); 3294 void dev_uc_flush(struct net_device *dev); 3295 void 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 **/ 3306 static 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 **/ 3322 static 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 */ 3330 int dev_mc_add(struct net_device *dev, const unsigned char *addr); 3331 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr); 3332 int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr); 3333 int dev_mc_del(struct net_device *dev, const unsigned char *addr); 3334 int dev_mc_del_global(struct net_device *dev, const unsigned char *addr); 3335 int dev_mc_sync(struct net_device *to, struct net_device *from); 3336 int dev_mc_sync_multiple(struct net_device *to, struct net_device *from); 3337 void dev_mc_unsync(struct net_device *to, struct net_device *from); 3338 void dev_mc_flush(struct net_device *dev); 3339 void 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 **/ 3350 static 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 **/ 3366 static 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 */ 3374 void dev_set_rx_mode(struct net_device *dev); 3375 void __dev_set_rx_mode(struct net_device *dev); 3376 int dev_set_promiscuity(struct net_device *dev, int inc); 3377 int dev_set_allmulti(struct net_device *dev, int inc); 3378 void netdev_state_change(struct net_device *dev); 3379 void netdev_notify_peers(struct net_device *dev); 3380 void netdev_features_change(struct net_device *dev); 3381 /* Load a device via the kmod */ 3382 void dev_load(struct net *net, const char *name); 3383 struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev, 3384 struct rtnl_link_stats64 *storage); 3385 void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64, 3386 const struct net_device_stats *netdev_stats); 3387 3388 extern int netdev_max_backlog; 3389 extern int netdev_tstamp_prequeue; 3390 extern int weight_p; 3391 extern int bpf_jit_enable; 3392 3393 bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev); 3394 struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev, 3395 struct list_head **iter); 3396 struct 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 3413 void *netdev_lower_get_next_private(struct net_device *dev, 3414 struct list_head **iter); 3415 void *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 3430 void *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 3438 void *netdev_adjacent_get_private(struct list_head *adj_list); 3439 void *netdev_lower_get_first_private_rcu(struct net_device *dev); 3440 struct net_device *netdev_master_upper_dev_get(struct net_device *dev); 3441 struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev); 3442 int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev); 3443 int netdev_master_upper_dev_link(struct net_device *dev, 3444 struct net_device *upper_dev); 3445 int netdev_master_upper_dev_link_private(struct net_device *dev, 3446 struct net_device *upper_dev, 3447 void *private); 3448 void netdev_upper_dev_unlink(struct net_device *dev, 3449 struct net_device *upper_dev); 3450 void netdev_adjacent_rename_links(struct net_device *dev, char *oldname); 3451 void *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 3456 extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN]; 3457 void netdev_rss_key_fill(void *buffer, size_t len); 3458 3459 int dev_get_nest_level(struct net_device *dev, 3460 bool (*type_check)(struct net_device *dev)); 3461 int skb_checksum_help(struct sk_buff *skb); 3462 struct sk_buff *__skb_gso_segment(struct sk_buff *skb, 3463 netdev_features_t features, bool tx_path); 3464 struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb, 3465 netdev_features_t features); 3466 3467 static inline 3468 struct 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 3474 static 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 3487 void netdev_rx_csum_fault(struct net_device *dev); 3488 #else 3489 static inline void netdev_rx_csum_fault(struct net_device *dev) 3490 { 3491 } 3492 #endif 3493 /* rx skb timestamps */ 3494 void net_enable_timestamp(void); 3495 void net_disable_timestamp(void); 3496 3497 #ifdef CONFIG_PROC_FS 3498 int __init dev_proc_init(void); 3499 #else 3500 #define dev_proc_init() 0 3501 #endif 3502 3503 static 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 3511 static 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 3524 int netdev_class_create_file_ns(struct class_attribute *class_attr, 3525 const void *ns); 3526 void netdev_class_remove_file_ns(struct class_attribute *class_attr, 3527 const void *ns); 3528 3529 static inline int netdev_class_create_file(struct class_attribute *class_attr) 3530 { 3531 return netdev_class_create_file_ns(class_attr, NULL); 3532 } 3533 3534 static inline void netdev_class_remove_file(struct class_attribute *class_attr) 3535 { 3536 netdev_class_remove_file_ns(class_attr, NULL); 3537 } 3538 3539 extern struct kobj_ns_type_operations net_ns_type_operations; 3540 3541 const char *netdev_drivername(const struct net_device *dev); 3542 3543 void linkwatch_run_queue(void); 3544 3545 static 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 3559 static 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 } 3564 netdev_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 */ 3571 static 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 3577 int __netdev_update_features(struct net_device *dev); 3578 void netdev_update_features(struct net_device *dev); 3579 void netdev_change_features(struct net_device *dev); 3580 3581 void netif_stacked_transfer_operstate(const struct net_device *rootdev, 3582 struct net_device *dev); 3583 3584 netdev_features_t netif_skb_features(struct sk_buff *skb); 3585 3586 static 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 3608 static 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 3614 static 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 3622 static inline void netif_set_gso_max_size(struct net_device *dev, 3623 unsigned int size) 3624 { 3625 dev->gso_max_size = size; 3626 } 3627 3628 static 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 3641 static inline bool netif_is_macvlan(struct net_device *dev) 3642 { 3643 return dev->priv_flags & IFF_MACVLAN; 3644 } 3645 3646 static inline bool netif_is_macvlan_port(struct net_device *dev) 3647 { 3648 return dev->priv_flags & IFF_MACVLAN_PORT; 3649 } 3650 3651 static inline bool netif_is_ipvlan(struct net_device *dev) 3652 { 3653 return dev->priv_flags & IFF_IPVLAN_SLAVE; 3654 } 3655 3656 static inline bool netif_is_ipvlan_port(struct net_device *dev) 3657 { 3658 return dev->priv_flags & IFF_IPVLAN_MASTER; 3659 } 3660 3661 static inline bool netif_is_bond_master(struct net_device *dev) 3662 { 3663 return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING; 3664 } 3665 3666 static inline bool netif_is_bond_slave(struct net_device *dev) 3667 { 3668 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING; 3669 } 3670 3671 static 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() */ 3677 static 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 3682 extern 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 3688 static 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 3695 static 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) 3711 void netdev_printk(const char *level, const struct net_device *dev, 3712 const char *format, ...); 3713 __printf(2, 3) 3714 void netdev_emerg(const struct net_device *dev, const char *format, ...); 3715 __printf(2, 3) 3716 void netdev_alert(const struct net_device *dev, const char *format, ...); 3717 __printf(2, 3) 3718 void netdev_crit(const struct net_device *dev, const char *format, ...); 3719 __printf(2, 3) 3720 void netdev_err(const struct net_device *dev, const char *format, ...); 3721 __printf(2, 3) 3722 void netdev_warn(const struct net_device *dev, const char *format, ...); 3723 __printf(2, 3) 3724 void netdev_notice(const struct net_device *dev, const char *format, ...); 3725 __printf(2, 3) 3726 void 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...) \ 3733 do { \ 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...) \ 3771 do { \ 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...) \ 3777 do { \ 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...) \ 3799 do { \ 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