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