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