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 * void *accel_priv); 774 * Called to decide which queue to when device supports multiple 775 * transmit queues. 776 * 777 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags); 778 * This function is called to allow device receiver to make 779 * changes to configuration when multicast or promiscious is enabled. 780 * 781 * void (*ndo_set_rx_mode)(struct net_device *dev); 782 * This function is called device changes address list filtering. 783 * If driver handles unicast address filtering, it should set 784 * IFF_UNICAST_FLT to its priv_flags. 785 * 786 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr); 787 * This function is called when the Media Access Control address 788 * needs to be changed. If this interface is not defined, the 789 * mac address can not be changed. 790 * 791 * int (*ndo_validate_addr)(struct net_device *dev); 792 * Test if Media Access Control address is valid for the device. 793 * 794 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd); 795 * Called when a user request an ioctl which can't be handled by 796 * the generic interface code. If not defined ioctl's return 797 * not supported error code. 798 * 799 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map); 800 * Used to set network devices bus interface parameters. This interface 801 * is retained for legacy reason, new devices should use the bus 802 * interface (PCI) for low level management. 803 * 804 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu); 805 * Called when a user wants to change the Maximum Transfer Unit 806 * of a device. If not defined, any request to change MTU will 807 * will return an error. 808 * 809 * void (*ndo_tx_timeout)(struct net_device *dev); 810 * Callback uses when the transmitter has not made any progress 811 * for dev->watchdog ticks. 812 * 813 * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev, 814 * struct rtnl_link_stats64 *storage); 815 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); 816 * Called when a user wants to get the network device usage 817 * statistics. Drivers must do one of the following: 818 * 1. Define @ndo_get_stats64 to fill in a zero-initialised 819 * rtnl_link_stats64 structure passed by the caller. 820 * 2. Define @ndo_get_stats to update a net_device_stats structure 821 * (which should normally be dev->stats) and return a pointer to 822 * it. The structure may be changed asynchronously only if each 823 * field is written atomically. 824 * 3. Update dev->stats asynchronously and atomically, and define 825 * neither operation. 826 * 827 * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16t vid); 828 * If device support VLAN filtering this function is called when a 829 * VLAN id is registered. 830 * 831 * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid); 832 * If device support VLAN filtering this function is called when a 833 * VLAN id is unregistered. 834 * 835 * void (*ndo_poll_controller)(struct net_device *dev); 836 * 837 * SR-IOV management functions. 838 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac); 839 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos); 840 * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate); 841 * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting); 842 * int (*ndo_get_vf_config)(struct net_device *dev, 843 * int vf, struct ifla_vf_info *ivf); 844 * int (*ndo_set_vf_link_state)(struct net_device *dev, int vf, int link_state); 845 * int (*ndo_set_vf_port)(struct net_device *dev, int vf, 846 * struct nlattr *port[]); 847 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb); 848 * int (*ndo_setup_tc)(struct net_device *dev, u8 tc) 849 * Called to setup 'tc' number of traffic classes in the net device. This 850 * is always called from the stack with the rtnl lock held and netif tx 851 * queues stopped. This allows the netdevice to perform queue management 852 * safely. 853 * 854 * Fiber Channel over Ethernet (FCoE) offload functions. 855 * int (*ndo_fcoe_enable)(struct net_device *dev); 856 * Called when the FCoE protocol stack wants to start using LLD for FCoE 857 * so the underlying device can perform whatever needed configuration or 858 * initialization to support acceleration of FCoE traffic. 859 * 860 * int (*ndo_fcoe_disable)(struct net_device *dev); 861 * Called when the FCoE protocol stack wants to stop using LLD for FCoE 862 * so the underlying device can perform whatever needed clean-ups to 863 * stop supporting acceleration of FCoE traffic. 864 * 865 * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid, 866 * struct scatterlist *sgl, unsigned int sgc); 867 * Called when the FCoE Initiator wants to initialize an I/O that 868 * is a possible candidate for Direct Data Placement (DDP). The LLD can 869 * perform necessary setup and returns 1 to indicate the device is set up 870 * successfully to perform DDP on this I/O, otherwise this returns 0. 871 * 872 * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid); 873 * Called when the FCoE Initiator/Target is done with the DDPed I/O as 874 * indicated by the FC exchange id 'xid', so the underlying device can 875 * clean up and reuse resources for later DDP requests. 876 * 877 * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid, 878 * struct scatterlist *sgl, unsigned int sgc); 879 * Called when the FCoE Target wants to initialize an I/O that 880 * is a possible candidate for Direct Data Placement (DDP). The LLD can 881 * perform necessary setup and returns 1 to indicate the device is set up 882 * successfully to perform DDP on this I/O, otherwise this returns 0. 883 * 884 * int (*ndo_fcoe_get_hbainfo)(struct net_device *dev, 885 * struct netdev_fcoe_hbainfo *hbainfo); 886 * Called when the FCoE Protocol stack wants information on the underlying 887 * device. This information is utilized by the FCoE protocol stack to 888 * register attributes with Fiber Channel management service as per the 889 * FC-GS Fabric Device Management Information(FDMI) specification. 890 * 891 * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type); 892 * Called when the underlying device wants to override default World Wide 893 * Name (WWN) generation mechanism in FCoE protocol stack to pass its own 894 * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE 895 * protocol stack to use. 896 * 897 * RFS acceleration. 898 * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb, 899 * u16 rxq_index, u32 flow_id); 900 * Set hardware filter for RFS. rxq_index is the target queue index; 901 * flow_id is a flow ID to be passed to rps_may_expire_flow() later. 902 * Return the filter ID on success, or a negative error code. 903 * 904 * Slave management functions (for bridge, bonding, etc). 905 * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev); 906 * Called to make another netdev an underling. 907 * 908 * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev); 909 * Called to release previously enslaved netdev. 910 * 911 * Feature/offload setting functions. 912 * netdev_features_t (*ndo_fix_features)(struct net_device *dev, 913 * netdev_features_t features); 914 * Adjusts the requested feature flags according to device-specific 915 * constraints, and returns the resulting flags. Must not modify 916 * the device state. 917 * 918 * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features); 919 * Called to update device configuration to new features. Passed 920 * feature set might be less than what was returned by ndo_fix_features()). 921 * Must return >0 or -errno if it changed dev->features itself. 922 * 923 * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[], 924 * struct net_device *dev, 925 * const unsigned char *addr, u16 flags) 926 * Adds an FDB entry to dev for addr. 927 * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[], 928 * struct net_device *dev, 929 * const unsigned char *addr) 930 * Deletes the FDB entry from dev coresponding to addr. 931 * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb, 932 * struct net_device *dev, int idx) 933 * Used to add FDB entries to dump requests. Implementers should add 934 * entries to skb and update idx with the number of entries. 935 * 936 * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh) 937 * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq, 938 * struct net_device *dev, u32 filter_mask) 939 * 940 * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier); 941 * Called to change device carrier. Soft-devices (like dummy, team, etc) 942 * which do not represent real hardware may define this to allow their 943 * userspace components to manage their virtual carrier state. Devices 944 * that determine carrier state from physical hardware properties (eg 945 * network cables) or protocol-dependent mechanisms (eg 946 * USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function. 947 * 948 * int (*ndo_get_phys_port_id)(struct net_device *dev, 949 * struct netdev_phys_port_id *ppid); 950 * Called to get ID of physical port of this device. If driver does 951 * not implement this, it is assumed that the hw is not able to have 952 * multiple net devices on single physical port. 953 * 954 * void (*ndo_add_vxlan_port)(struct net_device *dev, 955 * sa_family_t sa_family, __be16 port); 956 * Called by vxlan to notiy a driver about the UDP port and socket 957 * address family that vxlan is listnening to. It is called only when 958 * a new port starts listening. The operation is protected by the 959 * vxlan_net->sock_lock. 960 * 961 * void (*ndo_del_vxlan_port)(struct net_device *dev, 962 * sa_family_t sa_family, __be16 port); 963 * Called by vxlan to notify the driver about a UDP port and socket 964 * address family that vxlan is not listening to anymore. The operation 965 * is protected by the vxlan_net->sock_lock. 966 * 967 * void* (*ndo_dfwd_add_station)(struct net_device *pdev, 968 * struct net_device *dev) 969 * Called by upper layer devices to accelerate switching or other 970 * station functionality into hardware. 'pdev is the lowerdev 971 * to use for the offload and 'dev' is the net device that will 972 * back the offload. Returns a pointer to the private structure 973 * the upper layer will maintain. 974 * void (*ndo_dfwd_del_station)(struct net_device *pdev, void *priv) 975 * Called by upper layer device to delete the station created 976 * by 'ndo_dfwd_add_station'. 'pdev' is the net device backing 977 * the station and priv is the structure returned by the add 978 * operation. 979 * netdev_tx_t (*ndo_dfwd_start_xmit)(struct sk_buff *skb, 980 * struct net_device *dev, 981 * void *priv); 982 * Callback to use for xmit over the accelerated station. This 983 * is used in place of ndo_start_xmit on accelerated net 984 * devices. 985 */ 986 struct net_device_ops { 987 int (*ndo_init)(struct net_device *dev); 988 void (*ndo_uninit)(struct net_device *dev); 989 int (*ndo_open)(struct net_device *dev); 990 int (*ndo_stop)(struct net_device *dev); 991 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb, 992 struct net_device *dev); 993 u16 (*ndo_select_queue)(struct net_device *dev, 994 struct sk_buff *skb, 995 void *accel_priv); 996 void (*ndo_change_rx_flags)(struct net_device *dev, 997 int flags); 998 void (*ndo_set_rx_mode)(struct net_device *dev); 999 int (*ndo_set_mac_address)(struct net_device *dev, 1000 void *addr); 1001 int (*ndo_validate_addr)(struct net_device *dev); 1002 int (*ndo_do_ioctl)(struct net_device *dev, 1003 struct ifreq *ifr, int cmd); 1004 int (*ndo_set_config)(struct net_device *dev, 1005 struct ifmap *map); 1006 int (*ndo_change_mtu)(struct net_device *dev, 1007 int new_mtu); 1008 int (*ndo_neigh_setup)(struct net_device *dev, 1009 struct neigh_parms *); 1010 void (*ndo_tx_timeout) (struct net_device *dev); 1011 1012 struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev, 1013 struct rtnl_link_stats64 *storage); 1014 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); 1015 1016 int (*ndo_vlan_rx_add_vid)(struct net_device *dev, 1017 __be16 proto, u16 vid); 1018 int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, 1019 __be16 proto, u16 vid); 1020 #ifdef CONFIG_NET_POLL_CONTROLLER 1021 void (*ndo_poll_controller)(struct net_device *dev); 1022 int (*ndo_netpoll_setup)(struct net_device *dev, 1023 struct netpoll_info *info, 1024 gfp_t gfp); 1025 void (*ndo_netpoll_cleanup)(struct net_device *dev); 1026 #endif 1027 #ifdef CONFIG_NET_RX_BUSY_POLL 1028 int (*ndo_busy_poll)(struct napi_struct *dev); 1029 #endif 1030 int (*ndo_set_vf_mac)(struct net_device *dev, 1031 int queue, u8 *mac); 1032 int (*ndo_set_vf_vlan)(struct net_device *dev, 1033 int queue, u16 vlan, u8 qos); 1034 int (*ndo_set_vf_tx_rate)(struct net_device *dev, 1035 int vf, int rate); 1036 int (*ndo_set_vf_spoofchk)(struct net_device *dev, 1037 int vf, bool setting); 1038 int (*ndo_get_vf_config)(struct net_device *dev, 1039 int vf, 1040 struct ifla_vf_info *ivf); 1041 int (*ndo_set_vf_link_state)(struct net_device *dev, 1042 int vf, int link_state); 1043 int (*ndo_set_vf_port)(struct net_device *dev, 1044 int vf, 1045 struct nlattr *port[]); 1046 int (*ndo_get_vf_port)(struct net_device *dev, 1047 int vf, struct sk_buff *skb); 1048 int (*ndo_setup_tc)(struct net_device *dev, u8 tc); 1049 #if IS_ENABLED(CONFIG_FCOE) 1050 int (*ndo_fcoe_enable)(struct net_device *dev); 1051 int (*ndo_fcoe_disable)(struct net_device *dev); 1052 int (*ndo_fcoe_ddp_setup)(struct net_device *dev, 1053 u16 xid, 1054 struct scatterlist *sgl, 1055 unsigned int sgc); 1056 int (*ndo_fcoe_ddp_done)(struct net_device *dev, 1057 u16 xid); 1058 int (*ndo_fcoe_ddp_target)(struct net_device *dev, 1059 u16 xid, 1060 struct scatterlist *sgl, 1061 unsigned int sgc); 1062 int (*ndo_fcoe_get_hbainfo)(struct net_device *dev, 1063 struct netdev_fcoe_hbainfo *hbainfo); 1064 #endif 1065 1066 #if IS_ENABLED(CONFIG_LIBFCOE) 1067 #define NETDEV_FCOE_WWNN 0 1068 #define NETDEV_FCOE_WWPN 1 1069 int (*ndo_fcoe_get_wwn)(struct net_device *dev, 1070 u64 *wwn, int type); 1071 #endif 1072 1073 #ifdef CONFIG_RFS_ACCEL 1074 int (*ndo_rx_flow_steer)(struct net_device *dev, 1075 const struct sk_buff *skb, 1076 u16 rxq_index, 1077 u32 flow_id); 1078 #endif 1079 int (*ndo_add_slave)(struct net_device *dev, 1080 struct net_device *slave_dev); 1081 int (*ndo_del_slave)(struct net_device *dev, 1082 struct net_device *slave_dev); 1083 netdev_features_t (*ndo_fix_features)(struct net_device *dev, 1084 netdev_features_t features); 1085 int (*ndo_set_features)(struct net_device *dev, 1086 netdev_features_t features); 1087 int (*ndo_neigh_construct)(struct neighbour *n); 1088 void (*ndo_neigh_destroy)(struct neighbour *n); 1089 1090 int (*ndo_fdb_add)(struct ndmsg *ndm, 1091 struct nlattr *tb[], 1092 struct net_device *dev, 1093 const unsigned char *addr, 1094 u16 flags); 1095 int (*ndo_fdb_del)(struct ndmsg *ndm, 1096 struct nlattr *tb[], 1097 struct net_device *dev, 1098 const unsigned char *addr); 1099 int (*ndo_fdb_dump)(struct sk_buff *skb, 1100 struct netlink_callback *cb, 1101 struct net_device *dev, 1102 int idx); 1103 1104 int (*ndo_bridge_setlink)(struct net_device *dev, 1105 struct nlmsghdr *nlh); 1106 int (*ndo_bridge_getlink)(struct sk_buff *skb, 1107 u32 pid, u32 seq, 1108 struct net_device *dev, 1109 u32 filter_mask); 1110 int (*ndo_bridge_dellink)(struct net_device *dev, 1111 struct nlmsghdr *nlh); 1112 int (*ndo_change_carrier)(struct net_device *dev, 1113 bool new_carrier); 1114 int (*ndo_get_phys_port_id)(struct net_device *dev, 1115 struct netdev_phys_port_id *ppid); 1116 void (*ndo_add_vxlan_port)(struct net_device *dev, 1117 sa_family_t sa_family, 1118 __be16 port); 1119 void (*ndo_del_vxlan_port)(struct net_device *dev, 1120 sa_family_t sa_family, 1121 __be16 port); 1122 1123 void* (*ndo_dfwd_add_station)(struct net_device *pdev, 1124 struct net_device *dev); 1125 void (*ndo_dfwd_del_station)(struct net_device *pdev, 1126 void *priv); 1127 1128 netdev_tx_t (*ndo_dfwd_start_xmit) (struct sk_buff *skb, 1129 struct net_device *dev, 1130 void *priv); 1131 }; 1132 1133 /* 1134 * The DEVICE structure. 1135 * Actually, this whole structure is a big mistake. It mixes I/O 1136 * data with strictly "high-level" data, and it has to know about 1137 * almost every data structure used in the INET module. 1138 * 1139 * FIXME: cleanup struct net_device such that network protocol info 1140 * moves out. 1141 */ 1142 1143 struct net_device { 1144 1145 /* 1146 * This is the first field of the "visible" part of this structure 1147 * (i.e. as seen by users in the "Space.c" file). It is the name 1148 * of the interface. 1149 */ 1150 char name[IFNAMSIZ]; 1151 1152 /* device name hash chain, please keep it close to name[] */ 1153 struct hlist_node name_hlist; 1154 1155 /* snmp alias */ 1156 char *ifalias; 1157 1158 /* 1159 * I/O specific fields 1160 * FIXME: Merge these and struct ifmap into one 1161 */ 1162 unsigned long mem_end; /* shared mem end */ 1163 unsigned long mem_start; /* shared mem start */ 1164 unsigned long base_addr; /* device I/O address */ 1165 int irq; /* device IRQ number */ 1166 1167 /* 1168 * Some hardware also needs these fields, but they are not 1169 * part of the usual set specified in Space.c. 1170 */ 1171 1172 unsigned long state; 1173 1174 struct list_head dev_list; 1175 struct list_head napi_list; 1176 struct list_head unreg_list; 1177 struct list_head close_list; 1178 1179 /* directly linked devices, like slaves for bonding */ 1180 struct { 1181 struct list_head upper; 1182 struct list_head lower; 1183 } adj_list; 1184 1185 /* all linked devices, *including* neighbours */ 1186 struct { 1187 struct list_head upper; 1188 struct list_head lower; 1189 } all_adj_list; 1190 1191 1192 /* currently active device features */ 1193 netdev_features_t features; 1194 /* user-changeable features */ 1195 netdev_features_t hw_features; 1196 /* user-requested features */ 1197 netdev_features_t wanted_features; 1198 /* mask of features inheritable by VLAN devices */ 1199 netdev_features_t vlan_features; 1200 /* mask of features inherited by encapsulating devices 1201 * This field indicates what encapsulation offloads 1202 * the hardware is capable of doing, and drivers will 1203 * need to set them appropriately. 1204 */ 1205 netdev_features_t hw_enc_features; 1206 /* mask of fetures inheritable by MPLS */ 1207 netdev_features_t mpls_features; 1208 1209 /* Interface index. Unique device identifier */ 1210 int ifindex; 1211 int iflink; 1212 1213 struct net_device_stats stats; 1214 atomic_long_t rx_dropped; /* dropped packets by core network 1215 * Do not use this in drivers. 1216 */ 1217 1218 #ifdef CONFIG_WIRELESS_EXT 1219 /* List of functions to handle Wireless Extensions (instead of ioctl). 1220 * See <net/iw_handler.h> for details. Jean II */ 1221 const struct iw_handler_def * wireless_handlers; 1222 /* Instance data managed by the core of Wireless Extensions. */ 1223 struct iw_public_data * wireless_data; 1224 #endif 1225 /* Management operations */ 1226 const struct net_device_ops *netdev_ops; 1227 const struct ethtool_ops *ethtool_ops; 1228 const struct forwarding_accel_ops *fwd_ops; 1229 1230 /* Hardware header description */ 1231 const struct header_ops *header_ops; 1232 1233 unsigned int flags; /* interface flags (a la BSD) */ 1234 unsigned int priv_flags; /* Like 'flags' but invisible to userspace. 1235 * See if.h for definitions. */ 1236 unsigned short gflags; 1237 unsigned short padded; /* How much padding added by alloc_netdev() */ 1238 1239 unsigned char operstate; /* RFC2863 operstate */ 1240 unsigned char link_mode; /* mapping policy to operstate */ 1241 1242 unsigned char if_port; /* Selectable AUI, TP,..*/ 1243 unsigned char dma; /* DMA channel */ 1244 1245 unsigned int mtu; /* interface MTU value */ 1246 unsigned short type; /* interface hardware type */ 1247 unsigned short hard_header_len; /* hardware hdr length */ 1248 1249 /* extra head- and tailroom the hardware may need, but not in all cases 1250 * can this be guaranteed, especially tailroom. Some cases also use 1251 * LL_MAX_HEADER instead to allocate the skb. 1252 */ 1253 unsigned short needed_headroom; 1254 unsigned short needed_tailroom; 1255 1256 /* Interface address info. */ 1257 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */ 1258 unsigned char addr_assign_type; /* hw address assignment type */ 1259 unsigned char addr_len; /* hardware address length */ 1260 unsigned short neigh_priv_len; 1261 unsigned short dev_id; /* Used to differentiate devices 1262 * that share the same link 1263 * layer address 1264 */ 1265 spinlock_t addr_list_lock; 1266 struct netdev_hw_addr_list uc; /* Unicast mac addresses */ 1267 struct netdev_hw_addr_list mc; /* Multicast mac addresses */ 1268 struct netdev_hw_addr_list dev_addrs; /* list of device 1269 * hw addresses 1270 */ 1271 #ifdef CONFIG_SYSFS 1272 struct kset *queues_kset; 1273 #endif 1274 1275 bool uc_promisc; 1276 unsigned int promiscuity; 1277 unsigned int allmulti; 1278 1279 1280 /* Protocol specific pointers */ 1281 1282 #if IS_ENABLED(CONFIG_VLAN_8021Q) 1283 struct vlan_info __rcu *vlan_info; /* VLAN info */ 1284 #endif 1285 #if IS_ENABLED(CONFIG_NET_DSA) 1286 struct dsa_switch_tree *dsa_ptr; /* dsa specific data */ 1287 #endif 1288 void *atalk_ptr; /* AppleTalk link */ 1289 struct in_device __rcu *ip_ptr; /* IPv4 specific data */ 1290 struct dn_dev __rcu *dn_ptr; /* DECnet specific data */ 1291 struct inet6_dev __rcu *ip6_ptr; /* IPv6 specific data */ 1292 void *ax25_ptr; /* AX.25 specific data */ 1293 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data, 1294 assign before registering */ 1295 1296 /* 1297 * Cache lines mostly used on receive path (including eth_type_trans()) 1298 */ 1299 unsigned long last_rx; /* Time of last Rx 1300 * This should not be set in 1301 * drivers, unless really needed, 1302 * because network stack (bonding) 1303 * use it if/when necessary, to 1304 * avoid dirtying this cache line. 1305 */ 1306 1307 /* Interface address info used in eth_type_trans() */ 1308 unsigned char *dev_addr; /* hw address, (before bcast 1309 because most packets are 1310 unicast) */ 1311 1312 1313 #ifdef CONFIG_RPS 1314 struct netdev_rx_queue *_rx; 1315 1316 /* Number of RX queues allocated at register_netdev() time */ 1317 unsigned int num_rx_queues; 1318 1319 /* Number of RX queues currently active in device */ 1320 unsigned int real_num_rx_queues; 1321 1322 #endif 1323 1324 rx_handler_func_t __rcu *rx_handler; 1325 void __rcu *rx_handler_data; 1326 1327 struct netdev_queue __rcu *ingress_queue; 1328 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */ 1329 1330 1331 /* 1332 * Cache lines mostly used on transmit path 1333 */ 1334 struct netdev_queue *_tx ____cacheline_aligned_in_smp; 1335 1336 /* Number of TX queues allocated at alloc_netdev_mq() time */ 1337 unsigned int num_tx_queues; 1338 1339 /* Number of TX queues currently active in device */ 1340 unsigned int real_num_tx_queues; 1341 1342 /* root qdisc from userspace point of view */ 1343 struct Qdisc *qdisc; 1344 1345 unsigned long tx_queue_len; /* Max frames per queue allowed */ 1346 spinlock_t tx_global_lock; 1347 1348 #ifdef CONFIG_XPS 1349 struct xps_dev_maps __rcu *xps_maps; 1350 #endif 1351 #ifdef CONFIG_RFS_ACCEL 1352 /* CPU reverse-mapping for RX completion interrupts, indexed 1353 * by RX queue number. Assigned by driver. This must only be 1354 * set if the ndo_rx_flow_steer operation is defined. */ 1355 struct cpu_rmap *rx_cpu_rmap; 1356 #endif 1357 1358 /* These may be needed for future network-power-down code. */ 1359 1360 /* 1361 * trans_start here is expensive for high speed devices on SMP, 1362 * please use netdev_queue->trans_start instead. 1363 */ 1364 unsigned long trans_start; /* Time (in jiffies) of last Tx */ 1365 1366 int watchdog_timeo; /* used by dev_watchdog() */ 1367 struct timer_list watchdog_timer; 1368 1369 /* Number of references to this device */ 1370 int __percpu *pcpu_refcnt; 1371 1372 /* delayed register/unregister */ 1373 struct list_head todo_list; 1374 /* device index hash chain */ 1375 struct hlist_node index_hlist; 1376 1377 struct list_head link_watch_list; 1378 1379 /* register/unregister state machine */ 1380 enum { NETREG_UNINITIALIZED=0, 1381 NETREG_REGISTERED, /* completed register_netdevice */ 1382 NETREG_UNREGISTERING, /* called unregister_netdevice */ 1383 NETREG_UNREGISTERED, /* completed unregister todo */ 1384 NETREG_RELEASED, /* called free_netdev */ 1385 NETREG_DUMMY, /* dummy device for NAPI poll */ 1386 } reg_state:8; 1387 1388 bool dismantle; /* device is going do be freed */ 1389 1390 enum { 1391 RTNL_LINK_INITIALIZED, 1392 RTNL_LINK_INITIALIZING, 1393 } rtnl_link_state:16; 1394 1395 /* Called from unregister, can be used to call free_netdev */ 1396 void (*destructor)(struct net_device *dev); 1397 1398 #ifdef CONFIG_NETPOLL 1399 struct netpoll_info __rcu *npinfo; 1400 #endif 1401 1402 #ifdef CONFIG_NET_NS 1403 /* Network namespace this network device is inside */ 1404 struct net *nd_net; 1405 #endif 1406 1407 /* mid-layer private */ 1408 union { 1409 void *ml_priv; 1410 struct pcpu_lstats __percpu *lstats; /* loopback stats */ 1411 struct pcpu_tstats __percpu *tstats; /* tunnel stats */ 1412 struct pcpu_dstats __percpu *dstats; /* dummy stats */ 1413 struct pcpu_vstats __percpu *vstats; /* veth stats */ 1414 }; 1415 /* GARP */ 1416 struct garp_port __rcu *garp_port; 1417 /* MRP */ 1418 struct mrp_port __rcu *mrp_port; 1419 1420 /* class/net/name entry */ 1421 struct device dev; 1422 /* space for optional device, statistics, and wireless sysfs groups */ 1423 const struct attribute_group *sysfs_groups[4]; 1424 1425 /* rtnetlink link ops */ 1426 const struct rtnl_link_ops *rtnl_link_ops; 1427 1428 /* for setting kernel sock attribute on TCP connection setup */ 1429 #define GSO_MAX_SIZE 65536 1430 unsigned int gso_max_size; 1431 #define GSO_MAX_SEGS 65535 1432 u16 gso_max_segs; 1433 1434 #ifdef CONFIG_DCB 1435 /* Data Center Bridging netlink ops */ 1436 const struct dcbnl_rtnl_ops *dcbnl_ops; 1437 #endif 1438 u8 num_tc; 1439 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE]; 1440 u8 prio_tc_map[TC_BITMASK + 1]; 1441 1442 #if IS_ENABLED(CONFIG_FCOE) 1443 /* max exchange id for FCoE LRO by ddp */ 1444 unsigned int fcoe_ddp_xid; 1445 #endif 1446 #if IS_ENABLED(CONFIG_NETPRIO_CGROUP) 1447 struct netprio_map __rcu *priomap; 1448 #endif 1449 /* phy device may attach itself for hardware timestamping */ 1450 struct phy_device *phydev; 1451 1452 struct lock_class_key *qdisc_tx_busylock; 1453 1454 /* group the device belongs to */ 1455 int group; 1456 1457 struct pm_qos_request pm_qos_req; 1458 }; 1459 #define to_net_dev(d) container_of(d, struct net_device, dev) 1460 1461 #define NETDEV_ALIGN 32 1462 1463 static inline 1464 int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio) 1465 { 1466 return dev->prio_tc_map[prio & TC_BITMASK]; 1467 } 1468 1469 static inline 1470 int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc) 1471 { 1472 if (tc >= dev->num_tc) 1473 return -EINVAL; 1474 1475 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK; 1476 return 0; 1477 } 1478 1479 static inline 1480 void netdev_reset_tc(struct net_device *dev) 1481 { 1482 dev->num_tc = 0; 1483 memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq)); 1484 memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map)); 1485 } 1486 1487 static inline 1488 int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset) 1489 { 1490 if (tc >= dev->num_tc) 1491 return -EINVAL; 1492 1493 dev->tc_to_txq[tc].count = count; 1494 dev->tc_to_txq[tc].offset = offset; 1495 return 0; 1496 } 1497 1498 static inline 1499 int netdev_set_num_tc(struct net_device *dev, u8 num_tc) 1500 { 1501 if (num_tc > TC_MAX_QUEUE) 1502 return -EINVAL; 1503 1504 dev->num_tc = num_tc; 1505 return 0; 1506 } 1507 1508 static inline 1509 int netdev_get_num_tc(struct net_device *dev) 1510 { 1511 return dev->num_tc; 1512 } 1513 1514 static inline 1515 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev, 1516 unsigned int index) 1517 { 1518 return &dev->_tx[index]; 1519 } 1520 1521 static inline void netdev_for_each_tx_queue(struct net_device *dev, 1522 void (*f)(struct net_device *, 1523 struct netdev_queue *, 1524 void *), 1525 void *arg) 1526 { 1527 unsigned int i; 1528 1529 for (i = 0; i < dev->num_tx_queues; i++) 1530 f(dev, &dev->_tx[i], arg); 1531 } 1532 1533 struct netdev_queue *netdev_pick_tx(struct net_device *dev, 1534 struct sk_buff *skb, 1535 void *accel_priv); 1536 u16 __netdev_pick_tx(struct net_device *dev, struct sk_buff *skb); 1537 1538 /* 1539 * Net namespace inlines 1540 */ 1541 static inline 1542 struct net *dev_net(const struct net_device *dev) 1543 { 1544 return read_pnet(&dev->nd_net); 1545 } 1546 1547 static inline 1548 void dev_net_set(struct net_device *dev, struct net *net) 1549 { 1550 #ifdef CONFIG_NET_NS 1551 release_net(dev->nd_net); 1552 dev->nd_net = hold_net(net); 1553 #endif 1554 } 1555 1556 static inline bool netdev_uses_dsa_tags(struct net_device *dev) 1557 { 1558 #ifdef CONFIG_NET_DSA_TAG_DSA 1559 if (dev->dsa_ptr != NULL) 1560 return dsa_uses_dsa_tags(dev->dsa_ptr); 1561 #endif 1562 1563 return 0; 1564 } 1565 1566 static inline bool netdev_uses_trailer_tags(struct net_device *dev) 1567 { 1568 #ifdef CONFIG_NET_DSA_TAG_TRAILER 1569 if (dev->dsa_ptr != NULL) 1570 return dsa_uses_trailer_tags(dev->dsa_ptr); 1571 #endif 1572 1573 return 0; 1574 } 1575 1576 /** 1577 * netdev_priv - access network device private data 1578 * @dev: network device 1579 * 1580 * Get network device private data 1581 */ 1582 static inline void *netdev_priv(const struct net_device *dev) 1583 { 1584 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN); 1585 } 1586 1587 /* Set the sysfs physical device reference for the network logical device 1588 * if set prior to registration will cause a symlink during initialization. 1589 */ 1590 #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev)) 1591 1592 /* Set the sysfs device type for the network logical device to allow 1593 * fine-grained identification of different network device types. For 1594 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc. 1595 */ 1596 #define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype)) 1597 1598 /* Default NAPI poll() weight 1599 * Device drivers are strongly advised to not use bigger value 1600 */ 1601 #define NAPI_POLL_WEIGHT 64 1602 1603 /** 1604 * netif_napi_add - initialize a napi context 1605 * @dev: network device 1606 * @napi: napi context 1607 * @poll: polling function 1608 * @weight: default weight 1609 * 1610 * netif_napi_add() must be used to initialize a napi context prior to calling 1611 * *any* of the other napi related functions. 1612 */ 1613 void netif_napi_add(struct net_device *dev, struct napi_struct *napi, 1614 int (*poll)(struct napi_struct *, int), int weight); 1615 1616 /** 1617 * netif_napi_del - remove a napi context 1618 * @napi: napi context 1619 * 1620 * netif_napi_del() removes a napi context from the network device napi list 1621 */ 1622 void netif_napi_del(struct napi_struct *napi); 1623 1624 struct napi_gro_cb { 1625 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */ 1626 void *frag0; 1627 1628 /* Length of frag0. */ 1629 unsigned int frag0_len; 1630 1631 /* This indicates where we are processing relative to skb->data. */ 1632 int data_offset; 1633 1634 /* This is non-zero if the packet cannot be merged with the new skb. */ 1635 int flush; 1636 1637 /* Number of segments aggregated. */ 1638 u16 count; 1639 1640 /* This is non-zero if the packet may be of the same flow. */ 1641 u8 same_flow; 1642 1643 /* Free the skb? */ 1644 u8 free; 1645 #define NAPI_GRO_FREE 1 1646 #define NAPI_GRO_FREE_STOLEN_HEAD 2 1647 1648 /* jiffies when first packet was created/queued */ 1649 unsigned long age; 1650 1651 /* Used in ipv6_gro_receive() */ 1652 int proto; 1653 1654 /* used in skb_gro_receive() slow path */ 1655 struct sk_buff *last; 1656 }; 1657 1658 #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb) 1659 1660 struct packet_type { 1661 __be16 type; /* This is really htons(ether_type). */ 1662 struct net_device *dev; /* NULL is wildcarded here */ 1663 int (*func) (struct sk_buff *, 1664 struct net_device *, 1665 struct packet_type *, 1666 struct net_device *); 1667 bool (*id_match)(struct packet_type *ptype, 1668 struct sock *sk); 1669 void *af_packet_priv; 1670 struct list_head list; 1671 }; 1672 1673 struct offload_callbacks { 1674 struct sk_buff *(*gso_segment)(struct sk_buff *skb, 1675 netdev_features_t features); 1676 int (*gso_send_check)(struct sk_buff *skb); 1677 struct sk_buff **(*gro_receive)(struct sk_buff **head, 1678 struct sk_buff *skb); 1679 int (*gro_complete)(struct sk_buff *skb); 1680 }; 1681 1682 struct packet_offload { 1683 __be16 type; /* This is really htons(ether_type). */ 1684 struct offload_callbacks callbacks; 1685 struct list_head list; 1686 }; 1687 1688 #include <linux/notifier.h> 1689 1690 /* netdevice notifier chain. Please remember to update the rtnetlink 1691 * notification exclusion list in rtnetlink_event() when adding new 1692 * types. 1693 */ 1694 #define NETDEV_UP 0x0001 /* For now you can't veto a device up/down */ 1695 #define NETDEV_DOWN 0x0002 1696 #define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface 1697 detected a hardware crash and restarted 1698 - we can use this eg to kick tcp sessions 1699 once done */ 1700 #define NETDEV_CHANGE 0x0004 /* Notify device state change */ 1701 #define NETDEV_REGISTER 0x0005 1702 #define NETDEV_UNREGISTER 0x0006 1703 #define NETDEV_CHANGEMTU 0x0007 1704 #define NETDEV_CHANGEADDR 0x0008 1705 #define NETDEV_GOING_DOWN 0x0009 1706 #define NETDEV_CHANGENAME 0x000A 1707 #define NETDEV_FEAT_CHANGE 0x000B 1708 #define NETDEV_BONDING_FAILOVER 0x000C 1709 #define NETDEV_PRE_UP 0x000D 1710 #define NETDEV_PRE_TYPE_CHANGE 0x000E 1711 #define NETDEV_POST_TYPE_CHANGE 0x000F 1712 #define NETDEV_POST_INIT 0x0010 1713 #define NETDEV_UNREGISTER_FINAL 0x0011 1714 #define NETDEV_RELEASE 0x0012 1715 #define NETDEV_NOTIFY_PEERS 0x0013 1716 #define NETDEV_JOIN 0x0014 1717 #define NETDEV_CHANGEUPPER 0x0015 1718 #define NETDEV_RESEND_IGMP 0x0016 1719 1720 int register_netdevice_notifier(struct notifier_block *nb); 1721 int unregister_netdevice_notifier(struct notifier_block *nb); 1722 1723 struct netdev_notifier_info { 1724 struct net_device *dev; 1725 }; 1726 1727 struct netdev_notifier_change_info { 1728 struct netdev_notifier_info info; /* must be first */ 1729 unsigned int flags_changed; 1730 }; 1731 1732 static inline void netdev_notifier_info_init(struct netdev_notifier_info *info, 1733 struct net_device *dev) 1734 { 1735 info->dev = dev; 1736 } 1737 1738 static inline struct net_device * 1739 netdev_notifier_info_to_dev(const struct netdev_notifier_info *info) 1740 { 1741 return info->dev; 1742 } 1743 1744 int call_netdevice_notifiers_info(unsigned long val, struct net_device *dev, 1745 struct netdev_notifier_info *info); 1746 int call_netdevice_notifiers(unsigned long val, struct net_device *dev); 1747 1748 1749 extern rwlock_t dev_base_lock; /* Device list lock */ 1750 1751 #define for_each_netdev(net, d) \ 1752 list_for_each_entry(d, &(net)->dev_base_head, dev_list) 1753 #define for_each_netdev_reverse(net, d) \ 1754 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list) 1755 #define for_each_netdev_rcu(net, d) \ 1756 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list) 1757 #define for_each_netdev_safe(net, d, n) \ 1758 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list) 1759 #define for_each_netdev_continue(net, d) \ 1760 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list) 1761 #define for_each_netdev_continue_rcu(net, d) \ 1762 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list) 1763 #define for_each_netdev_in_bond_rcu(bond, slave) \ 1764 for_each_netdev_rcu(&init_net, slave) \ 1765 if (netdev_master_upper_dev_get_rcu(slave) == bond) 1766 #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list) 1767 1768 static inline struct net_device *next_net_device(struct net_device *dev) 1769 { 1770 struct list_head *lh; 1771 struct net *net; 1772 1773 net = dev_net(dev); 1774 lh = dev->dev_list.next; 1775 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1776 } 1777 1778 static inline struct net_device *next_net_device_rcu(struct net_device *dev) 1779 { 1780 struct list_head *lh; 1781 struct net *net; 1782 1783 net = dev_net(dev); 1784 lh = rcu_dereference(list_next_rcu(&dev->dev_list)); 1785 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1786 } 1787 1788 static inline struct net_device *first_net_device(struct net *net) 1789 { 1790 return list_empty(&net->dev_base_head) ? NULL : 1791 net_device_entry(net->dev_base_head.next); 1792 } 1793 1794 static inline struct net_device *first_net_device_rcu(struct net *net) 1795 { 1796 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head)); 1797 1798 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1799 } 1800 1801 int netdev_boot_setup_check(struct net_device *dev); 1802 unsigned long netdev_boot_base(const char *prefix, int unit); 1803 struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type, 1804 const char *hwaddr); 1805 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type); 1806 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type); 1807 void dev_add_pack(struct packet_type *pt); 1808 void dev_remove_pack(struct packet_type *pt); 1809 void __dev_remove_pack(struct packet_type *pt); 1810 void dev_add_offload(struct packet_offload *po); 1811 void dev_remove_offload(struct packet_offload *po); 1812 void __dev_remove_offload(struct packet_offload *po); 1813 1814 struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags, 1815 unsigned short mask); 1816 struct net_device *dev_get_by_name(struct net *net, const char *name); 1817 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name); 1818 struct net_device *__dev_get_by_name(struct net *net, const char *name); 1819 int dev_alloc_name(struct net_device *dev, const char *name); 1820 int dev_open(struct net_device *dev); 1821 int dev_close(struct net_device *dev); 1822 void dev_disable_lro(struct net_device *dev); 1823 int dev_loopback_xmit(struct sk_buff *newskb); 1824 int dev_queue_xmit(struct sk_buff *skb); 1825 int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv); 1826 int register_netdevice(struct net_device *dev); 1827 void unregister_netdevice_queue(struct net_device *dev, struct list_head *head); 1828 void unregister_netdevice_many(struct list_head *head); 1829 static inline void unregister_netdevice(struct net_device *dev) 1830 { 1831 unregister_netdevice_queue(dev, NULL); 1832 } 1833 1834 int netdev_refcnt_read(const struct net_device *dev); 1835 void free_netdev(struct net_device *dev); 1836 void netdev_freemem(struct net_device *dev); 1837 void synchronize_net(void); 1838 int init_dummy_netdev(struct net_device *dev); 1839 1840 struct net_device *dev_get_by_index(struct net *net, int ifindex); 1841 struct net_device *__dev_get_by_index(struct net *net, int ifindex); 1842 struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex); 1843 int netdev_get_name(struct net *net, char *name, int ifindex); 1844 int dev_restart(struct net_device *dev); 1845 #ifdef CONFIG_NETPOLL_TRAP 1846 int netpoll_trap(void); 1847 #endif 1848 int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb); 1849 1850 static inline unsigned int skb_gro_offset(const struct sk_buff *skb) 1851 { 1852 return NAPI_GRO_CB(skb)->data_offset; 1853 } 1854 1855 static inline unsigned int skb_gro_len(const struct sk_buff *skb) 1856 { 1857 return skb->len - NAPI_GRO_CB(skb)->data_offset; 1858 } 1859 1860 static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len) 1861 { 1862 NAPI_GRO_CB(skb)->data_offset += len; 1863 } 1864 1865 static inline void *skb_gro_header_fast(struct sk_buff *skb, 1866 unsigned int offset) 1867 { 1868 return NAPI_GRO_CB(skb)->frag0 + offset; 1869 } 1870 1871 static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen) 1872 { 1873 return NAPI_GRO_CB(skb)->frag0_len < hlen; 1874 } 1875 1876 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen, 1877 unsigned int offset) 1878 { 1879 if (!pskb_may_pull(skb, hlen)) 1880 return NULL; 1881 1882 NAPI_GRO_CB(skb)->frag0 = NULL; 1883 NAPI_GRO_CB(skb)->frag0_len = 0; 1884 return skb->data + offset; 1885 } 1886 1887 static inline void *skb_gro_mac_header(struct sk_buff *skb) 1888 { 1889 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb); 1890 } 1891 1892 static inline void *skb_gro_network_header(struct sk_buff *skb) 1893 { 1894 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) + 1895 skb_network_offset(skb); 1896 } 1897 1898 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev, 1899 unsigned short type, 1900 const void *daddr, const void *saddr, 1901 unsigned int len) 1902 { 1903 if (!dev->header_ops || !dev->header_ops->create) 1904 return 0; 1905 1906 return dev->header_ops->create(skb, dev, type, daddr, saddr, len); 1907 } 1908 1909 static inline int dev_parse_header(const struct sk_buff *skb, 1910 unsigned char *haddr) 1911 { 1912 const struct net_device *dev = skb->dev; 1913 1914 if (!dev->header_ops || !dev->header_ops->parse) 1915 return 0; 1916 return dev->header_ops->parse(skb, haddr); 1917 } 1918 1919 static inline int dev_rebuild_header(struct sk_buff *skb) 1920 { 1921 const struct net_device *dev = skb->dev; 1922 1923 if (!dev->header_ops || !dev->header_ops->rebuild) 1924 return 0; 1925 return dev->header_ops->rebuild(skb); 1926 } 1927 1928 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len); 1929 int register_gifconf(unsigned int family, gifconf_func_t *gifconf); 1930 static inline int unregister_gifconf(unsigned int family) 1931 { 1932 return register_gifconf(family, NULL); 1933 } 1934 1935 #ifdef CONFIG_NET_FLOW_LIMIT 1936 #define FLOW_LIMIT_HISTORY (1 << 7) /* must be ^2 and !overflow buckets */ 1937 struct sd_flow_limit { 1938 u64 count; 1939 unsigned int num_buckets; 1940 unsigned int history_head; 1941 u16 history[FLOW_LIMIT_HISTORY]; 1942 u8 buckets[]; 1943 }; 1944 1945 extern int netdev_flow_limit_table_len; 1946 #endif /* CONFIG_NET_FLOW_LIMIT */ 1947 1948 /* 1949 * Incoming packets are placed on per-cpu queues 1950 */ 1951 struct softnet_data { 1952 struct Qdisc *output_queue; 1953 struct Qdisc **output_queue_tailp; 1954 struct list_head poll_list; 1955 struct sk_buff *completion_queue; 1956 struct sk_buff_head process_queue; 1957 1958 /* stats */ 1959 unsigned int processed; 1960 unsigned int time_squeeze; 1961 unsigned int cpu_collision; 1962 unsigned int received_rps; 1963 1964 #ifdef CONFIG_RPS 1965 struct softnet_data *rps_ipi_list; 1966 1967 /* Elements below can be accessed between CPUs for RPS */ 1968 struct call_single_data csd ____cacheline_aligned_in_smp; 1969 struct softnet_data *rps_ipi_next; 1970 unsigned int cpu; 1971 unsigned int input_queue_head; 1972 unsigned int input_queue_tail; 1973 #endif 1974 unsigned int dropped; 1975 struct sk_buff_head input_pkt_queue; 1976 struct napi_struct backlog; 1977 1978 #ifdef CONFIG_NET_FLOW_LIMIT 1979 struct sd_flow_limit __rcu *flow_limit; 1980 #endif 1981 }; 1982 1983 static inline void input_queue_head_incr(struct softnet_data *sd) 1984 { 1985 #ifdef CONFIG_RPS 1986 sd->input_queue_head++; 1987 #endif 1988 } 1989 1990 static inline void input_queue_tail_incr_save(struct softnet_data *sd, 1991 unsigned int *qtail) 1992 { 1993 #ifdef CONFIG_RPS 1994 *qtail = ++sd->input_queue_tail; 1995 #endif 1996 } 1997 1998 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data); 1999 2000 void __netif_schedule(struct Qdisc *q); 2001 2002 static inline void netif_schedule_queue(struct netdev_queue *txq) 2003 { 2004 if (!(txq->state & QUEUE_STATE_ANY_XOFF)) 2005 __netif_schedule(txq->qdisc); 2006 } 2007 2008 static inline void netif_tx_schedule_all(struct net_device *dev) 2009 { 2010 unsigned int i; 2011 2012 for (i = 0; i < dev->num_tx_queues; i++) 2013 netif_schedule_queue(netdev_get_tx_queue(dev, i)); 2014 } 2015 2016 static inline void netif_tx_start_queue(struct netdev_queue *dev_queue) 2017 { 2018 clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state); 2019 } 2020 2021 /** 2022 * netif_start_queue - allow transmit 2023 * @dev: network device 2024 * 2025 * Allow upper layers to call the device hard_start_xmit routine. 2026 */ 2027 static inline void netif_start_queue(struct net_device *dev) 2028 { 2029 netif_tx_start_queue(netdev_get_tx_queue(dev, 0)); 2030 } 2031 2032 static inline void netif_tx_start_all_queues(struct net_device *dev) 2033 { 2034 unsigned int i; 2035 2036 for (i = 0; i < dev->num_tx_queues; i++) { 2037 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2038 netif_tx_start_queue(txq); 2039 } 2040 } 2041 2042 static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue) 2043 { 2044 #ifdef CONFIG_NETPOLL_TRAP 2045 if (netpoll_trap()) { 2046 netif_tx_start_queue(dev_queue); 2047 return; 2048 } 2049 #endif 2050 if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state)) 2051 __netif_schedule(dev_queue->qdisc); 2052 } 2053 2054 /** 2055 * netif_wake_queue - restart transmit 2056 * @dev: network device 2057 * 2058 * Allow upper layers to call the device hard_start_xmit routine. 2059 * Used for flow control when transmit resources are available. 2060 */ 2061 static inline void netif_wake_queue(struct net_device *dev) 2062 { 2063 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0)); 2064 } 2065 2066 static inline void netif_tx_wake_all_queues(struct net_device *dev) 2067 { 2068 unsigned int i; 2069 2070 for (i = 0; i < dev->num_tx_queues; i++) { 2071 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2072 netif_tx_wake_queue(txq); 2073 } 2074 } 2075 2076 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue) 2077 { 2078 if (WARN_ON(!dev_queue)) { 2079 pr_info("netif_stop_queue() cannot be called before register_netdev()\n"); 2080 return; 2081 } 2082 set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state); 2083 } 2084 2085 /** 2086 * netif_stop_queue - stop transmitted packets 2087 * @dev: network device 2088 * 2089 * Stop upper layers calling the device hard_start_xmit routine. 2090 * Used for flow control when transmit resources are unavailable. 2091 */ 2092 static inline void netif_stop_queue(struct net_device *dev) 2093 { 2094 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0)); 2095 } 2096 2097 static inline void netif_tx_stop_all_queues(struct net_device *dev) 2098 { 2099 unsigned int i; 2100 2101 for (i = 0; i < dev->num_tx_queues; i++) { 2102 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2103 netif_tx_stop_queue(txq); 2104 } 2105 } 2106 2107 static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue) 2108 { 2109 return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state); 2110 } 2111 2112 /** 2113 * netif_queue_stopped - test if transmit queue is flowblocked 2114 * @dev: network device 2115 * 2116 * Test if transmit queue on device is currently unable to send. 2117 */ 2118 static inline bool netif_queue_stopped(const struct net_device *dev) 2119 { 2120 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0)); 2121 } 2122 2123 static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue) 2124 { 2125 return dev_queue->state & QUEUE_STATE_ANY_XOFF; 2126 } 2127 2128 static inline bool netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue) 2129 { 2130 return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN; 2131 } 2132 2133 static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue, 2134 unsigned int bytes) 2135 { 2136 #ifdef CONFIG_BQL 2137 dql_queued(&dev_queue->dql, bytes); 2138 2139 if (likely(dql_avail(&dev_queue->dql) >= 0)) 2140 return; 2141 2142 set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state); 2143 2144 /* 2145 * The XOFF flag must be set before checking the dql_avail below, 2146 * because in netdev_tx_completed_queue we update the dql_completed 2147 * before checking the XOFF flag. 2148 */ 2149 smp_mb(); 2150 2151 /* check again in case another CPU has just made room avail */ 2152 if (unlikely(dql_avail(&dev_queue->dql) >= 0)) 2153 clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state); 2154 #endif 2155 } 2156 2157 /** 2158 * netdev_sent_queue - report the number of bytes queued to hardware 2159 * @dev: network device 2160 * @bytes: number of bytes queued to the hardware device queue 2161 * 2162 * Report the number of bytes queued for sending/completion to the network 2163 * device hardware queue. @bytes should be a good approximation and should 2164 * exactly match netdev_completed_queue() @bytes 2165 */ 2166 static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes) 2167 { 2168 netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes); 2169 } 2170 2171 static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue, 2172 unsigned int pkts, unsigned int bytes) 2173 { 2174 #ifdef CONFIG_BQL 2175 if (unlikely(!bytes)) 2176 return; 2177 2178 dql_completed(&dev_queue->dql, bytes); 2179 2180 /* 2181 * Without the memory barrier there is a small possiblity that 2182 * netdev_tx_sent_queue will miss the update and cause the queue to 2183 * be stopped forever 2184 */ 2185 smp_mb(); 2186 2187 if (dql_avail(&dev_queue->dql) < 0) 2188 return; 2189 2190 if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state)) 2191 netif_schedule_queue(dev_queue); 2192 #endif 2193 } 2194 2195 /** 2196 * netdev_completed_queue - report bytes and packets completed by device 2197 * @dev: network device 2198 * @pkts: actual number of packets sent over the medium 2199 * @bytes: actual number of bytes sent over the medium 2200 * 2201 * Report the number of bytes and packets transmitted by the network device 2202 * hardware queue over the physical medium, @bytes must exactly match the 2203 * @bytes amount passed to netdev_sent_queue() 2204 */ 2205 static inline void netdev_completed_queue(struct net_device *dev, 2206 unsigned int pkts, unsigned int bytes) 2207 { 2208 netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes); 2209 } 2210 2211 static inline void netdev_tx_reset_queue(struct netdev_queue *q) 2212 { 2213 #ifdef CONFIG_BQL 2214 clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state); 2215 dql_reset(&q->dql); 2216 #endif 2217 } 2218 2219 /** 2220 * netdev_reset_queue - reset the packets and bytes count of a network device 2221 * @dev_queue: network device 2222 * 2223 * Reset the bytes and packet count of a network device and clear the 2224 * software flow control OFF bit for this network device 2225 */ 2226 static inline void netdev_reset_queue(struct net_device *dev_queue) 2227 { 2228 netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0)); 2229 } 2230 2231 /** 2232 * netif_running - test if up 2233 * @dev: network device 2234 * 2235 * Test if the device has been brought up. 2236 */ 2237 static inline bool netif_running(const struct net_device *dev) 2238 { 2239 return test_bit(__LINK_STATE_START, &dev->state); 2240 } 2241 2242 /* 2243 * Routines to manage the subqueues on a device. We only need start 2244 * stop, and a check if it's stopped. All other device management is 2245 * done at the overall netdevice level. 2246 * Also test the device if we're multiqueue. 2247 */ 2248 2249 /** 2250 * netif_start_subqueue - allow sending packets on subqueue 2251 * @dev: network device 2252 * @queue_index: sub queue index 2253 * 2254 * Start individual transmit queue of a device with multiple transmit queues. 2255 */ 2256 static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index) 2257 { 2258 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index); 2259 2260 netif_tx_start_queue(txq); 2261 } 2262 2263 /** 2264 * netif_stop_subqueue - stop sending packets on subqueue 2265 * @dev: network device 2266 * @queue_index: sub queue index 2267 * 2268 * Stop individual transmit queue of a device with multiple transmit queues. 2269 */ 2270 static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index) 2271 { 2272 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index); 2273 #ifdef CONFIG_NETPOLL_TRAP 2274 if (netpoll_trap()) 2275 return; 2276 #endif 2277 netif_tx_stop_queue(txq); 2278 } 2279 2280 /** 2281 * netif_subqueue_stopped - test status of subqueue 2282 * @dev: network device 2283 * @queue_index: sub queue index 2284 * 2285 * Check individual transmit queue of a device with multiple transmit queues. 2286 */ 2287 static inline bool __netif_subqueue_stopped(const struct net_device *dev, 2288 u16 queue_index) 2289 { 2290 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index); 2291 2292 return netif_tx_queue_stopped(txq); 2293 } 2294 2295 static inline bool netif_subqueue_stopped(const struct net_device *dev, 2296 struct sk_buff *skb) 2297 { 2298 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb)); 2299 } 2300 2301 /** 2302 * netif_wake_subqueue - allow sending packets on subqueue 2303 * @dev: network device 2304 * @queue_index: sub queue index 2305 * 2306 * Resume individual transmit queue of a device with multiple transmit queues. 2307 */ 2308 static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index) 2309 { 2310 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index); 2311 #ifdef CONFIG_NETPOLL_TRAP 2312 if (netpoll_trap()) 2313 return; 2314 #endif 2315 if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &txq->state)) 2316 __netif_schedule(txq->qdisc); 2317 } 2318 2319 #ifdef CONFIG_XPS 2320 int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask, 2321 u16 index); 2322 #else 2323 static inline int netif_set_xps_queue(struct net_device *dev, 2324 const struct cpumask *mask, 2325 u16 index) 2326 { 2327 return 0; 2328 } 2329 #endif 2330 2331 /* 2332 * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used 2333 * as a distribution range limit for the returned value. 2334 */ 2335 static inline u16 skb_tx_hash(const struct net_device *dev, 2336 const struct sk_buff *skb) 2337 { 2338 return __skb_tx_hash(dev, skb, dev->real_num_tx_queues); 2339 } 2340 2341 /** 2342 * netif_is_multiqueue - test if device has multiple transmit queues 2343 * @dev: network device 2344 * 2345 * Check if device has multiple transmit queues 2346 */ 2347 static inline bool netif_is_multiqueue(const struct net_device *dev) 2348 { 2349 return dev->num_tx_queues > 1; 2350 } 2351 2352 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq); 2353 2354 #ifdef CONFIG_RPS 2355 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq); 2356 #else 2357 static inline int netif_set_real_num_rx_queues(struct net_device *dev, 2358 unsigned int rxq) 2359 { 2360 return 0; 2361 } 2362 #endif 2363 2364 static inline int netif_copy_real_num_queues(struct net_device *to_dev, 2365 const struct net_device *from_dev) 2366 { 2367 int err; 2368 2369 err = netif_set_real_num_tx_queues(to_dev, 2370 from_dev->real_num_tx_queues); 2371 if (err) 2372 return err; 2373 #ifdef CONFIG_RPS 2374 return netif_set_real_num_rx_queues(to_dev, 2375 from_dev->real_num_rx_queues); 2376 #else 2377 return 0; 2378 #endif 2379 } 2380 2381 #define DEFAULT_MAX_NUM_RSS_QUEUES (8) 2382 int netif_get_num_default_rss_queues(void); 2383 2384 /* Use this variant when it is known for sure that it 2385 * is executing from hardware interrupt context or with hardware interrupts 2386 * disabled. 2387 */ 2388 void dev_kfree_skb_irq(struct sk_buff *skb); 2389 2390 /* Use this variant in places where it could be invoked 2391 * from either hardware interrupt or other context, with hardware interrupts 2392 * either disabled or enabled. 2393 */ 2394 void dev_kfree_skb_any(struct sk_buff *skb); 2395 2396 int netif_rx(struct sk_buff *skb); 2397 int netif_rx_ni(struct sk_buff *skb); 2398 int netif_receive_skb(struct sk_buff *skb); 2399 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb); 2400 void napi_gro_flush(struct napi_struct *napi, bool flush_old); 2401 struct sk_buff *napi_get_frags(struct napi_struct *napi); 2402 gro_result_t napi_gro_frags(struct napi_struct *napi); 2403 2404 static inline void napi_free_frags(struct napi_struct *napi) 2405 { 2406 kfree_skb(napi->skb); 2407 napi->skb = NULL; 2408 } 2409 2410 int netdev_rx_handler_register(struct net_device *dev, 2411 rx_handler_func_t *rx_handler, 2412 void *rx_handler_data); 2413 void netdev_rx_handler_unregister(struct net_device *dev); 2414 2415 bool dev_valid_name(const char *name); 2416 int dev_ioctl(struct net *net, unsigned int cmd, void __user *); 2417 int dev_ethtool(struct net *net, struct ifreq *); 2418 unsigned int dev_get_flags(const struct net_device *); 2419 int __dev_change_flags(struct net_device *, unsigned int flags); 2420 int dev_change_flags(struct net_device *, unsigned int); 2421 void __dev_notify_flags(struct net_device *, unsigned int old_flags, 2422 unsigned int gchanges); 2423 int dev_change_name(struct net_device *, const char *); 2424 int dev_set_alias(struct net_device *, const char *, size_t); 2425 int dev_change_net_namespace(struct net_device *, struct net *, const char *); 2426 int dev_set_mtu(struct net_device *, int); 2427 void dev_set_group(struct net_device *, int); 2428 int dev_set_mac_address(struct net_device *, struct sockaddr *); 2429 int dev_change_carrier(struct net_device *, bool new_carrier); 2430 int dev_get_phys_port_id(struct net_device *dev, 2431 struct netdev_phys_port_id *ppid); 2432 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev, 2433 struct netdev_queue *txq); 2434 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb); 2435 2436 extern int netdev_budget; 2437 2438 /* Called by rtnetlink.c:rtnl_unlock() */ 2439 void netdev_run_todo(void); 2440 2441 /** 2442 * dev_put - release reference to device 2443 * @dev: network device 2444 * 2445 * Release reference to device to allow it to be freed. 2446 */ 2447 static inline void dev_put(struct net_device *dev) 2448 { 2449 this_cpu_dec(*dev->pcpu_refcnt); 2450 } 2451 2452 /** 2453 * dev_hold - get reference to device 2454 * @dev: network device 2455 * 2456 * Hold reference to device to keep it from being freed. 2457 */ 2458 static inline void dev_hold(struct net_device *dev) 2459 { 2460 this_cpu_inc(*dev->pcpu_refcnt); 2461 } 2462 2463 /* Carrier loss detection, dial on demand. The functions netif_carrier_on 2464 * and _off may be called from IRQ context, but it is caller 2465 * who is responsible for serialization of these calls. 2466 * 2467 * The name carrier is inappropriate, these functions should really be 2468 * called netif_lowerlayer_*() because they represent the state of any 2469 * kind of lower layer not just hardware media. 2470 */ 2471 2472 void linkwatch_init_dev(struct net_device *dev); 2473 void linkwatch_fire_event(struct net_device *dev); 2474 void linkwatch_forget_dev(struct net_device *dev); 2475 2476 /** 2477 * netif_carrier_ok - test if carrier present 2478 * @dev: network device 2479 * 2480 * Check if carrier is present on device 2481 */ 2482 static inline bool netif_carrier_ok(const struct net_device *dev) 2483 { 2484 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state); 2485 } 2486 2487 unsigned long dev_trans_start(struct net_device *dev); 2488 2489 void __netdev_watchdog_up(struct net_device *dev); 2490 2491 void netif_carrier_on(struct net_device *dev); 2492 2493 void netif_carrier_off(struct net_device *dev); 2494 2495 /** 2496 * netif_dormant_on - mark device as dormant. 2497 * @dev: network device 2498 * 2499 * Mark device as dormant (as per RFC2863). 2500 * 2501 * The dormant state indicates that the relevant interface is not 2502 * actually in a condition to pass packets (i.e., it is not 'up') but is 2503 * in a "pending" state, waiting for some external event. For "on- 2504 * demand" interfaces, this new state identifies the situation where the 2505 * interface is waiting for events to place it in the up state. 2506 * 2507 */ 2508 static inline void netif_dormant_on(struct net_device *dev) 2509 { 2510 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state)) 2511 linkwatch_fire_event(dev); 2512 } 2513 2514 /** 2515 * netif_dormant_off - set device as not dormant. 2516 * @dev: network device 2517 * 2518 * Device is not in dormant state. 2519 */ 2520 static inline void netif_dormant_off(struct net_device *dev) 2521 { 2522 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state)) 2523 linkwatch_fire_event(dev); 2524 } 2525 2526 /** 2527 * netif_dormant - test if carrier present 2528 * @dev: network device 2529 * 2530 * Check if carrier is present on device 2531 */ 2532 static inline bool netif_dormant(const struct net_device *dev) 2533 { 2534 return test_bit(__LINK_STATE_DORMANT, &dev->state); 2535 } 2536 2537 2538 /** 2539 * netif_oper_up - test if device is operational 2540 * @dev: network device 2541 * 2542 * Check if carrier is operational 2543 */ 2544 static inline bool netif_oper_up(const struct net_device *dev) 2545 { 2546 return (dev->operstate == IF_OPER_UP || 2547 dev->operstate == IF_OPER_UNKNOWN /* backward compat */); 2548 } 2549 2550 /** 2551 * netif_device_present - is device available or removed 2552 * @dev: network device 2553 * 2554 * Check if device has not been removed from system. 2555 */ 2556 static inline bool netif_device_present(struct net_device *dev) 2557 { 2558 return test_bit(__LINK_STATE_PRESENT, &dev->state); 2559 } 2560 2561 void netif_device_detach(struct net_device *dev); 2562 2563 void netif_device_attach(struct net_device *dev); 2564 2565 /* 2566 * Network interface message level settings 2567 */ 2568 2569 enum { 2570 NETIF_MSG_DRV = 0x0001, 2571 NETIF_MSG_PROBE = 0x0002, 2572 NETIF_MSG_LINK = 0x0004, 2573 NETIF_MSG_TIMER = 0x0008, 2574 NETIF_MSG_IFDOWN = 0x0010, 2575 NETIF_MSG_IFUP = 0x0020, 2576 NETIF_MSG_RX_ERR = 0x0040, 2577 NETIF_MSG_TX_ERR = 0x0080, 2578 NETIF_MSG_TX_QUEUED = 0x0100, 2579 NETIF_MSG_INTR = 0x0200, 2580 NETIF_MSG_TX_DONE = 0x0400, 2581 NETIF_MSG_RX_STATUS = 0x0800, 2582 NETIF_MSG_PKTDATA = 0x1000, 2583 NETIF_MSG_HW = 0x2000, 2584 NETIF_MSG_WOL = 0x4000, 2585 }; 2586 2587 #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV) 2588 #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE) 2589 #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK) 2590 #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER) 2591 #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN) 2592 #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP) 2593 #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR) 2594 #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR) 2595 #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED) 2596 #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR) 2597 #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE) 2598 #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS) 2599 #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA) 2600 #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW) 2601 #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL) 2602 2603 static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits) 2604 { 2605 /* use default */ 2606 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8)) 2607 return default_msg_enable_bits; 2608 if (debug_value == 0) /* no output */ 2609 return 0; 2610 /* set low N bits */ 2611 return (1 << debug_value) - 1; 2612 } 2613 2614 static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu) 2615 { 2616 spin_lock(&txq->_xmit_lock); 2617 txq->xmit_lock_owner = cpu; 2618 } 2619 2620 static inline void __netif_tx_lock_bh(struct netdev_queue *txq) 2621 { 2622 spin_lock_bh(&txq->_xmit_lock); 2623 txq->xmit_lock_owner = smp_processor_id(); 2624 } 2625 2626 static inline bool __netif_tx_trylock(struct netdev_queue *txq) 2627 { 2628 bool ok = spin_trylock(&txq->_xmit_lock); 2629 if (likely(ok)) 2630 txq->xmit_lock_owner = smp_processor_id(); 2631 return ok; 2632 } 2633 2634 static inline void __netif_tx_unlock(struct netdev_queue *txq) 2635 { 2636 txq->xmit_lock_owner = -1; 2637 spin_unlock(&txq->_xmit_lock); 2638 } 2639 2640 static inline void __netif_tx_unlock_bh(struct netdev_queue *txq) 2641 { 2642 txq->xmit_lock_owner = -1; 2643 spin_unlock_bh(&txq->_xmit_lock); 2644 } 2645 2646 static inline void txq_trans_update(struct netdev_queue *txq) 2647 { 2648 if (txq->xmit_lock_owner != -1) 2649 txq->trans_start = jiffies; 2650 } 2651 2652 /** 2653 * netif_tx_lock - grab network device transmit lock 2654 * @dev: network device 2655 * 2656 * Get network device transmit lock 2657 */ 2658 static inline void netif_tx_lock(struct net_device *dev) 2659 { 2660 unsigned int i; 2661 int cpu; 2662 2663 spin_lock(&dev->tx_global_lock); 2664 cpu = smp_processor_id(); 2665 for (i = 0; i < dev->num_tx_queues; i++) { 2666 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2667 2668 /* We are the only thread of execution doing a 2669 * freeze, but we have to grab the _xmit_lock in 2670 * order to synchronize with threads which are in 2671 * the ->hard_start_xmit() handler and already 2672 * checked the frozen bit. 2673 */ 2674 __netif_tx_lock(txq, cpu); 2675 set_bit(__QUEUE_STATE_FROZEN, &txq->state); 2676 __netif_tx_unlock(txq); 2677 } 2678 } 2679 2680 static inline void netif_tx_lock_bh(struct net_device *dev) 2681 { 2682 local_bh_disable(); 2683 netif_tx_lock(dev); 2684 } 2685 2686 static inline void netif_tx_unlock(struct net_device *dev) 2687 { 2688 unsigned int i; 2689 2690 for (i = 0; i < dev->num_tx_queues; i++) { 2691 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2692 2693 /* No need to grab the _xmit_lock here. If the 2694 * queue is not stopped for another reason, we 2695 * force a schedule. 2696 */ 2697 clear_bit(__QUEUE_STATE_FROZEN, &txq->state); 2698 netif_schedule_queue(txq); 2699 } 2700 spin_unlock(&dev->tx_global_lock); 2701 } 2702 2703 static inline void netif_tx_unlock_bh(struct net_device *dev) 2704 { 2705 netif_tx_unlock(dev); 2706 local_bh_enable(); 2707 } 2708 2709 #define HARD_TX_LOCK(dev, txq, cpu) { \ 2710 if ((dev->features & NETIF_F_LLTX) == 0) { \ 2711 __netif_tx_lock(txq, cpu); \ 2712 } \ 2713 } 2714 2715 #define HARD_TX_UNLOCK(dev, txq) { \ 2716 if ((dev->features & NETIF_F_LLTX) == 0) { \ 2717 __netif_tx_unlock(txq); \ 2718 } \ 2719 } 2720 2721 static inline void netif_tx_disable(struct net_device *dev) 2722 { 2723 unsigned int i; 2724 int cpu; 2725 2726 local_bh_disable(); 2727 cpu = smp_processor_id(); 2728 for (i = 0; i < dev->num_tx_queues; i++) { 2729 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2730 2731 __netif_tx_lock(txq, cpu); 2732 netif_tx_stop_queue(txq); 2733 __netif_tx_unlock(txq); 2734 } 2735 local_bh_enable(); 2736 } 2737 2738 static inline void netif_addr_lock(struct net_device *dev) 2739 { 2740 spin_lock(&dev->addr_list_lock); 2741 } 2742 2743 static inline void netif_addr_lock_nested(struct net_device *dev) 2744 { 2745 spin_lock_nested(&dev->addr_list_lock, SINGLE_DEPTH_NESTING); 2746 } 2747 2748 static inline void netif_addr_lock_bh(struct net_device *dev) 2749 { 2750 spin_lock_bh(&dev->addr_list_lock); 2751 } 2752 2753 static inline void netif_addr_unlock(struct net_device *dev) 2754 { 2755 spin_unlock(&dev->addr_list_lock); 2756 } 2757 2758 static inline void netif_addr_unlock_bh(struct net_device *dev) 2759 { 2760 spin_unlock_bh(&dev->addr_list_lock); 2761 } 2762 2763 /* 2764 * dev_addrs walker. Should be used only for read access. Call with 2765 * rcu_read_lock held. 2766 */ 2767 #define for_each_dev_addr(dev, ha) \ 2768 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list) 2769 2770 /* These functions live elsewhere (drivers/net/net_init.c, but related) */ 2771 2772 void ether_setup(struct net_device *dev); 2773 2774 /* Support for loadable net-drivers */ 2775 struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name, 2776 void (*setup)(struct net_device *), 2777 unsigned int txqs, unsigned int rxqs); 2778 #define alloc_netdev(sizeof_priv, name, setup) \ 2779 alloc_netdev_mqs(sizeof_priv, name, setup, 1, 1) 2780 2781 #define alloc_netdev_mq(sizeof_priv, name, setup, count) \ 2782 alloc_netdev_mqs(sizeof_priv, name, setup, count, count) 2783 2784 int register_netdev(struct net_device *dev); 2785 void unregister_netdev(struct net_device *dev); 2786 2787 /* General hardware address lists handling functions */ 2788 int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list, 2789 struct netdev_hw_addr_list *from_list, 2790 int addr_len, unsigned char addr_type); 2791 void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list, 2792 struct netdev_hw_addr_list *from_list, 2793 int addr_len, unsigned char addr_type); 2794 int __hw_addr_sync(struct netdev_hw_addr_list *to_list, 2795 struct netdev_hw_addr_list *from_list, int addr_len); 2796 void __hw_addr_unsync(struct netdev_hw_addr_list *to_list, 2797 struct netdev_hw_addr_list *from_list, int addr_len); 2798 void __hw_addr_flush(struct netdev_hw_addr_list *list); 2799 void __hw_addr_init(struct netdev_hw_addr_list *list); 2800 2801 /* Functions used for device addresses handling */ 2802 int dev_addr_add(struct net_device *dev, const unsigned char *addr, 2803 unsigned char addr_type); 2804 int dev_addr_del(struct net_device *dev, const unsigned char *addr, 2805 unsigned char addr_type); 2806 int dev_addr_add_multiple(struct net_device *to_dev, 2807 struct net_device *from_dev, unsigned char addr_type); 2808 int dev_addr_del_multiple(struct net_device *to_dev, 2809 struct net_device *from_dev, unsigned char addr_type); 2810 void dev_addr_flush(struct net_device *dev); 2811 int dev_addr_init(struct net_device *dev); 2812 2813 /* Functions used for unicast addresses handling */ 2814 int dev_uc_add(struct net_device *dev, const unsigned char *addr); 2815 int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr); 2816 int dev_uc_del(struct net_device *dev, const unsigned char *addr); 2817 int dev_uc_sync(struct net_device *to, struct net_device *from); 2818 int dev_uc_sync_multiple(struct net_device *to, struct net_device *from); 2819 void dev_uc_unsync(struct net_device *to, struct net_device *from); 2820 void dev_uc_flush(struct net_device *dev); 2821 void dev_uc_init(struct net_device *dev); 2822 2823 /* Functions used for multicast addresses handling */ 2824 int dev_mc_add(struct net_device *dev, const unsigned char *addr); 2825 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr); 2826 int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr); 2827 int dev_mc_del(struct net_device *dev, const unsigned char *addr); 2828 int dev_mc_del_global(struct net_device *dev, const unsigned char *addr); 2829 int dev_mc_sync(struct net_device *to, struct net_device *from); 2830 int dev_mc_sync_multiple(struct net_device *to, struct net_device *from); 2831 void dev_mc_unsync(struct net_device *to, struct net_device *from); 2832 void dev_mc_flush(struct net_device *dev); 2833 void dev_mc_init(struct net_device *dev); 2834 2835 /* Functions used for secondary unicast and multicast support */ 2836 void dev_set_rx_mode(struct net_device *dev); 2837 void __dev_set_rx_mode(struct net_device *dev); 2838 int dev_set_promiscuity(struct net_device *dev, int inc); 2839 int dev_set_allmulti(struct net_device *dev, int inc); 2840 void netdev_state_change(struct net_device *dev); 2841 void netdev_notify_peers(struct net_device *dev); 2842 void netdev_features_change(struct net_device *dev); 2843 /* Load a device via the kmod */ 2844 void dev_load(struct net *net, const char *name); 2845 struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev, 2846 struct rtnl_link_stats64 *storage); 2847 void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64, 2848 const struct net_device_stats *netdev_stats); 2849 2850 extern int netdev_max_backlog; 2851 extern int netdev_tstamp_prequeue; 2852 extern int weight_p; 2853 extern int bpf_jit_enable; 2854 2855 bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev); 2856 bool netdev_has_any_upper_dev(struct net_device *dev); 2857 struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev, 2858 struct list_head **iter); 2859 2860 /* iterate through upper list, must be called under RCU read lock */ 2861 #define netdev_for_each_all_upper_dev_rcu(dev, updev, iter) \ 2862 for (iter = &(dev)->all_adj_list.upper, \ 2863 updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)); \ 2864 updev; \ 2865 updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter))) 2866 2867 void *netdev_lower_get_next_private(struct net_device *dev, 2868 struct list_head **iter); 2869 void *netdev_lower_get_next_private_rcu(struct net_device *dev, 2870 struct list_head **iter); 2871 2872 #define netdev_for_each_lower_private(dev, priv, iter) \ 2873 for (iter = (dev)->adj_list.lower.next, \ 2874 priv = netdev_lower_get_next_private(dev, &(iter)); \ 2875 priv; \ 2876 priv = netdev_lower_get_next_private(dev, &(iter))) 2877 2878 #define netdev_for_each_lower_private_rcu(dev, priv, iter) \ 2879 for (iter = &(dev)->adj_list.lower, \ 2880 priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \ 2881 priv; \ 2882 priv = netdev_lower_get_next_private_rcu(dev, &(iter))) 2883 2884 void *netdev_adjacent_get_private(struct list_head *adj_list); 2885 struct net_device *netdev_master_upper_dev_get(struct net_device *dev); 2886 struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev); 2887 int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev); 2888 int netdev_master_upper_dev_link(struct net_device *dev, 2889 struct net_device *upper_dev); 2890 int netdev_master_upper_dev_link_private(struct net_device *dev, 2891 struct net_device *upper_dev, 2892 void *private); 2893 void netdev_upper_dev_unlink(struct net_device *dev, 2894 struct net_device *upper_dev); 2895 void *netdev_lower_dev_get_private_rcu(struct net_device *dev, 2896 struct net_device *lower_dev); 2897 void *netdev_lower_dev_get_private(struct net_device *dev, 2898 struct net_device *lower_dev); 2899 int skb_checksum_help(struct sk_buff *skb); 2900 struct sk_buff *__skb_gso_segment(struct sk_buff *skb, 2901 netdev_features_t features, bool tx_path); 2902 struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb, 2903 netdev_features_t features); 2904 2905 static inline 2906 struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features) 2907 { 2908 return __skb_gso_segment(skb, features, true); 2909 } 2910 __be16 skb_network_protocol(struct sk_buff *skb); 2911 2912 static inline bool can_checksum_protocol(netdev_features_t features, 2913 __be16 protocol) 2914 { 2915 return ((features & NETIF_F_GEN_CSUM) || 2916 ((features & NETIF_F_V4_CSUM) && 2917 protocol == htons(ETH_P_IP)) || 2918 ((features & NETIF_F_V6_CSUM) && 2919 protocol == htons(ETH_P_IPV6)) || 2920 ((features & NETIF_F_FCOE_CRC) && 2921 protocol == htons(ETH_P_FCOE))); 2922 } 2923 2924 #ifdef CONFIG_BUG 2925 void netdev_rx_csum_fault(struct net_device *dev); 2926 #else 2927 static inline void netdev_rx_csum_fault(struct net_device *dev) 2928 { 2929 } 2930 #endif 2931 /* rx skb timestamps */ 2932 void net_enable_timestamp(void); 2933 void net_disable_timestamp(void); 2934 2935 #ifdef CONFIG_PROC_FS 2936 int __init dev_proc_init(void); 2937 #else 2938 #define dev_proc_init() 0 2939 #endif 2940 2941 int netdev_class_create_file_ns(struct class_attribute *class_attr, 2942 const void *ns); 2943 void netdev_class_remove_file_ns(struct class_attribute *class_attr, 2944 const void *ns); 2945 2946 static inline int netdev_class_create_file(struct class_attribute *class_attr) 2947 { 2948 return netdev_class_create_file_ns(class_attr, NULL); 2949 } 2950 2951 static inline void netdev_class_remove_file(struct class_attribute *class_attr) 2952 { 2953 netdev_class_remove_file_ns(class_attr, NULL); 2954 } 2955 2956 extern struct kobj_ns_type_operations net_ns_type_operations; 2957 2958 const char *netdev_drivername(const struct net_device *dev); 2959 2960 void linkwatch_run_queue(void); 2961 2962 static inline netdev_features_t netdev_get_wanted_features( 2963 struct net_device *dev) 2964 { 2965 return (dev->features & ~dev->hw_features) | dev->wanted_features; 2966 } 2967 netdev_features_t netdev_increment_features(netdev_features_t all, 2968 netdev_features_t one, netdev_features_t mask); 2969 2970 /* Allow TSO being used on stacked device : 2971 * Performing the GSO segmentation before last device 2972 * is a performance improvement. 2973 */ 2974 static inline netdev_features_t netdev_add_tso_features(netdev_features_t features, 2975 netdev_features_t mask) 2976 { 2977 return netdev_increment_features(features, NETIF_F_ALL_TSO, mask); 2978 } 2979 2980 int __netdev_update_features(struct net_device *dev); 2981 void netdev_update_features(struct net_device *dev); 2982 void netdev_change_features(struct net_device *dev); 2983 2984 void netif_stacked_transfer_operstate(const struct net_device *rootdev, 2985 struct net_device *dev); 2986 2987 netdev_features_t netif_skb_features(struct sk_buff *skb); 2988 2989 static inline bool net_gso_ok(netdev_features_t features, int gso_type) 2990 { 2991 netdev_features_t feature = gso_type << NETIF_F_GSO_SHIFT; 2992 2993 /* check flags correspondence */ 2994 BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT)); 2995 BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_UFO >> NETIF_F_GSO_SHIFT)); 2996 BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT)); 2997 BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT)); 2998 BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT)); 2999 BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT)); 3000 3001 return (features & feature) == feature; 3002 } 3003 3004 static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features) 3005 { 3006 return net_gso_ok(features, skb_shinfo(skb)->gso_type) && 3007 (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST)); 3008 } 3009 3010 static inline bool netif_needs_gso(struct sk_buff *skb, 3011 netdev_features_t features) 3012 { 3013 return skb_is_gso(skb) && (!skb_gso_ok(skb, features) || 3014 unlikely((skb->ip_summed != CHECKSUM_PARTIAL) && 3015 (skb->ip_summed != CHECKSUM_UNNECESSARY))); 3016 } 3017 3018 static inline void netif_set_gso_max_size(struct net_device *dev, 3019 unsigned int size) 3020 { 3021 dev->gso_max_size = size; 3022 } 3023 3024 static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol, 3025 int pulled_hlen, u16 mac_offset, 3026 int mac_len) 3027 { 3028 skb->protocol = protocol; 3029 skb->encapsulation = 1; 3030 skb_push(skb, pulled_hlen); 3031 skb_reset_transport_header(skb); 3032 skb->mac_header = mac_offset; 3033 skb->network_header = skb->mac_header + mac_len; 3034 skb->mac_len = mac_len; 3035 } 3036 3037 static inline bool netif_is_macvlan(struct net_device *dev) 3038 { 3039 return dev->priv_flags & IFF_MACVLAN; 3040 } 3041 3042 static inline bool netif_is_bond_master(struct net_device *dev) 3043 { 3044 return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING; 3045 } 3046 3047 static inline bool netif_is_bond_slave(struct net_device *dev) 3048 { 3049 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING; 3050 } 3051 3052 static inline bool netif_supports_nofcs(struct net_device *dev) 3053 { 3054 return dev->priv_flags & IFF_SUPP_NOFCS; 3055 } 3056 3057 extern struct pernet_operations __net_initdata loopback_net_ops; 3058 3059 /* Logging, debugging and troubleshooting/diagnostic helpers. */ 3060 3061 /* netdev_printk helpers, similar to dev_printk */ 3062 3063 static inline const char *netdev_name(const struct net_device *dev) 3064 { 3065 if (dev->reg_state != NETREG_REGISTERED) 3066 return "(unregistered net_device)"; 3067 return dev->name; 3068 } 3069 3070 __printf(3, 4) 3071 int netdev_printk(const char *level, const struct net_device *dev, 3072 const char *format, ...); 3073 __printf(2, 3) 3074 int netdev_emerg(const struct net_device *dev, const char *format, ...); 3075 __printf(2, 3) 3076 int netdev_alert(const struct net_device *dev, const char *format, ...); 3077 __printf(2, 3) 3078 int netdev_crit(const struct net_device *dev, const char *format, ...); 3079 __printf(2, 3) 3080 int netdev_err(const struct net_device *dev, const char *format, ...); 3081 __printf(2, 3) 3082 int netdev_warn(const struct net_device *dev, const char *format, ...); 3083 __printf(2, 3) 3084 int netdev_notice(const struct net_device *dev, const char *format, ...); 3085 __printf(2, 3) 3086 int netdev_info(const struct net_device *dev, const char *format, ...); 3087 3088 #define MODULE_ALIAS_NETDEV(device) \ 3089 MODULE_ALIAS("netdev-" device) 3090 3091 #if defined(CONFIG_DYNAMIC_DEBUG) 3092 #define netdev_dbg(__dev, format, args...) \ 3093 do { \ 3094 dynamic_netdev_dbg(__dev, format, ##args); \ 3095 } while (0) 3096 #elif defined(DEBUG) 3097 #define netdev_dbg(__dev, format, args...) \ 3098 netdev_printk(KERN_DEBUG, __dev, format, ##args) 3099 #else 3100 #define netdev_dbg(__dev, format, args...) \ 3101 ({ \ 3102 if (0) \ 3103 netdev_printk(KERN_DEBUG, __dev, format, ##args); \ 3104 0; \ 3105 }) 3106 #endif 3107 3108 #if defined(VERBOSE_DEBUG) 3109 #define netdev_vdbg netdev_dbg 3110 #else 3111 3112 #define netdev_vdbg(dev, format, args...) \ 3113 ({ \ 3114 if (0) \ 3115 netdev_printk(KERN_DEBUG, dev, format, ##args); \ 3116 0; \ 3117 }) 3118 #endif 3119 3120 /* 3121 * netdev_WARN() acts like dev_printk(), but with the key difference 3122 * of using a WARN/WARN_ON to get the message out, including the 3123 * file/line information and a backtrace. 3124 */ 3125 #define netdev_WARN(dev, format, args...) \ 3126 WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args) 3127 3128 /* netif printk helpers, similar to netdev_printk */ 3129 3130 #define netif_printk(priv, type, level, dev, fmt, args...) \ 3131 do { \ 3132 if (netif_msg_##type(priv)) \ 3133 netdev_printk(level, (dev), fmt, ##args); \ 3134 } while (0) 3135 3136 #define netif_level(level, priv, type, dev, fmt, args...) \ 3137 do { \ 3138 if (netif_msg_##type(priv)) \ 3139 netdev_##level(dev, fmt, ##args); \ 3140 } while (0) 3141 3142 #define netif_emerg(priv, type, dev, fmt, args...) \ 3143 netif_level(emerg, priv, type, dev, fmt, ##args) 3144 #define netif_alert(priv, type, dev, fmt, args...) \ 3145 netif_level(alert, priv, type, dev, fmt, ##args) 3146 #define netif_crit(priv, type, dev, fmt, args...) \ 3147 netif_level(crit, priv, type, dev, fmt, ##args) 3148 #define netif_err(priv, type, dev, fmt, args...) \ 3149 netif_level(err, priv, type, dev, fmt, ##args) 3150 #define netif_warn(priv, type, dev, fmt, args...) \ 3151 netif_level(warn, priv, type, dev, fmt, ##args) 3152 #define netif_notice(priv, type, dev, fmt, args...) \ 3153 netif_level(notice, priv, type, dev, fmt, ##args) 3154 #define netif_info(priv, type, dev, fmt, args...) \ 3155 netif_level(info, priv, type, dev, fmt, ##args) 3156 3157 #if defined(CONFIG_DYNAMIC_DEBUG) 3158 #define netif_dbg(priv, type, netdev, format, args...) \ 3159 do { \ 3160 if (netif_msg_##type(priv)) \ 3161 dynamic_netdev_dbg(netdev, format, ##args); \ 3162 } while (0) 3163 #elif defined(DEBUG) 3164 #define netif_dbg(priv, type, dev, format, args...) \ 3165 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args) 3166 #else 3167 #define netif_dbg(priv, type, dev, format, args...) \ 3168 ({ \ 3169 if (0) \ 3170 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \ 3171 0; \ 3172 }) 3173 #endif 3174 3175 #if defined(VERBOSE_DEBUG) 3176 #define netif_vdbg netif_dbg 3177 #else 3178 #define netif_vdbg(priv, type, dev, format, args...) \ 3179 ({ \ 3180 if (0) \ 3181 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \ 3182 0; \ 3183 }) 3184 #endif 3185 3186 /* 3187 * The list of packet types we will receive (as opposed to discard) 3188 * and the routines to invoke. 3189 * 3190 * Why 16. Because with 16 the only overlap we get on a hash of the 3191 * low nibble of the protocol value is RARP/SNAP/X.25. 3192 * 3193 * NOTE: That is no longer true with the addition of VLAN tags. Not 3194 * sure which should go first, but I bet it won't make much 3195 * difference if we are running VLANs. The good news is that 3196 * this protocol won't be in the list unless compiled in, so 3197 * the average user (w/out VLANs) will not be adversely affected. 3198 * --BLG 3199 * 3200 * 0800 IP 3201 * 8100 802.1Q VLAN 3202 * 0001 802.3 3203 * 0002 AX.25 3204 * 0004 802.2 3205 * 8035 RARP 3206 * 0005 SNAP 3207 * 0805 X.25 3208 * 0806 ARP 3209 * 8137 IPX 3210 * 0009 Localtalk 3211 * 86DD IPv6 3212 */ 3213 #define PTYPE_HASH_SIZE (16) 3214 #define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1) 3215 3216 #endif /* _LINUX_NETDEVICE_H */ 3217