1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#ifndef _LINUX_NETDEVICE_H
22#define _LINUX_NETDEVICE_H
23
24#include <linux/timer.h>
25#include <linux/bug.h>
26#include <linux/delay.h>
27#include <linux/atomic.h>
28#include <linux/prefetch.h>
29#include <asm/cache.h>
30#include <asm/byteorder.h>
31
32#include <linux/percpu.h>
33#include <linux/rculist.h>
34#include <linux/workqueue.h>
35#include <linux/dynamic_queue_limits.h>
36
37#include <linux/ethtool.h>
38#include <net/net_namespace.h>
39#ifdef CONFIG_DCB
40#include <net/dcbnl.h>
41#endif
42#include <net/netprio_cgroup.h>
43#include <net/xdp.h>
44
45#include <linux/netdev_features.h>
46#include <linux/neighbour.h>
47#include <uapi/linux/netdevice.h>
48#include <uapi/linux/if_bonding.h>
49#include <uapi/linux/pkt_cls.h>
50#include <linux/hashtable.h>
51
52struct netpoll_info;
53struct device;
54struct phy_device;
55struct dsa_port;
56struct ip_tunnel_parm;
57struct macsec_context;
58struct macsec_ops;
59
60struct sfp_bus;
61
62struct wireless_dev;
63
64struct wpan_dev;
65struct mpls_dev;
66
67struct udp_tunnel_info;
68struct udp_tunnel_nic_info;
69struct udp_tunnel_nic;
70struct bpf_prog;
71struct xdp_buff;
72
73void netdev_set_default_ethtool_ops(struct net_device *dev,
74 const struct ethtool_ops *ops);
75
76
77#define NET_RX_SUCCESS 0
78#define NET_RX_DROP 1
79
80#define MAX_NEST_DEV 8
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100#define NET_XMIT_SUCCESS 0x00
101#define NET_XMIT_DROP 0x01
102#define NET_XMIT_CN 0x02
103#define NET_XMIT_MASK 0x0f
104
105
106
107
108#define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
109#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
110
111
112#define NETDEV_TX_MASK 0xf0
113
114enum netdev_tx {
115 __NETDEV_TX_MIN = INT_MIN,
116 NETDEV_TX_OK = 0x00,
117 NETDEV_TX_BUSY = 0x10,
118};
119typedef enum netdev_tx netdev_tx_t;
120
121
122
123
124
125static inline bool dev_xmit_complete(int rc)
126{
127
128
129
130
131
132
133 if (likely(rc < NET_XMIT_MASK))
134 return true;
135
136 return false;
137}
138
139
140
141
142
143
144#if defined(CONFIG_HYPERV_NET)
145# define LL_MAX_HEADER 128
146#elif defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
147# if defined(CONFIG_MAC80211_MESH)
148# define LL_MAX_HEADER 128
149# else
150# define LL_MAX_HEADER 96
151# endif
152#else
153# define LL_MAX_HEADER 32
154#endif
155
156#if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
157 !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)
158#define MAX_HEADER LL_MAX_HEADER
159#else
160#define MAX_HEADER (LL_MAX_HEADER + 48)
161#endif
162
163
164
165
166
167
168struct net_device_stats {
169 unsigned long rx_packets;
170 unsigned long tx_packets;
171 unsigned long rx_bytes;
172 unsigned long tx_bytes;
173 unsigned long rx_errors;
174 unsigned long tx_errors;
175 unsigned long rx_dropped;
176 unsigned long tx_dropped;
177 unsigned long multicast;
178 unsigned long collisions;
179 unsigned long rx_length_errors;
180 unsigned long rx_over_errors;
181 unsigned long rx_crc_errors;
182 unsigned long rx_frame_errors;
183 unsigned long rx_fifo_errors;
184 unsigned long rx_missed_errors;
185 unsigned long tx_aborted_errors;
186 unsigned long tx_carrier_errors;
187 unsigned long tx_fifo_errors;
188 unsigned long tx_heartbeat_errors;
189 unsigned long tx_window_errors;
190 unsigned long rx_compressed;
191 unsigned long tx_compressed;
192};
193
194
195#include <linux/cache.h>
196#include <linux/skbuff.h>
197
198#ifdef CONFIG_RPS
199#include <linux/static_key.h>
200extern struct static_key_false rps_needed;
201extern struct static_key_false rfs_needed;
202#endif
203
204struct neighbour;
205struct neigh_parms;
206struct sk_buff;
207
208struct netdev_hw_addr {
209 struct list_head list;
210 unsigned char addr[MAX_ADDR_LEN];
211 unsigned char type;
212#define NETDEV_HW_ADDR_T_LAN 1
213#define NETDEV_HW_ADDR_T_SAN 2
214#define NETDEV_HW_ADDR_T_SLAVE 3
215#define NETDEV_HW_ADDR_T_UNICAST 4
216#define NETDEV_HW_ADDR_T_MULTICAST 5
217 bool global_use;
218 int sync_cnt;
219 int refcount;
220 int synced;
221 struct rcu_head rcu_head;
222};
223
224struct netdev_hw_addr_list {
225 struct list_head list;
226 int count;
227};
228
229#define netdev_hw_addr_list_count(l) ((l)->count)
230#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
231#define netdev_hw_addr_list_for_each(ha, l) \
232 list_for_each_entry(ha, &(l)->list, list)
233
234#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
235#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
236#define netdev_for_each_uc_addr(ha, dev) \
237 netdev_hw_addr_list_for_each(ha, &(dev)->uc)
238
239#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
240#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
241#define netdev_for_each_mc_addr(ha, dev) \
242 netdev_hw_addr_list_for_each(ha, &(dev)->mc)
243
244struct hh_cache {
245 unsigned int hh_len;
246 seqlock_t hh_lock;
247
248
249#define HH_DATA_MOD 16
250#define HH_DATA_OFF(__len) \
251 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
252#define HH_DATA_ALIGN(__len) \
253 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
254 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
255};
256
257
258
259
260
261
262
263
264
265#define LL_RESERVED_SPACE(dev) \
266 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
267#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
268 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
269
270struct header_ops {
271 int (*create) (struct sk_buff *skb, struct net_device *dev,
272 unsigned short type, const void *daddr,
273 const void *saddr, unsigned int len);
274 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
275 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
276 void (*cache_update)(struct hh_cache *hh,
277 const struct net_device *dev,
278 const unsigned char *haddr);
279 bool (*validate)(const char *ll_header, unsigned int len);
280 __be16 (*parse_protocol)(const struct sk_buff *skb);
281};
282
283
284
285
286
287
288enum netdev_state_t {
289 __LINK_STATE_START,
290 __LINK_STATE_PRESENT,
291 __LINK_STATE_NOCARRIER,
292 __LINK_STATE_LINKWATCH_PENDING,
293 __LINK_STATE_DORMANT,
294 __LINK_STATE_TESTING,
295};
296
297
298
299
300
301
302struct netdev_boot_setup {
303 char name[IFNAMSIZ];
304 struct ifmap map;
305};
306#define NETDEV_BOOT_SETUP_MAX 8
307
308int __init netdev_boot_setup(char *str);
309
310struct gro_list {
311 struct list_head list;
312 int count;
313};
314
315
316
317
318
319#define GRO_HASH_BUCKETS 8
320
321
322
323
324struct napi_struct {
325
326
327
328
329
330
331 struct list_head poll_list;
332
333 unsigned long state;
334 int weight;
335 int defer_hard_irqs_count;
336 unsigned long gro_bitmask;
337 int (*poll)(struct napi_struct *, int);
338#ifdef CONFIG_NETPOLL
339 int poll_owner;
340#endif
341 struct net_device *dev;
342 struct gro_list gro_hash[GRO_HASH_BUCKETS];
343 struct sk_buff *skb;
344 struct list_head rx_list;
345 int rx_count;
346 struct hrtimer timer;
347 struct list_head dev_list;
348 struct hlist_node napi_hash_node;
349 unsigned int napi_id;
350};
351
352enum {
353 NAPI_STATE_SCHED,
354 NAPI_STATE_MISSED,
355 NAPI_STATE_DISABLE,
356 NAPI_STATE_NPSVC,
357 NAPI_STATE_HASHED,
358 NAPI_STATE_NO_BUSY_POLL,
359 NAPI_STATE_IN_BUSY_POLL,
360};
361
362enum {
363 NAPIF_STATE_SCHED = BIT(NAPI_STATE_SCHED),
364 NAPIF_STATE_MISSED = BIT(NAPI_STATE_MISSED),
365 NAPIF_STATE_DISABLE = BIT(NAPI_STATE_DISABLE),
366 NAPIF_STATE_NPSVC = BIT(NAPI_STATE_NPSVC),
367 NAPIF_STATE_HASHED = BIT(NAPI_STATE_HASHED),
368 NAPIF_STATE_NO_BUSY_POLL = BIT(NAPI_STATE_NO_BUSY_POLL),
369 NAPIF_STATE_IN_BUSY_POLL = BIT(NAPI_STATE_IN_BUSY_POLL),
370};
371
372enum gro_result {
373 GRO_MERGED,
374 GRO_MERGED_FREE,
375 GRO_HELD,
376 GRO_NORMAL,
377 GRO_DROP,
378 GRO_CONSUMED,
379};
380typedef enum gro_result gro_result_t;
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423enum rx_handler_result {
424 RX_HANDLER_CONSUMED,
425 RX_HANDLER_ANOTHER,
426 RX_HANDLER_EXACT,
427 RX_HANDLER_PASS,
428};
429typedef enum rx_handler_result rx_handler_result_t;
430typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
431
432void __napi_schedule(struct napi_struct *n);
433void __napi_schedule_irqoff(struct napi_struct *n);
434
435static inline bool napi_disable_pending(struct napi_struct *n)
436{
437 return test_bit(NAPI_STATE_DISABLE, &n->state);
438}
439
440bool napi_schedule_prep(struct napi_struct *n);
441
442
443
444
445
446
447
448
449static inline void napi_schedule(struct napi_struct *n)
450{
451 if (napi_schedule_prep(n))
452 __napi_schedule(n);
453}
454
455
456
457
458
459
460
461static inline void napi_schedule_irqoff(struct napi_struct *n)
462{
463 if (napi_schedule_prep(n))
464 __napi_schedule_irqoff(n);
465}
466
467
468static inline bool napi_reschedule(struct napi_struct *napi)
469{
470 if (napi_schedule_prep(napi)) {
471 __napi_schedule(napi);
472 return true;
473 }
474 return false;
475}
476
477bool napi_complete_done(struct napi_struct *n, int work_done);
478
479
480
481
482
483
484
485
486static inline bool napi_complete(struct napi_struct *n)
487{
488 return napi_complete_done(n, 0);
489}
490
491
492
493
494
495
496
497
498
499
500
501
502
503bool napi_hash_del(struct napi_struct *napi);
504
505
506
507
508
509
510
511
512void napi_disable(struct napi_struct *n);
513
514
515
516
517
518
519
520
521static inline void napi_enable(struct napi_struct *n)
522{
523 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
524 smp_mb__before_atomic();
525 clear_bit(NAPI_STATE_SCHED, &n->state);
526 clear_bit(NAPI_STATE_NPSVC, &n->state);
527}
528
529
530
531
532
533
534
535
536
537static inline void napi_synchronize(const struct napi_struct *n)
538{
539 if (IS_ENABLED(CONFIG_SMP))
540 while (test_bit(NAPI_STATE_SCHED, &n->state))
541 msleep(1);
542 else
543 barrier();
544}
545
546
547
548
549
550
551
552
553
554static inline bool napi_if_scheduled_mark_missed(struct napi_struct *n)
555{
556 unsigned long val, new;
557
558 do {
559 val = READ_ONCE(n->state);
560 if (val & NAPIF_STATE_DISABLE)
561 return true;
562
563 if (!(val & NAPIF_STATE_SCHED))
564 return false;
565
566 new = val | NAPIF_STATE_MISSED;
567 } while (cmpxchg(&n->state, val, new) != val);
568
569 return true;
570}
571
572enum netdev_queue_state_t {
573 __QUEUE_STATE_DRV_XOFF,
574 __QUEUE_STATE_STACK_XOFF,
575 __QUEUE_STATE_FROZEN,
576};
577
578#define QUEUE_STATE_DRV_XOFF (1 << __QUEUE_STATE_DRV_XOFF)
579#define QUEUE_STATE_STACK_XOFF (1 << __QUEUE_STATE_STACK_XOFF)
580#define QUEUE_STATE_FROZEN (1 << __QUEUE_STATE_FROZEN)
581
582#define QUEUE_STATE_ANY_XOFF (QUEUE_STATE_DRV_XOFF | QUEUE_STATE_STACK_XOFF)
583#define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
584 QUEUE_STATE_FROZEN)
585#define QUEUE_STATE_DRV_XOFF_OR_FROZEN (QUEUE_STATE_DRV_XOFF | \
586 QUEUE_STATE_FROZEN)
587
588
589
590
591
592
593
594
595
596
597
598struct netdev_queue {
599
600
601
602 struct net_device *dev;
603 struct Qdisc __rcu *qdisc;
604 struct Qdisc *qdisc_sleeping;
605#ifdef CONFIG_SYSFS
606 struct kobject kobj;
607#endif
608#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
609 int numa_node;
610#endif
611 unsigned long tx_maxrate;
612
613
614
615
616 unsigned long trans_timeout;
617
618
619 struct net_device *sb_dev;
620#ifdef CONFIG_XDP_SOCKETS
621 struct xdp_umem *umem;
622#endif
623
624
625
626 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
627 int xmit_lock_owner;
628
629
630
631 unsigned long trans_start;
632
633 unsigned long state;
634
635#ifdef CONFIG_BQL
636 struct dql dql;
637#endif
638} ____cacheline_aligned_in_smp;
639
640extern int sysctl_fb_tunnels_only_for_init_net;
641extern int sysctl_devconf_inherit_init_net;
642
643static inline bool net_has_fallback_tunnels(const struct net *net)
644{
645 return net == &init_net ||
646 !IS_ENABLED(CONFIG_SYSCTL) ||
647 !sysctl_fb_tunnels_only_for_init_net;
648}
649
650static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
651{
652#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
653 return q->numa_node;
654#else
655 return NUMA_NO_NODE;
656#endif
657}
658
659static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
660{
661#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
662 q->numa_node = node;
663#endif
664}
665
666#ifdef CONFIG_RPS
667
668
669
670
671struct rps_map {
672 unsigned int len;
673 struct rcu_head rcu;
674 u16 cpus[];
675};
676#define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + ((_num) * sizeof(u16)))
677
678
679
680
681
682
683struct rps_dev_flow {
684 u16 cpu;
685 u16 filter;
686 unsigned int last_qtail;
687};
688#define RPS_NO_FILTER 0xffff
689
690
691
692
693struct rps_dev_flow_table {
694 unsigned int mask;
695 struct rcu_head rcu;
696 struct rps_dev_flow flows[];
697};
698#define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
699 ((_num) * sizeof(struct rps_dev_flow)))
700
701
702
703
704
705
706
707
708
709
710
711struct rps_sock_flow_table {
712 u32 mask;
713
714 u32 ents[] ____cacheline_aligned_in_smp;
715};
716#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (offsetof(struct rps_sock_flow_table, ents[_num]))
717
718#define RPS_NO_CPU 0xffff
719
720extern u32 rps_cpu_mask;
721extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
722
723static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
724 u32 hash)
725{
726 if (table && hash) {
727 unsigned int index = hash & table->mask;
728 u32 val = hash & ~rps_cpu_mask;
729
730
731 val |= raw_smp_processor_id();
732
733 if (table->ents[index] != val)
734 table->ents[index] = val;
735 }
736}
737
738#ifdef CONFIG_RFS_ACCEL
739bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id,
740 u16 filter_id);
741#endif
742#endif
743
744
745struct netdev_rx_queue {
746#ifdef CONFIG_RPS
747 struct rps_map __rcu *rps_map;
748 struct rps_dev_flow_table __rcu *rps_flow_table;
749#endif
750 struct kobject kobj;
751 struct net_device *dev;
752 struct xdp_rxq_info xdp_rxq;
753#ifdef CONFIG_XDP_SOCKETS
754 struct xdp_umem *umem;
755#endif
756} ____cacheline_aligned_in_smp;
757
758
759
760
761struct rx_queue_attribute {
762 struct attribute attr;
763 ssize_t (*show)(struct netdev_rx_queue *queue, char *buf);
764 ssize_t (*store)(struct netdev_rx_queue *queue,
765 const char *buf, size_t len);
766};
767
768#ifdef CONFIG_XPS
769
770
771
772
773struct xps_map {
774 unsigned int len;
775 unsigned int alloc_len;
776 struct rcu_head rcu;
777 u16 queues[];
778};
779#define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16)))
780#define XPS_MIN_MAP_ALLOC ((L1_CACHE_ALIGN(offsetof(struct xps_map, queues[1])) \
781 - sizeof(struct xps_map)) / sizeof(u16))
782
783
784
785
786struct xps_dev_maps {
787 struct rcu_head rcu;
788 struct xps_map __rcu *attr_map[];
789};
790
791#define XPS_CPU_DEV_MAPS_SIZE(_tcs) (sizeof(struct xps_dev_maps) + \
792 (nr_cpu_ids * (_tcs) * sizeof(struct xps_map *)))
793
794#define XPS_RXQ_DEV_MAPS_SIZE(_tcs, _rxqs) (sizeof(struct xps_dev_maps) +\
795 (_rxqs * (_tcs) * sizeof(struct xps_map *)))
796
797#endif
798
799#define TC_MAX_QUEUE 16
800#define TC_BITMASK 15
801
802struct netdev_tc_txq {
803 u16 count;
804 u16 offset;
805};
806
807#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
808
809
810
811
812struct netdev_fcoe_hbainfo {
813 char manufacturer[64];
814 char serial_number[64];
815 char hardware_version[64];
816 char driver_version[64];
817 char optionrom_version[64];
818 char firmware_version[64];
819 char model[256];
820 char model_description[256];
821};
822#endif
823
824#define MAX_PHYS_ITEM_ID_LEN 32
825
826
827
828
829struct netdev_phys_item_id {
830 unsigned char id[MAX_PHYS_ITEM_ID_LEN];
831 unsigned char id_len;
832};
833
834static inline bool netdev_phys_item_id_same(struct netdev_phys_item_id *a,
835 struct netdev_phys_item_id *b)
836{
837 return a->id_len == b->id_len &&
838 memcmp(a->id, b->id, a->id_len) == 0;
839}
840
841typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
842 struct sk_buff *skb,
843 struct net_device *sb_dev);
844
845enum tc_setup_type {
846 TC_SETUP_QDISC_MQPRIO,
847 TC_SETUP_CLSU32,
848 TC_SETUP_CLSFLOWER,
849 TC_SETUP_CLSMATCHALL,
850 TC_SETUP_CLSBPF,
851 TC_SETUP_BLOCK,
852 TC_SETUP_QDISC_CBS,
853 TC_SETUP_QDISC_RED,
854 TC_SETUP_QDISC_PRIO,
855 TC_SETUP_QDISC_MQ,
856 TC_SETUP_QDISC_ETF,
857 TC_SETUP_ROOT_QDISC,
858 TC_SETUP_QDISC_GRED,
859 TC_SETUP_QDISC_TAPRIO,
860 TC_SETUP_FT,
861 TC_SETUP_QDISC_ETS,
862 TC_SETUP_QDISC_TBF,
863 TC_SETUP_QDISC_FIFO,
864};
865
866
867
868
869enum bpf_netdev_command {
870
871
872
873
874
875
876
877 XDP_SETUP_PROG,
878 XDP_SETUP_PROG_HW,
879
880 BPF_OFFLOAD_MAP_ALLOC,
881 BPF_OFFLOAD_MAP_FREE,
882 XDP_SETUP_XSK_UMEM,
883};
884
885struct bpf_prog_offload_ops;
886struct netlink_ext_ack;
887struct xdp_umem;
888struct xdp_dev_bulk_queue;
889struct bpf_xdp_link;
890
891enum bpf_xdp_mode {
892 XDP_MODE_SKB = 0,
893 XDP_MODE_DRV = 1,
894 XDP_MODE_HW = 2,
895 __MAX_XDP_MODE
896};
897
898struct bpf_xdp_entity {
899 struct bpf_prog *prog;
900 struct bpf_xdp_link *link;
901};
902
903struct netdev_bpf {
904 enum bpf_netdev_command command;
905 union {
906
907 struct {
908 u32 flags;
909 struct bpf_prog *prog;
910 struct netlink_ext_ack *extack;
911 };
912
913 struct {
914 struct bpf_offloaded_map *offmap;
915 };
916
917 struct {
918 struct xdp_umem *umem;
919 u16 queue_id;
920 } xsk;
921 };
922};
923
924
925#define XDP_WAKEUP_RX (1 << 0)
926#define XDP_WAKEUP_TX (1 << 1)
927
928#ifdef CONFIG_XFRM_OFFLOAD
929struct xfrmdev_ops {
930 int (*xdo_dev_state_add) (struct xfrm_state *x);
931 void (*xdo_dev_state_delete) (struct xfrm_state *x);
932 void (*xdo_dev_state_free) (struct xfrm_state *x);
933 bool (*xdo_dev_offload_ok) (struct sk_buff *skb,
934 struct xfrm_state *x);
935 void (*xdo_dev_state_advance_esn) (struct xfrm_state *x);
936};
937#endif
938
939struct dev_ifalias {
940 struct rcu_head rcuhead;
941 char ifalias[];
942};
943
944struct devlink;
945struct tlsdev_ops;
946
947struct netdev_name_node {
948 struct hlist_node hlist;
949 struct list_head list;
950 struct net_device *dev;
951 const char *name;
952};
953
954int netdev_name_node_alt_create(struct net_device *dev, const char *name);
955int netdev_name_node_alt_destroy(struct net_device *dev, const char *name);
956
957struct netdev_net_notifier {
958 struct list_head list;
959 struct notifier_block *nb;
960};
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289struct net_device_ops {
1290 int (*ndo_init)(struct net_device *dev);
1291 void (*ndo_uninit)(struct net_device *dev);
1292 int (*ndo_open)(struct net_device *dev);
1293 int (*ndo_stop)(struct net_device *dev);
1294 netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
1295 struct net_device *dev);
1296 netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
1297 struct net_device *dev,
1298 netdev_features_t features);
1299 u16 (*ndo_select_queue)(struct net_device *dev,
1300 struct sk_buff *skb,
1301 struct net_device *sb_dev);
1302 void (*ndo_change_rx_flags)(struct net_device *dev,
1303 int flags);
1304 void (*ndo_set_rx_mode)(struct net_device *dev);
1305 int (*ndo_set_mac_address)(struct net_device *dev,
1306 void *addr);
1307 int (*ndo_validate_addr)(struct net_device *dev);
1308 int (*ndo_do_ioctl)(struct net_device *dev,
1309 struct ifreq *ifr, int cmd);
1310 int (*ndo_set_config)(struct net_device *dev,
1311 struct ifmap *map);
1312 int (*ndo_change_mtu)(struct net_device *dev,
1313 int new_mtu);
1314 int (*ndo_neigh_setup)(struct net_device *dev,
1315 struct neigh_parms *);
1316 void (*ndo_tx_timeout) (struct net_device *dev,
1317 unsigned int txqueue);
1318
1319 void (*ndo_get_stats64)(struct net_device *dev,
1320 struct rtnl_link_stats64 *storage);
1321 bool (*ndo_has_offload_stats)(const struct net_device *dev, int attr_id);
1322 int (*ndo_get_offload_stats)(int attr_id,
1323 const struct net_device *dev,
1324 void *attr_data);
1325 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
1326
1327 int (*ndo_vlan_rx_add_vid)(struct net_device *dev,
1328 __be16 proto, u16 vid);
1329 int (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
1330 __be16 proto, u16 vid);
1331#ifdef CONFIG_NET_POLL_CONTROLLER
1332 void (*ndo_poll_controller)(struct net_device *dev);
1333 int (*ndo_netpoll_setup)(struct net_device *dev,
1334 struct netpoll_info *info);
1335 void (*ndo_netpoll_cleanup)(struct net_device *dev);
1336#endif
1337 int (*ndo_set_vf_mac)(struct net_device *dev,
1338 int queue, u8 *mac);
1339 int (*ndo_set_vf_vlan)(struct net_device *dev,
1340 int queue, u16 vlan,
1341 u8 qos, __be16 proto);
1342 int (*ndo_set_vf_rate)(struct net_device *dev,
1343 int vf, int min_tx_rate,
1344 int max_tx_rate);
1345 int (*ndo_set_vf_spoofchk)(struct net_device *dev,
1346 int vf, bool setting);
1347 int (*ndo_set_vf_trust)(struct net_device *dev,
1348 int vf, bool setting);
1349 int (*ndo_get_vf_config)(struct net_device *dev,
1350 int vf,
1351 struct ifla_vf_info *ivf);
1352 int (*ndo_set_vf_link_state)(struct net_device *dev,
1353 int vf, int link_state);
1354 int (*ndo_get_vf_stats)(struct net_device *dev,
1355 int vf,
1356 struct ifla_vf_stats
1357 *vf_stats);
1358 int (*ndo_set_vf_port)(struct net_device *dev,
1359 int vf,
1360 struct nlattr *port[]);
1361 int (*ndo_get_vf_port)(struct net_device *dev,
1362 int vf, struct sk_buff *skb);
1363 int (*ndo_get_vf_guid)(struct net_device *dev,
1364 int vf,
1365 struct ifla_vf_guid *node_guid,
1366 struct ifla_vf_guid *port_guid);
1367 int (*ndo_set_vf_guid)(struct net_device *dev,
1368 int vf, u64 guid,
1369 int guid_type);
1370 int (*ndo_set_vf_rss_query_en)(
1371 struct net_device *dev,
1372 int vf, bool setting);
1373 int (*ndo_setup_tc)(struct net_device *dev,
1374 enum tc_setup_type type,
1375 void *type_data);
1376#if IS_ENABLED(CONFIG_FCOE)
1377 int (*ndo_fcoe_enable)(struct net_device *dev);
1378 int (*ndo_fcoe_disable)(struct net_device *dev);
1379 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
1380 u16 xid,
1381 struct scatterlist *sgl,
1382 unsigned int sgc);
1383 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
1384 u16 xid);
1385 int (*ndo_fcoe_ddp_target)(struct net_device *dev,
1386 u16 xid,
1387 struct scatterlist *sgl,
1388 unsigned int sgc);
1389 int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
1390 struct netdev_fcoe_hbainfo *hbainfo);
1391#endif
1392
1393#if IS_ENABLED(CONFIG_LIBFCOE)
1394#define NETDEV_FCOE_WWNN 0
1395#define NETDEV_FCOE_WWPN 1
1396 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
1397 u64 *wwn, int type);
1398#endif
1399
1400#ifdef CONFIG_RFS_ACCEL
1401 int (*ndo_rx_flow_steer)(struct net_device *dev,
1402 const struct sk_buff *skb,
1403 u16 rxq_index,
1404 u32 flow_id);
1405#endif
1406 int (*ndo_add_slave)(struct net_device *dev,
1407 struct net_device *slave_dev,
1408 struct netlink_ext_ack *extack);
1409 int (*ndo_del_slave)(struct net_device *dev,
1410 struct net_device *slave_dev);
1411 struct net_device* (*ndo_get_xmit_slave)(struct net_device *dev,
1412 struct sk_buff *skb,
1413 bool all_slaves);
1414 netdev_features_t (*ndo_fix_features)(struct net_device *dev,
1415 netdev_features_t features);
1416 int (*ndo_set_features)(struct net_device *dev,
1417 netdev_features_t features);
1418 int (*ndo_neigh_construct)(struct net_device *dev,
1419 struct neighbour *n);
1420 void (*ndo_neigh_destroy)(struct net_device *dev,
1421 struct neighbour *n);
1422
1423 int (*ndo_fdb_add)(struct ndmsg *ndm,
1424 struct nlattr *tb[],
1425 struct net_device *dev,
1426 const unsigned char *addr,
1427 u16 vid,
1428 u16 flags,
1429 struct netlink_ext_ack *extack);
1430 int (*ndo_fdb_del)(struct ndmsg *ndm,
1431 struct nlattr *tb[],
1432 struct net_device *dev,
1433 const unsigned char *addr,
1434 u16 vid);
1435 int (*ndo_fdb_dump)(struct sk_buff *skb,
1436 struct netlink_callback *cb,
1437 struct net_device *dev,
1438 struct net_device *filter_dev,
1439 int *idx);
1440 int (*ndo_fdb_get)(struct sk_buff *skb,
1441 struct nlattr *tb[],
1442 struct net_device *dev,
1443 const unsigned char *addr,
1444 u16 vid, u32 portid, u32 seq,
1445 struct netlink_ext_ack *extack);
1446 int (*ndo_bridge_setlink)(struct net_device *dev,
1447 struct nlmsghdr *nlh,
1448 u16 flags,
1449 struct netlink_ext_ack *extack);
1450 int (*ndo_bridge_getlink)(struct sk_buff *skb,
1451 u32 pid, u32 seq,
1452 struct net_device *dev,
1453 u32 filter_mask,
1454 int nlflags);
1455 int (*ndo_bridge_dellink)(struct net_device *dev,
1456 struct nlmsghdr *nlh,
1457 u16 flags);
1458 int (*ndo_change_carrier)(struct net_device *dev,
1459 bool new_carrier);
1460 int (*ndo_get_phys_port_id)(struct net_device *dev,
1461 struct netdev_phys_item_id *ppid);
1462 int (*ndo_get_port_parent_id)(struct net_device *dev,
1463 struct netdev_phys_item_id *ppid);
1464 int (*ndo_get_phys_port_name)(struct net_device *dev,
1465 char *name, size_t len);
1466 void (*ndo_udp_tunnel_add)(struct net_device *dev,
1467 struct udp_tunnel_info *ti);
1468 void (*ndo_udp_tunnel_del)(struct net_device *dev,
1469 struct udp_tunnel_info *ti);
1470 void* (*ndo_dfwd_add_station)(struct net_device *pdev,
1471 struct net_device *dev);
1472 void (*ndo_dfwd_del_station)(struct net_device *pdev,
1473 void *priv);
1474
1475 int (*ndo_set_tx_maxrate)(struct net_device *dev,
1476 int queue_index,
1477 u32 maxrate);
1478 int (*ndo_get_iflink)(const struct net_device *dev);
1479 int (*ndo_change_proto_down)(struct net_device *dev,
1480 bool proto_down);
1481 int (*ndo_fill_metadata_dst)(struct net_device *dev,
1482 struct sk_buff *skb);
1483 void (*ndo_set_rx_headroom)(struct net_device *dev,
1484 int needed_headroom);
1485 int (*ndo_bpf)(struct net_device *dev,
1486 struct netdev_bpf *bpf);
1487 int (*ndo_xdp_xmit)(struct net_device *dev, int n,
1488 struct xdp_frame **xdp,
1489 u32 flags);
1490 int (*ndo_xsk_wakeup)(struct net_device *dev,
1491 u32 queue_id, u32 flags);
1492 struct devlink_port * (*ndo_get_devlink_port)(struct net_device *dev);
1493 int (*ndo_tunnel_ctl)(struct net_device *dev,
1494 struct ip_tunnel_parm *p, int cmd);
1495};
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543enum netdev_priv_flags {
1544 IFF_802_1Q_VLAN = 1<<0,
1545 IFF_EBRIDGE = 1<<1,
1546 IFF_BONDING = 1<<2,
1547 IFF_ISATAP = 1<<3,
1548 IFF_WAN_HDLC = 1<<4,
1549 IFF_XMIT_DST_RELEASE = 1<<5,
1550 IFF_DONT_BRIDGE = 1<<6,
1551 IFF_DISABLE_NETPOLL = 1<<7,
1552 IFF_MACVLAN_PORT = 1<<8,
1553 IFF_BRIDGE_PORT = 1<<9,
1554 IFF_OVS_DATAPATH = 1<<10,
1555 IFF_TX_SKB_SHARING = 1<<11,
1556 IFF_UNICAST_FLT = 1<<12,
1557 IFF_TEAM_PORT = 1<<13,
1558 IFF_SUPP_NOFCS = 1<<14,
1559 IFF_LIVE_ADDR_CHANGE = 1<<15,
1560 IFF_MACVLAN = 1<<16,
1561 IFF_XMIT_DST_RELEASE_PERM = 1<<17,
1562 IFF_L3MDEV_MASTER = 1<<18,
1563 IFF_NO_QUEUE = 1<<19,
1564 IFF_OPENVSWITCH = 1<<20,
1565 IFF_L3MDEV_SLAVE = 1<<21,
1566 IFF_TEAM = 1<<22,
1567 IFF_RXFH_CONFIGURED = 1<<23,
1568 IFF_PHONY_HEADROOM = 1<<24,
1569 IFF_MACSEC = 1<<25,
1570 IFF_NO_RX_HANDLER = 1<<26,
1571 IFF_FAILOVER = 1<<27,
1572 IFF_FAILOVER_SLAVE = 1<<28,
1573 IFF_L3MDEV_RX_HANDLER = 1<<29,
1574 IFF_LIVE_RENAME_OK = 1<<30,
1575};
1576
1577#define IFF_802_1Q_VLAN IFF_802_1Q_VLAN
1578#define IFF_EBRIDGE IFF_EBRIDGE
1579#define IFF_BONDING IFF_BONDING
1580#define IFF_ISATAP IFF_ISATAP
1581#define IFF_WAN_HDLC IFF_WAN_HDLC
1582#define IFF_XMIT_DST_RELEASE IFF_XMIT_DST_RELEASE
1583#define IFF_DONT_BRIDGE IFF_DONT_BRIDGE
1584#define IFF_DISABLE_NETPOLL IFF_DISABLE_NETPOLL
1585#define IFF_MACVLAN_PORT IFF_MACVLAN_PORT
1586#define IFF_BRIDGE_PORT IFF_BRIDGE_PORT
1587#define IFF_OVS_DATAPATH IFF_OVS_DATAPATH
1588#define IFF_TX_SKB_SHARING IFF_TX_SKB_SHARING
1589#define IFF_UNICAST_FLT IFF_UNICAST_FLT
1590#define IFF_TEAM_PORT IFF_TEAM_PORT
1591#define IFF_SUPP_NOFCS IFF_SUPP_NOFCS
1592#define IFF_LIVE_ADDR_CHANGE IFF_LIVE_ADDR_CHANGE
1593#define IFF_MACVLAN IFF_MACVLAN
1594#define IFF_XMIT_DST_RELEASE_PERM IFF_XMIT_DST_RELEASE_PERM
1595#define IFF_L3MDEV_MASTER IFF_L3MDEV_MASTER
1596#define IFF_NO_QUEUE IFF_NO_QUEUE
1597#define IFF_OPENVSWITCH IFF_OPENVSWITCH
1598#define IFF_L3MDEV_SLAVE IFF_L3MDEV_SLAVE
1599#define IFF_TEAM IFF_TEAM
1600#define IFF_RXFH_CONFIGURED IFF_RXFH_CONFIGURED
1601#define IFF_MACSEC IFF_MACSEC
1602#define IFF_NO_RX_HANDLER IFF_NO_RX_HANDLER
1603#define IFF_FAILOVER IFF_FAILOVER
1604#define IFF_FAILOVER_SLAVE IFF_FAILOVER_SLAVE
1605#define IFF_L3MDEV_RX_HANDLER IFF_L3MDEV_RX_HANDLER
1606#define IFF_LIVE_RENAME_OK IFF_LIVE_RENAME_OK
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863struct net_device {
1864 char name[IFNAMSIZ];
1865 struct netdev_name_node *name_node;
1866 struct dev_ifalias __rcu *ifalias;
1867
1868
1869
1870
1871 unsigned long mem_end;
1872 unsigned long mem_start;
1873 unsigned long base_addr;
1874 int irq;
1875
1876
1877
1878
1879
1880
1881
1882 unsigned long state;
1883
1884 struct list_head dev_list;
1885 struct list_head napi_list;
1886 struct list_head unreg_list;
1887 struct list_head close_list;
1888 struct list_head ptype_all;
1889 struct list_head ptype_specific;
1890
1891 struct {
1892 struct list_head upper;
1893 struct list_head lower;
1894 } adj_list;
1895
1896 netdev_features_t features;
1897 netdev_features_t hw_features;
1898 netdev_features_t wanted_features;
1899 netdev_features_t vlan_features;
1900 netdev_features_t hw_enc_features;
1901 netdev_features_t mpls_features;
1902 netdev_features_t gso_partial_features;
1903
1904 int ifindex;
1905 int group;
1906
1907 struct net_device_stats stats;
1908
1909 atomic_long_t rx_dropped;
1910 atomic_long_t tx_dropped;
1911 atomic_long_t rx_nohandler;
1912
1913
1914 atomic_t carrier_up_count;
1915 atomic_t carrier_down_count;
1916
1917#ifdef CONFIG_WIRELESS_EXT
1918 const struct iw_handler_def *wireless_handlers;
1919 struct iw_public_data *wireless_data;
1920#endif
1921 const struct net_device_ops *netdev_ops;
1922 const struct ethtool_ops *ethtool_ops;
1923#ifdef CONFIG_NET_L3_MASTER_DEV
1924 const struct l3mdev_ops *l3mdev_ops;
1925#endif
1926#if IS_ENABLED(CONFIG_IPV6)
1927 const struct ndisc_ops *ndisc_ops;
1928#endif
1929
1930#ifdef CONFIG_XFRM_OFFLOAD
1931 const struct xfrmdev_ops *xfrmdev_ops;
1932#endif
1933
1934#if IS_ENABLED(CONFIG_TLS_DEVICE)
1935 const struct tlsdev_ops *tlsdev_ops;
1936#endif
1937
1938 const struct header_ops *header_ops;
1939
1940 unsigned int flags;
1941 unsigned int priv_flags;
1942
1943 unsigned short gflags;
1944 unsigned short padded;
1945
1946 unsigned char operstate;
1947 unsigned char link_mode;
1948
1949 unsigned char if_port;
1950 unsigned char dma;
1951
1952
1953
1954
1955
1956
1957 unsigned int mtu;
1958 unsigned int min_mtu;
1959 unsigned int max_mtu;
1960 unsigned short type;
1961 unsigned short hard_header_len;
1962 unsigned char min_header_len;
1963 unsigned char name_assign_type;
1964
1965 unsigned short needed_headroom;
1966 unsigned short needed_tailroom;
1967
1968
1969 unsigned char perm_addr[MAX_ADDR_LEN];
1970 unsigned char addr_assign_type;
1971 unsigned char addr_len;
1972 unsigned char upper_level;
1973 unsigned char lower_level;
1974
1975 unsigned short neigh_priv_len;
1976 unsigned short dev_id;
1977 unsigned short dev_port;
1978 spinlock_t addr_list_lock;
1979
1980 struct netdev_hw_addr_list uc;
1981 struct netdev_hw_addr_list mc;
1982 struct netdev_hw_addr_list dev_addrs;
1983
1984#ifdef CONFIG_SYSFS
1985 struct kset *queues_kset;
1986#endif
1987#ifdef CONFIG_LOCKDEP
1988 struct list_head unlink_list;
1989#endif
1990 unsigned int promiscuity;
1991 unsigned int allmulti;
1992 bool uc_promisc;
1993#ifdef CONFIG_LOCKDEP
1994 unsigned char nested_level;
1995#endif
1996
1997
1998
1999
2000#if IS_ENABLED(CONFIG_VLAN_8021Q)
2001 struct vlan_info __rcu *vlan_info;
2002#endif
2003#if IS_ENABLED(CONFIG_NET_DSA)
2004 struct dsa_port *dsa_ptr;
2005#endif
2006#if IS_ENABLED(CONFIG_TIPC)
2007 struct tipc_bearer __rcu *tipc_ptr;
2008#endif
2009#if IS_ENABLED(CONFIG_IRDA) || IS_ENABLED(CONFIG_ATALK)
2010 void *atalk_ptr;
2011#endif
2012 struct in_device __rcu *ip_ptr;
2013#if IS_ENABLED(CONFIG_DECNET)
2014 struct dn_dev __rcu *dn_ptr;
2015#endif
2016 struct inet6_dev __rcu *ip6_ptr;
2017#if IS_ENABLED(CONFIG_AX25)
2018 void *ax25_ptr;
2019#endif
2020 struct wireless_dev *ieee80211_ptr;
2021 struct wpan_dev *ieee802154_ptr;
2022#if IS_ENABLED(CONFIG_MPLS_ROUTING)
2023 struct mpls_dev __rcu *mpls_ptr;
2024#endif
2025
2026
2027
2028
2029
2030 unsigned char *dev_addr;
2031
2032 struct netdev_rx_queue *_rx;
2033 unsigned int num_rx_queues;
2034 unsigned int real_num_rx_queues;
2035
2036 struct bpf_prog __rcu *xdp_prog;
2037 unsigned long gro_flush_timeout;
2038 int napi_defer_hard_irqs;
2039 rx_handler_func_t __rcu *rx_handler;
2040 void __rcu *rx_handler_data;
2041
2042#ifdef CONFIG_NET_CLS_ACT
2043 struct mini_Qdisc __rcu *miniq_ingress;
2044#endif
2045 struct netdev_queue __rcu *ingress_queue;
2046#ifdef CONFIG_NETFILTER_INGRESS
2047 struct nf_hook_entries __rcu *nf_hooks_ingress;
2048#endif
2049
2050 unsigned char broadcast[MAX_ADDR_LEN];
2051#ifdef CONFIG_RFS_ACCEL
2052 struct cpu_rmap *rx_cpu_rmap;
2053#endif
2054 struct hlist_node index_hlist;
2055
2056
2057
2058
2059 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
2060 unsigned int num_tx_queues;
2061 unsigned int real_num_tx_queues;
2062 struct Qdisc *qdisc;
2063 unsigned int tx_queue_len;
2064 spinlock_t tx_global_lock;
2065
2066 struct xdp_dev_bulk_queue __percpu *xdp_bulkq;
2067
2068#ifdef CONFIG_XPS
2069 struct xps_dev_maps __rcu *xps_cpus_map;
2070 struct xps_dev_maps __rcu *xps_rxqs_map;
2071#endif
2072#ifdef CONFIG_NET_CLS_ACT
2073 struct mini_Qdisc __rcu *miniq_egress;
2074#endif
2075
2076#ifdef CONFIG_NET_SCHED
2077 DECLARE_HASHTABLE (qdisc_hash, 4);
2078#endif
2079
2080 struct timer_list watchdog_timer;
2081 int watchdog_timeo;
2082
2083 u32 proto_down_reason;
2084
2085 struct list_head todo_list;
2086 int __percpu *pcpu_refcnt;
2087
2088 struct list_head link_watch_list;
2089
2090 enum { NETREG_UNINITIALIZED=0,
2091 NETREG_REGISTERED,
2092 NETREG_UNREGISTERING,
2093 NETREG_UNREGISTERED,
2094 NETREG_RELEASED,
2095 NETREG_DUMMY,
2096 } reg_state:8;
2097
2098 bool dismantle;
2099
2100 enum {
2101 RTNL_LINK_INITIALIZED,
2102 RTNL_LINK_INITIALIZING,
2103 } rtnl_link_state:16;
2104
2105 bool needs_free_netdev;
2106 void (*priv_destructor)(struct net_device *dev);
2107
2108#ifdef CONFIG_NETPOLL
2109 struct netpoll_info __rcu *npinfo;
2110#endif
2111
2112 possible_net_t nd_net;
2113
2114
2115 union {
2116 void *ml_priv;
2117 struct pcpu_lstats __percpu *lstats;
2118 struct pcpu_sw_netstats __percpu *tstats;
2119 struct pcpu_dstats __percpu *dstats;
2120 };
2121
2122#if IS_ENABLED(CONFIG_GARP)
2123 struct garp_port __rcu *garp_port;
2124#endif
2125#if IS_ENABLED(CONFIG_MRP)
2126 struct mrp_port __rcu *mrp_port;
2127#endif
2128
2129 struct device dev;
2130 const struct attribute_group *sysfs_groups[4];
2131 const struct attribute_group *sysfs_rx_queue_group;
2132
2133 const struct rtnl_link_ops *rtnl_link_ops;
2134
2135
2136#define GSO_MAX_SIZE 65536
2137 unsigned int gso_max_size;
2138#define GSO_MAX_SEGS 65535
2139 u16 gso_max_segs;
2140
2141#ifdef CONFIG_DCB
2142 const struct dcbnl_rtnl_ops *dcbnl_ops;
2143#endif
2144 s16 num_tc;
2145 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
2146 u8 prio_tc_map[TC_BITMASK + 1];
2147
2148#if IS_ENABLED(CONFIG_FCOE)
2149 unsigned int fcoe_ddp_xid;
2150#endif
2151#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
2152 struct netprio_map __rcu *priomap;
2153#endif
2154 struct phy_device *phydev;
2155 struct sfp_bus *sfp_bus;
2156 struct lock_class_key *qdisc_tx_busylock;
2157 struct lock_class_key *qdisc_running_key;
2158 bool proto_down;
2159 unsigned wol_enabled:1;
2160
2161 struct list_head net_notifier_list;
2162
2163#if IS_ENABLED(CONFIG_MACSEC)
2164
2165 const struct macsec_ops *macsec_ops;
2166#endif
2167 const struct udp_tunnel_nic_info *udp_tunnel_nic_info;
2168 struct udp_tunnel_nic *udp_tunnel_nic;
2169
2170
2171 struct bpf_xdp_entity xdp_state[__MAX_XDP_MODE];
2172};
2173#define to_net_dev(d) container_of(d, struct net_device, dev)
2174
2175static inline bool netif_elide_gro(const struct net_device *dev)
2176{
2177 if (!(dev->features & NETIF_F_GRO) || dev->xdp_prog)
2178 return true;
2179 return false;
2180}
2181
2182#define NETDEV_ALIGN 32
2183
2184static inline
2185int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
2186{
2187 return dev->prio_tc_map[prio & TC_BITMASK];
2188}
2189
2190static inline
2191int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
2192{
2193 if (tc >= dev->num_tc)
2194 return -EINVAL;
2195
2196 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
2197 return 0;
2198}
2199
2200int netdev_txq_to_tc(struct net_device *dev, unsigned int txq);
2201void netdev_reset_tc(struct net_device *dev);
2202int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset);
2203int netdev_set_num_tc(struct net_device *dev, u8 num_tc);
2204
2205static inline
2206int netdev_get_num_tc(struct net_device *dev)
2207{
2208 return dev->num_tc;
2209}
2210
2211void netdev_unbind_sb_channel(struct net_device *dev,
2212 struct net_device *sb_dev);
2213int netdev_bind_sb_channel_queue(struct net_device *dev,
2214 struct net_device *sb_dev,
2215 u8 tc, u16 count, u16 offset);
2216int netdev_set_sb_channel(struct net_device *dev, u16 channel);
2217static inline int netdev_get_sb_channel(struct net_device *dev)
2218{
2219 return max_t(int, -dev->num_tc, 0);
2220}
2221
2222static inline
2223struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
2224 unsigned int index)
2225{
2226 return &dev->_tx[index];
2227}
2228
2229static inline struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
2230 const struct sk_buff *skb)
2231{
2232 return netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
2233}
2234
2235static inline void netdev_for_each_tx_queue(struct net_device *dev,
2236 void (*f)(struct net_device *,
2237 struct netdev_queue *,
2238 void *),
2239 void *arg)
2240{
2241 unsigned int i;
2242
2243 for (i = 0; i < dev->num_tx_queues; i++)
2244 f(dev, &dev->_tx[i], arg);
2245}
2246
2247#define netdev_lockdep_set_classes(dev) \
2248{ \
2249 static struct lock_class_key qdisc_tx_busylock_key; \
2250 static struct lock_class_key qdisc_running_key; \
2251 static struct lock_class_key qdisc_xmit_lock_key; \
2252 static struct lock_class_key dev_addr_list_lock_key; \
2253 unsigned int i; \
2254 \
2255 (dev)->qdisc_tx_busylock = &qdisc_tx_busylock_key; \
2256 (dev)->qdisc_running_key = &qdisc_running_key; \
2257 lockdep_set_class(&(dev)->addr_list_lock, \
2258 &dev_addr_list_lock_key); \
2259 for (i = 0; i < (dev)->num_tx_queues; i++) \
2260 lockdep_set_class(&(dev)->_tx[i]._xmit_lock, \
2261 &qdisc_xmit_lock_key); \
2262}
2263
2264u16 netdev_pick_tx(struct net_device *dev, struct sk_buff *skb,
2265 struct net_device *sb_dev);
2266struct netdev_queue *netdev_core_pick_tx(struct net_device *dev,
2267 struct sk_buff *skb,
2268 struct net_device *sb_dev);
2269
2270
2271
2272
2273static inline unsigned netdev_get_fwd_headroom(struct net_device *dev)
2274{
2275 return dev->priv_flags & IFF_PHONY_HEADROOM ? 0 : dev->needed_headroom;
2276}
2277
2278static inline void netdev_set_rx_headroom(struct net_device *dev, int new_hr)
2279{
2280 if (dev->netdev_ops->ndo_set_rx_headroom)
2281 dev->netdev_ops->ndo_set_rx_headroom(dev, new_hr);
2282}
2283
2284
2285static inline void netdev_reset_rx_headroom(struct net_device *dev)
2286{
2287 netdev_set_rx_headroom(dev, -1);
2288}
2289
2290
2291
2292
2293static inline
2294struct net *dev_net(const struct net_device *dev)
2295{
2296 return read_pnet(&dev->nd_net);
2297}
2298
2299static inline
2300void dev_net_set(struct net_device *dev, struct net *net)
2301{
2302 write_pnet(&dev->nd_net, net);
2303}
2304
2305
2306
2307
2308
2309
2310
2311static inline void *netdev_priv(const struct net_device *dev)
2312{
2313 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
2314}
2315
2316
2317
2318
2319#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
2320
2321
2322
2323
2324
2325#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
2326
2327
2328
2329
2330#define NAPI_POLL_WEIGHT 64
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
2343 int (*poll)(struct napi_struct *, int), int weight);
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356static inline void netif_tx_napi_add(struct net_device *dev,
2357 struct napi_struct *napi,
2358 int (*poll)(struct napi_struct *, int),
2359 int weight)
2360{
2361 set_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state);
2362 netif_napi_add(dev, napi, poll, weight);
2363}
2364
2365
2366
2367
2368
2369
2370
2371void netif_napi_del(struct napi_struct *napi);
2372
2373struct napi_gro_cb {
2374
2375 void *frag0;
2376
2377
2378 unsigned int frag0_len;
2379
2380
2381 int data_offset;
2382
2383
2384 u16 flush;
2385
2386
2387 u16 flush_id;
2388
2389
2390 u16 count;
2391
2392
2393 u16 gro_remcsum_start;
2394
2395
2396 unsigned long age;
2397
2398
2399 u16 proto;
2400
2401
2402 u8 same_flow:1;
2403
2404
2405 u8 encap_mark:1;
2406
2407
2408 u8 csum_valid:1;
2409
2410
2411 u8 csum_cnt:3;
2412
2413
2414 u8 free:2;
2415#define NAPI_GRO_FREE 1
2416#define NAPI_GRO_FREE_STOLEN_HEAD 2
2417
2418
2419 u8 is_ipv6:1;
2420
2421
2422 u8 is_fou:1;
2423
2424
2425 u8 is_atomic:1;
2426
2427
2428 u8 recursion_counter:4;
2429
2430
2431 u8 is_flist:1;
2432
2433
2434 __wsum csum;
2435
2436
2437 struct sk_buff *last;
2438};
2439
2440#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
2441
2442#define GRO_RECURSION_LIMIT 15
2443static inline int gro_recursion_inc_test(struct sk_buff *skb)
2444{
2445 return ++NAPI_GRO_CB(skb)->recursion_counter == GRO_RECURSION_LIMIT;
2446}
2447
2448typedef struct sk_buff *(*gro_receive_t)(struct list_head *, struct sk_buff *);
2449static inline struct sk_buff *call_gro_receive(gro_receive_t cb,
2450 struct list_head *head,
2451 struct sk_buff *skb)
2452{
2453 if (unlikely(gro_recursion_inc_test(skb))) {
2454 NAPI_GRO_CB(skb)->flush |= 1;
2455 return NULL;
2456 }
2457
2458 return cb(head, skb);
2459}
2460
2461typedef struct sk_buff *(*gro_receive_sk_t)(struct sock *, struct list_head *,
2462 struct sk_buff *);
2463static inline struct sk_buff *call_gro_receive_sk(gro_receive_sk_t cb,
2464 struct sock *sk,
2465 struct list_head *head,
2466 struct sk_buff *skb)
2467{
2468 if (unlikely(gro_recursion_inc_test(skb))) {
2469 NAPI_GRO_CB(skb)->flush |= 1;
2470 return NULL;
2471 }
2472
2473 return cb(sk, head, skb);
2474}
2475
2476struct packet_type {
2477 __be16 type;
2478 bool ignore_outgoing;
2479 struct net_device *dev;
2480 int (*func) (struct sk_buff *,
2481 struct net_device *,
2482 struct packet_type *,
2483 struct net_device *);
2484 void (*list_func) (struct list_head *,
2485 struct packet_type *,
2486 struct net_device *);
2487 bool (*id_match)(struct packet_type *ptype,
2488 struct sock *sk);
2489 void *af_packet_priv;
2490 struct list_head list;
2491};
2492
2493struct offload_callbacks {
2494 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
2495 netdev_features_t features);
2496 struct sk_buff *(*gro_receive)(struct list_head *head,
2497 struct sk_buff *skb);
2498 int (*gro_complete)(struct sk_buff *skb, int nhoff);
2499};
2500
2501struct packet_offload {
2502 __be16 type;
2503 u16 priority;
2504 struct offload_callbacks callbacks;
2505 struct list_head list;
2506};
2507
2508
2509struct pcpu_sw_netstats {
2510 u64 rx_packets;
2511 u64 rx_bytes;
2512 u64 tx_packets;
2513 u64 tx_bytes;
2514 struct u64_stats_sync syncp;
2515} __aligned(4 * sizeof(u64));
2516
2517struct pcpu_lstats {
2518 u64_stats_t packets;
2519 u64_stats_t bytes;
2520 struct u64_stats_sync syncp;
2521} __aligned(2 * sizeof(u64));
2522
2523void dev_lstats_read(struct net_device *dev, u64 *packets, u64 *bytes);
2524
2525static inline void dev_lstats_add(struct net_device *dev, unsigned int len)
2526{
2527 struct pcpu_lstats *lstats = this_cpu_ptr(dev->lstats);
2528
2529 u64_stats_update_begin(&lstats->syncp);
2530 u64_stats_add(&lstats->bytes, len);
2531 u64_stats_inc(&lstats->packets);
2532 u64_stats_update_end(&lstats->syncp);
2533}
2534
2535#define __netdev_alloc_pcpu_stats(type, gfp) \
2536({ \
2537 typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
2538 if (pcpu_stats) { \
2539 int __cpu; \
2540 for_each_possible_cpu(__cpu) { \
2541 typeof(type) *stat; \
2542 stat = per_cpu_ptr(pcpu_stats, __cpu); \
2543 u64_stats_init(&stat->syncp); \
2544 } \
2545 } \
2546 pcpu_stats; \
2547})
2548
2549#define netdev_alloc_pcpu_stats(type) \
2550 __netdev_alloc_pcpu_stats(type, GFP_KERNEL)
2551
2552enum netdev_lag_tx_type {
2553 NETDEV_LAG_TX_TYPE_UNKNOWN,
2554 NETDEV_LAG_TX_TYPE_RANDOM,
2555 NETDEV_LAG_TX_TYPE_BROADCAST,
2556 NETDEV_LAG_TX_TYPE_ROUNDROBIN,
2557 NETDEV_LAG_TX_TYPE_ACTIVEBACKUP,
2558 NETDEV_LAG_TX_TYPE_HASH,
2559};
2560
2561enum netdev_lag_hash {
2562 NETDEV_LAG_HASH_NONE,
2563 NETDEV_LAG_HASH_L2,
2564 NETDEV_LAG_HASH_L34,
2565 NETDEV_LAG_HASH_L23,
2566 NETDEV_LAG_HASH_E23,
2567 NETDEV_LAG_HASH_E34,
2568 NETDEV_LAG_HASH_UNKNOWN,
2569};
2570
2571struct netdev_lag_upper_info {
2572 enum netdev_lag_tx_type tx_type;
2573 enum netdev_lag_hash hash_type;
2574};
2575
2576struct netdev_lag_lower_state_info {
2577 u8 link_up : 1,
2578 tx_enabled : 1;
2579};
2580
2581#include <linux/notifier.h>
2582
2583
2584
2585
2586
2587enum netdev_cmd {
2588 NETDEV_UP = 1,
2589 NETDEV_DOWN,
2590 NETDEV_REBOOT,
2591
2592
2593
2594 NETDEV_CHANGE,
2595 NETDEV_REGISTER,
2596 NETDEV_UNREGISTER,
2597 NETDEV_CHANGEMTU,
2598 NETDEV_CHANGEADDR,
2599 NETDEV_PRE_CHANGEADDR,
2600 NETDEV_GOING_DOWN,
2601 NETDEV_CHANGENAME,
2602 NETDEV_FEAT_CHANGE,
2603 NETDEV_BONDING_FAILOVER,
2604 NETDEV_PRE_UP,
2605 NETDEV_PRE_TYPE_CHANGE,
2606 NETDEV_POST_TYPE_CHANGE,
2607 NETDEV_POST_INIT,
2608 NETDEV_RELEASE,
2609 NETDEV_NOTIFY_PEERS,
2610 NETDEV_JOIN,
2611 NETDEV_CHANGEUPPER,
2612 NETDEV_RESEND_IGMP,
2613 NETDEV_PRECHANGEMTU,
2614 NETDEV_CHANGEINFODATA,
2615 NETDEV_BONDING_INFO,
2616 NETDEV_PRECHANGEUPPER,
2617 NETDEV_CHANGELOWERSTATE,
2618 NETDEV_UDP_TUNNEL_PUSH_INFO,
2619 NETDEV_UDP_TUNNEL_DROP_INFO,
2620 NETDEV_CHANGE_TX_QUEUE_LEN,
2621 NETDEV_CVLAN_FILTER_PUSH_INFO,
2622 NETDEV_CVLAN_FILTER_DROP_INFO,
2623 NETDEV_SVLAN_FILTER_PUSH_INFO,
2624 NETDEV_SVLAN_FILTER_DROP_INFO,
2625};
2626const char *netdev_cmd_to_name(enum netdev_cmd cmd);
2627
2628int register_netdevice_notifier(struct notifier_block *nb);
2629int unregister_netdevice_notifier(struct notifier_block *nb);
2630int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb);
2631int unregister_netdevice_notifier_net(struct net *net,
2632 struct notifier_block *nb);
2633int register_netdevice_notifier_dev_net(struct net_device *dev,
2634 struct notifier_block *nb,
2635 struct netdev_net_notifier *nn);
2636int unregister_netdevice_notifier_dev_net(struct net_device *dev,
2637 struct notifier_block *nb,
2638 struct netdev_net_notifier *nn);
2639
2640struct netdev_notifier_info {
2641 struct net_device *dev;
2642 struct netlink_ext_ack *extack;
2643};
2644
2645struct netdev_notifier_info_ext {
2646 struct netdev_notifier_info info;
2647 union {
2648 u32 mtu;
2649 } ext;
2650};
2651
2652struct netdev_notifier_change_info {
2653 struct netdev_notifier_info info;
2654 unsigned int flags_changed;
2655};
2656
2657struct netdev_notifier_changeupper_info {
2658 struct netdev_notifier_info info;
2659 struct net_device *upper_dev;
2660 bool master;
2661 bool linking;
2662 void *upper_info;
2663};
2664
2665struct netdev_notifier_changelowerstate_info {
2666 struct netdev_notifier_info info;
2667 void *lower_state_info;
2668};
2669
2670struct netdev_notifier_pre_changeaddr_info {
2671 struct netdev_notifier_info info;
2672 const unsigned char *dev_addr;
2673};
2674
2675static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
2676 struct net_device *dev)
2677{
2678 info->dev = dev;
2679 info->extack = NULL;
2680}
2681
2682static inline struct net_device *
2683netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
2684{
2685 return info->dev;
2686}
2687
2688static inline struct netlink_ext_ack *
2689netdev_notifier_info_to_extack(const struct netdev_notifier_info *info)
2690{
2691 return info->extack;
2692}
2693
2694int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
2695
2696
2697extern rwlock_t dev_base_lock;
2698
2699#define for_each_netdev(net, d) \
2700 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
2701#define for_each_netdev_reverse(net, d) \
2702 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
2703#define for_each_netdev_rcu(net, d) \
2704 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
2705#define for_each_netdev_safe(net, d, n) \
2706 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
2707#define for_each_netdev_continue(net, d) \
2708 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
2709#define for_each_netdev_continue_reverse(net, d) \
2710 list_for_each_entry_continue_reverse(d, &(net)->dev_base_head, \
2711 dev_list)
2712#define for_each_netdev_continue_rcu(net, d) \
2713 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
2714#define for_each_netdev_in_bond_rcu(bond, slave) \
2715 for_each_netdev_rcu(&init_net, slave) \
2716 if (netdev_master_upper_dev_get_rcu(slave) == (bond))
2717#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
2718
2719static inline struct net_device *next_net_device(struct net_device *dev)
2720{
2721 struct list_head *lh;
2722 struct net *net;
2723
2724 net = dev_net(dev);
2725 lh = dev->dev_list.next;
2726 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2727}
2728
2729static inline struct net_device *next_net_device_rcu(struct net_device *dev)
2730{
2731 struct list_head *lh;
2732 struct net *net;
2733
2734 net = dev_net(dev);
2735 lh = rcu_dereference(list_next_rcu(&dev->dev_list));
2736 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2737}
2738
2739static inline struct net_device *first_net_device(struct net *net)
2740{
2741 return list_empty(&net->dev_base_head) ? NULL :
2742 net_device_entry(net->dev_base_head.next);
2743}
2744
2745static inline struct net_device *first_net_device_rcu(struct net *net)
2746{
2747 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
2748
2749 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2750}
2751
2752int netdev_boot_setup_check(struct net_device *dev);
2753unsigned long netdev_boot_base(const char *prefix, int unit);
2754struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
2755 const char *hwaddr);
2756struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
2757struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
2758void dev_add_pack(struct packet_type *pt);
2759void dev_remove_pack(struct packet_type *pt);
2760void __dev_remove_pack(struct packet_type *pt);
2761void dev_add_offload(struct packet_offload *po);
2762void dev_remove_offload(struct packet_offload *po);
2763
2764int dev_get_iflink(const struct net_device *dev);
2765int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb);
2766struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
2767 unsigned short mask);
2768struct net_device *dev_get_by_name(struct net *net, const char *name);
2769struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
2770struct net_device *__dev_get_by_name(struct net *net, const char *name);
2771int dev_alloc_name(struct net_device *dev, const char *name);
2772int dev_open(struct net_device *dev, struct netlink_ext_ack *extack);
2773void dev_close(struct net_device *dev);
2774void dev_close_many(struct list_head *head, bool unlink);
2775void dev_disable_lro(struct net_device *dev);
2776int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *newskb);
2777u16 dev_pick_tx_zero(struct net_device *dev, struct sk_buff *skb,
2778 struct net_device *sb_dev);
2779u16 dev_pick_tx_cpu_id(struct net_device *dev, struct sk_buff *skb,
2780 struct net_device *sb_dev);
2781int dev_queue_xmit(struct sk_buff *skb);
2782int dev_queue_xmit_accel(struct sk_buff *skb, struct net_device *sb_dev);
2783int dev_direct_xmit(struct sk_buff *skb, u16 queue_id);
2784int register_netdevice(struct net_device *dev);
2785void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
2786void unregister_netdevice_many(struct list_head *head);
2787static inline void unregister_netdevice(struct net_device *dev)
2788{
2789 unregister_netdevice_queue(dev, NULL);
2790}
2791
2792int netdev_refcnt_read(const struct net_device *dev);
2793void free_netdev(struct net_device *dev);
2794void netdev_freemem(struct net_device *dev);
2795void synchronize_net(void);
2796int init_dummy_netdev(struct net_device *dev);
2797
2798struct net_device *netdev_get_xmit_slave(struct net_device *dev,
2799 struct sk_buff *skb,
2800 bool all_slaves);
2801struct net_device *dev_get_by_index(struct net *net, int ifindex);
2802struct net_device *__dev_get_by_index(struct net *net, int ifindex);
2803struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
2804struct net_device *dev_get_by_napi_id(unsigned int napi_id);
2805int netdev_get_name(struct net *net, char *name, int ifindex);
2806int dev_restart(struct net_device *dev);
2807int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb);
2808int skb_gro_receive_list(struct sk_buff *p, struct sk_buff *skb);
2809
2810static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
2811{
2812 return NAPI_GRO_CB(skb)->data_offset;
2813}
2814
2815static inline unsigned int skb_gro_len(const struct sk_buff *skb)
2816{
2817 return skb->len - NAPI_GRO_CB(skb)->data_offset;
2818}
2819
2820static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
2821{
2822 NAPI_GRO_CB(skb)->data_offset += len;
2823}
2824
2825static inline void *skb_gro_header_fast(struct sk_buff *skb,
2826 unsigned int offset)
2827{
2828 return NAPI_GRO_CB(skb)->frag0 + offset;
2829}
2830
2831static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
2832{
2833 return NAPI_GRO_CB(skb)->frag0_len < hlen;
2834}
2835
2836static inline void skb_gro_frag0_invalidate(struct sk_buff *skb)
2837{
2838 NAPI_GRO_CB(skb)->frag0 = NULL;
2839 NAPI_GRO_CB(skb)->frag0_len = 0;
2840}
2841
2842static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
2843 unsigned int offset)
2844{
2845 if (!pskb_may_pull(skb, hlen))
2846 return NULL;
2847
2848 skb_gro_frag0_invalidate(skb);
2849 return skb->data + offset;
2850}
2851
2852static inline void *skb_gro_network_header(struct sk_buff *skb)
2853{
2854 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
2855 skb_network_offset(skb);
2856}
2857
2858static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
2859 const void *start, unsigned int len)
2860{
2861 if (NAPI_GRO_CB(skb)->csum_valid)
2862 NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
2863 csum_partial(start, len, 0));
2864}
2865
2866
2867
2868
2869
2870
2871__sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
2872
2873static inline bool skb_at_gro_remcsum_start(struct sk_buff *skb)
2874{
2875 return (NAPI_GRO_CB(skb)->gro_remcsum_start == skb_gro_offset(skb));
2876}
2877
2878static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
2879 bool zero_okay,
2880 __sum16 check)
2881{
2882 return ((skb->ip_summed != CHECKSUM_PARTIAL ||
2883 skb_checksum_start_offset(skb) <
2884 skb_gro_offset(skb)) &&
2885 !skb_at_gro_remcsum_start(skb) &&
2886 NAPI_GRO_CB(skb)->csum_cnt == 0 &&
2887 (!zero_okay || check));
2888}
2889
2890static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
2891 __wsum psum)
2892{
2893 if (NAPI_GRO_CB(skb)->csum_valid &&
2894 !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
2895 return 0;
2896
2897 NAPI_GRO_CB(skb)->csum = psum;
2898
2899 return __skb_gro_checksum_complete(skb);
2900}
2901
2902static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
2903{
2904 if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
2905
2906 NAPI_GRO_CB(skb)->csum_cnt--;
2907 } else {
2908
2909
2910
2911
2912 __skb_incr_checksum_unnecessary(skb);
2913 }
2914}
2915
2916#define __skb_gro_checksum_validate(skb, proto, zero_okay, check, \
2917 compute_pseudo) \
2918({ \
2919 __sum16 __ret = 0; \
2920 if (__skb_gro_checksum_validate_needed(skb, zero_okay, check)) \
2921 __ret = __skb_gro_checksum_validate_complete(skb, \
2922 compute_pseudo(skb, proto)); \
2923 if (!__ret) \
2924 skb_gro_incr_csum_unnecessary(skb); \
2925 __ret; \
2926})
2927
2928#define skb_gro_checksum_validate(skb, proto, compute_pseudo) \
2929 __skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)
2930
2931#define skb_gro_checksum_validate_zero_check(skb, proto, check, \
2932 compute_pseudo) \
2933 __skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)
2934
2935#define skb_gro_checksum_simple_validate(skb) \
2936 __skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)
2937
2938static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
2939{
2940 return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
2941 !NAPI_GRO_CB(skb)->csum_valid);
2942}
2943
2944static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
2945 __wsum pseudo)
2946{
2947 NAPI_GRO_CB(skb)->csum = ~pseudo;
2948 NAPI_GRO_CB(skb)->csum_valid = 1;
2949}
2950
2951#define skb_gro_checksum_try_convert(skb, proto, compute_pseudo) \
2952do { \
2953 if (__skb_gro_checksum_convert_check(skb)) \
2954 __skb_gro_checksum_convert(skb, \
2955 compute_pseudo(skb, proto)); \
2956} while (0)
2957
2958struct gro_remcsum {
2959 int offset;
2960 __wsum delta;
2961};
2962
2963static inline void skb_gro_remcsum_init(struct gro_remcsum *grc)
2964{
2965 grc->offset = 0;
2966 grc->delta = 0;
2967}
2968
2969static inline void *skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
2970 unsigned int off, size_t hdrlen,
2971 int start, int offset,
2972 struct gro_remcsum *grc,
2973 bool nopartial)
2974{
2975 __wsum delta;
2976 size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);
2977
2978 BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);
2979
2980 if (!nopartial) {
2981 NAPI_GRO_CB(skb)->gro_remcsum_start = off + hdrlen + start;
2982 return ptr;
2983 }
2984
2985 ptr = skb_gro_header_fast(skb, off);
2986 if (skb_gro_header_hard(skb, off + plen)) {
2987 ptr = skb_gro_header_slow(skb, off + plen, off);
2988 if (!ptr)
2989 return NULL;
2990 }
2991
2992 delta = remcsum_adjust(ptr + hdrlen, NAPI_GRO_CB(skb)->csum,
2993 start, offset);
2994
2995
2996 NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);
2997
2998 grc->offset = off + hdrlen + offset;
2999 grc->delta = delta;
3000
3001 return ptr;
3002}
3003
3004static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
3005 struct gro_remcsum *grc)
3006{
3007 void *ptr;
3008 size_t plen = grc->offset + sizeof(u16);
3009
3010 if (!grc->delta)
3011 return;
3012
3013 ptr = skb_gro_header_fast(skb, grc->offset);
3014 if (skb_gro_header_hard(skb, grc->offset + sizeof(u16))) {
3015 ptr = skb_gro_header_slow(skb, plen, grc->offset);
3016 if (!ptr)
3017 return;
3018 }
3019
3020 remcsum_unadjust((__sum16 *)ptr, grc->delta);
3021}
3022
3023#ifdef CONFIG_XFRM_OFFLOAD
3024static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff *pp, int flush)
3025{
3026 if (PTR_ERR(pp) != -EINPROGRESS)
3027 NAPI_GRO_CB(skb)->flush |= flush;
3028}
3029static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
3030 struct sk_buff *pp,
3031 int flush,
3032 struct gro_remcsum *grc)
3033{
3034 if (PTR_ERR(pp) != -EINPROGRESS) {
3035 NAPI_GRO_CB(skb)->flush |= flush;
3036 skb_gro_remcsum_cleanup(skb, grc);
3037 skb->remcsum_offload = 0;
3038 }
3039}
3040#else
3041static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff *pp, int flush)
3042{
3043 NAPI_GRO_CB(skb)->flush |= flush;
3044}
3045static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
3046 struct sk_buff *pp,
3047 int flush,
3048 struct gro_remcsum *grc)
3049{
3050 NAPI_GRO_CB(skb)->flush |= flush;
3051 skb_gro_remcsum_cleanup(skb, grc);
3052 skb->remcsum_offload = 0;
3053}
3054#endif
3055
3056static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
3057 unsigned short type,
3058 const void *daddr, const void *saddr,
3059 unsigned int len)
3060{
3061 if (!dev->header_ops || !dev->header_ops->create)
3062 return 0;
3063
3064 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
3065}
3066
3067static inline int dev_parse_header(const struct sk_buff *skb,
3068 unsigned char *haddr)
3069{
3070 const struct net_device *dev = skb->dev;
3071
3072 if (!dev->header_ops || !dev->header_ops->parse)
3073 return 0;
3074 return dev->header_ops->parse(skb, haddr);
3075}
3076
3077static inline __be16 dev_parse_header_protocol(const struct sk_buff *skb)
3078{
3079 const struct net_device *dev = skb->dev;
3080
3081 if (!dev->header_ops || !dev->header_ops->parse_protocol)
3082 return 0;
3083 return dev->header_ops->parse_protocol(skb);
3084}
3085
3086
3087static inline bool dev_validate_header(const struct net_device *dev,
3088 char *ll_header, int len)
3089{
3090 if (likely(len >= dev->hard_header_len))
3091 return true;
3092 if (len < dev->min_header_len)
3093 return false;
3094
3095 if (capable(CAP_SYS_RAWIO)) {
3096 memset(ll_header + len, 0, dev->hard_header_len - len);
3097 return true;
3098 }
3099
3100 if (dev->header_ops && dev->header_ops->validate)
3101 return dev->header_ops->validate(ll_header, len);
3102
3103 return false;
3104}
3105
3106typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr,
3107 int len, int size);
3108int register_gifconf(unsigned int family, gifconf_func_t *gifconf);
3109static inline int unregister_gifconf(unsigned int family)
3110{
3111 return register_gifconf(family, NULL);
3112}
3113
3114#ifdef CONFIG_NET_FLOW_LIMIT
3115#define FLOW_LIMIT_HISTORY (1 << 7)
3116struct sd_flow_limit {
3117 u64 count;
3118 unsigned int num_buckets;
3119 unsigned int history_head;
3120 u16 history[FLOW_LIMIT_HISTORY];
3121 u8 buckets[];
3122};
3123
3124extern int netdev_flow_limit_table_len;
3125#endif
3126
3127
3128
3129
3130struct softnet_data {
3131 struct list_head poll_list;
3132 struct sk_buff_head process_queue;
3133
3134
3135 unsigned int processed;
3136 unsigned int time_squeeze;
3137 unsigned int received_rps;
3138#ifdef CONFIG_RPS
3139 struct softnet_data *rps_ipi_list;
3140#endif
3141#ifdef CONFIG_NET_FLOW_LIMIT
3142 struct sd_flow_limit __rcu *flow_limit;
3143#endif
3144 struct Qdisc *output_queue;
3145 struct Qdisc **output_queue_tailp;
3146 struct sk_buff *completion_queue;
3147#ifdef CONFIG_XFRM_OFFLOAD
3148 struct sk_buff_head xfrm_backlog;
3149#endif
3150
3151 struct {
3152 u16 recursion;
3153 u8 more;
3154 } xmit;
3155#ifdef CONFIG_RPS
3156
3157
3158
3159 unsigned int input_queue_head ____cacheline_aligned_in_smp;
3160
3161
3162 call_single_data_t csd ____cacheline_aligned_in_smp;
3163 struct softnet_data *rps_ipi_next;
3164 unsigned int cpu;
3165 unsigned int input_queue_tail;
3166#endif
3167 unsigned int dropped;
3168 struct sk_buff_head input_pkt_queue;
3169 struct napi_struct backlog;
3170
3171};
3172
3173static inline void input_queue_head_incr(struct softnet_data *sd)
3174{
3175#ifdef CONFIG_RPS
3176 sd->input_queue_head++;
3177#endif
3178}
3179
3180static inline void input_queue_tail_incr_save(struct softnet_data *sd,
3181 unsigned int *qtail)
3182{
3183#ifdef CONFIG_RPS
3184 *qtail = ++sd->input_queue_tail;
3185#endif
3186}
3187
3188DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
3189
3190static inline int dev_recursion_level(void)
3191{
3192 return this_cpu_read(softnet_data.xmit.recursion);
3193}
3194
3195#define XMIT_RECURSION_LIMIT 8
3196static inline bool dev_xmit_recursion(void)
3197{
3198 return unlikely(__this_cpu_read(softnet_data.xmit.recursion) >
3199 XMIT_RECURSION_LIMIT);
3200}
3201
3202static inline void dev_xmit_recursion_inc(void)
3203{
3204 __this_cpu_inc(softnet_data.xmit.recursion);
3205}
3206
3207static inline void dev_xmit_recursion_dec(void)
3208{
3209 __this_cpu_dec(softnet_data.xmit.recursion);
3210}
3211
3212void __netif_schedule(struct Qdisc *q);
3213void netif_schedule_queue(struct netdev_queue *txq);
3214
3215static inline void netif_tx_schedule_all(struct net_device *dev)
3216{
3217 unsigned int i;
3218
3219 for (i = 0; i < dev->num_tx_queues; i++)
3220 netif_schedule_queue(netdev_get_tx_queue(dev, i));
3221}
3222
3223static __always_inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
3224{
3225 clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
3226}
3227
3228
3229
3230
3231
3232
3233
3234static inline void netif_start_queue(struct net_device *dev)
3235{
3236 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
3237}
3238
3239static inline void netif_tx_start_all_queues(struct net_device *dev)
3240{
3241 unsigned int i;
3242
3243 for (i = 0; i < dev->num_tx_queues; i++) {
3244 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
3245 netif_tx_start_queue(txq);
3246 }
3247}
3248
3249void netif_tx_wake_queue(struct netdev_queue *dev_queue);
3250
3251
3252
3253
3254
3255
3256
3257
3258static inline void netif_wake_queue(struct net_device *dev)
3259{
3260 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
3261}
3262
3263static inline void netif_tx_wake_all_queues(struct net_device *dev)
3264{
3265 unsigned int i;
3266
3267 for (i = 0; i < dev->num_tx_queues; i++) {
3268 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
3269 netif_tx_wake_queue(txq);
3270 }
3271}
3272
3273static __always_inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
3274{
3275 set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
3276}
3277
3278
3279
3280
3281
3282
3283
3284
3285static inline void netif_stop_queue(struct net_device *dev)
3286{
3287 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
3288}
3289
3290void netif_tx_stop_all_queues(struct net_device *dev);
3291
3292static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
3293{
3294 return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
3295}
3296
3297
3298
3299
3300
3301
3302
3303static inline bool netif_queue_stopped(const struct net_device *dev)
3304{
3305 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
3306}
3307
3308static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
3309{
3310 return dev_queue->state & QUEUE_STATE_ANY_XOFF;
3311}
3312
3313static inline bool
3314netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
3315{
3316 return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
3317}
3318
3319static inline bool
3320netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
3321{
3322 return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
3323}
3324
3325
3326
3327
3328
3329
3330
3331
3332static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
3333{
3334#ifdef CONFIG_BQL
3335 prefetchw(&dev_queue->dql.num_queued);
3336#endif
3337}
3338
3339
3340
3341
3342
3343
3344
3345
3346static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
3347{
3348#ifdef CONFIG_BQL
3349 prefetchw(&dev_queue->dql.limit);
3350#endif
3351}
3352
3353static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
3354 unsigned int bytes)
3355{
3356#ifdef CONFIG_BQL
3357 dql_queued(&dev_queue->dql, bytes);
3358
3359 if (likely(dql_avail(&dev_queue->dql) >= 0))
3360 return;
3361
3362 set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
3363
3364
3365
3366
3367
3368
3369 smp_mb();
3370
3371
3372 if (unlikely(dql_avail(&dev_queue->dql) >= 0))
3373 clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
3374#endif
3375}
3376
3377
3378
3379
3380
3381
3382
3383static inline bool __netdev_tx_sent_queue(struct netdev_queue *dev_queue,
3384 unsigned int bytes,
3385 bool xmit_more)
3386{
3387 if (xmit_more) {
3388#ifdef CONFIG_BQL
3389 dql_queued(&dev_queue->dql, bytes);
3390#endif
3391 return netif_tx_queue_stopped(dev_queue);
3392 }
3393 netdev_tx_sent_queue(dev_queue, bytes);
3394 return true;
3395}
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
3407{
3408 netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes);
3409}
3410
3411static inline bool __netdev_sent_queue(struct net_device *dev,
3412 unsigned int bytes,
3413 bool xmit_more)
3414{
3415 return __netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes,
3416 xmit_more);
3417}
3418
3419static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
3420 unsigned int pkts, unsigned int bytes)
3421{
3422#ifdef CONFIG_BQL
3423 if (unlikely(!bytes))
3424 return;
3425
3426 dql_completed(&dev_queue->dql, bytes);
3427
3428
3429
3430
3431
3432
3433 smp_mb();
3434
3435 if (unlikely(dql_avail(&dev_queue->dql) < 0))
3436 return;
3437
3438 if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
3439 netif_schedule_queue(dev_queue);
3440#endif
3441}
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453static inline void netdev_completed_queue(struct net_device *dev,
3454 unsigned int pkts, unsigned int bytes)
3455{
3456 netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes);
3457}
3458
3459static inline void netdev_tx_reset_queue(struct netdev_queue *q)
3460{
3461#ifdef CONFIG_BQL
3462 clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
3463 dql_reset(&q->dql);
3464#endif
3465}
3466
3467
3468
3469
3470
3471
3472
3473
3474static inline void netdev_reset_queue(struct net_device *dev_queue)
3475{
3476 netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0));
3477}
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
3488{
3489 if (unlikely(queue_index >= dev->real_num_tx_queues)) {
3490 net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
3491 dev->name, queue_index,
3492 dev->real_num_tx_queues);
3493 return 0;
3494 }
3495
3496 return queue_index;
3497}
3498
3499
3500
3501
3502
3503
3504
3505static inline bool netif_running(const struct net_device *dev)
3506{
3507 return test_bit(__LINK_STATE_START, &dev->state);
3508}
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
3525{
3526 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
3527
3528 netif_tx_start_queue(txq);
3529}
3530
3531
3532
3533
3534
3535
3536
3537
3538static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
3539{
3540 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
3541 netif_tx_stop_queue(txq);
3542}
3543
3544
3545
3546
3547
3548
3549
3550
3551static inline bool __netif_subqueue_stopped(const struct net_device *dev,
3552 u16 queue_index)
3553{
3554 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
3555
3556 return netif_tx_queue_stopped(txq);
3557}
3558
3559static inline bool netif_subqueue_stopped(const struct net_device *dev,
3560 struct sk_buff *skb)
3561{
3562 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
3563}
3564
3565
3566
3567
3568
3569
3570
3571
3572static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
3573{
3574 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
3575
3576 netif_tx_wake_queue(txq);
3577}
3578
3579#ifdef CONFIG_XPS
3580int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
3581 u16 index);
3582int __netif_set_xps_queue(struct net_device *dev, const unsigned long *mask,
3583 u16 index, bool is_rxqs_map);
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593static inline bool netif_attr_test_mask(unsigned long j,
3594 const unsigned long *mask,
3595 unsigned int nr_bits)
3596{
3597 cpu_max_bits_warn(j, nr_bits);
3598 return test_bit(j, mask);
3599}
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609static inline bool netif_attr_test_online(unsigned long j,
3610 const unsigned long *online_mask,
3611 unsigned int nr_bits)
3612{
3613 cpu_max_bits_warn(j, nr_bits);
3614
3615 if (online_mask)
3616 return test_bit(j, online_mask);
3617
3618 return (j < nr_bits);
3619}
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629static inline unsigned int netif_attrmask_next(int n, const unsigned long *srcp,
3630 unsigned int nr_bits)
3631{
3632
3633 if (n != -1)
3634 cpu_max_bits_warn(n, nr_bits);
3635
3636 if (srcp)
3637 return find_next_bit(srcp, nr_bits, n + 1);
3638
3639 return n + 1;
3640}
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651static inline int netif_attrmask_next_and(int n, const unsigned long *src1p,
3652 const unsigned long *src2p,
3653 unsigned int nr_bits)
3654{
3655
3656 if (n != -1)
3657 cpu_max_bits_warn(n, nr_bits);
3658
3659 if (src1p && src2p)
3660 return find_next_and_bit(src1p, src2p, nr_bits, n + 1);
3661 else if (src1p)
3662 return find_next_bit(src1p, nr_bits, n + 1);
3663 else if (src2p)
3664 return find_next_bit(src2p, nr_bits, n + 1);
3665
3666 return n + 1;
3667}
3668#else
3669static inline int netif_set_xps_queue(struct net_device *dev,
3670 const struct cpumask *mask,
3671 u16 index)
3672{
3673 return 0;
3674}
3675
3676static inline int __netif_set_xps_queue(struct net_device *dev,
3677 const unsigned long *mask,
3678 u16 index, bool is_rxqs_map)
3679{
3680 return 0;
3681}
3682#endif
3683
3684
3685
3686
3687
3688
3689
3690static inline bool netif_is_multiqueue(const struct net_device *dev)
3691{
3692 return dev->num_tx_queues > 1;
3693}
3694
3695int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
3696
3697#ifdef CONFIG_SYSFS
3698int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq);
3699#else
3700static inline int netif_set_real_num_rx_queues(struct net_device *dev,
3701 unsigned int rxqs)
3702{
3703 dev->real_num_rx_queues = rxqs;
3704 return 0;
3705}
3706#endif
3707
3708static inline struct netdev_rx_queue *
3709__netif_get_rx_queue(struct net_device *dev, unsigned int rxq)
3710{
3711 return dev->_rx + rxq;
3712}
3713
3714#ifdef CONFIG_SYSFS
3715static inline unsigned int get_netdev_rx_queue_index(
3716 struct netdev_rx_queue *queue)
3717{
3718 struct net_device *dev = queue->dev;
3719 int index = queue - dev->_rx;
3720
3721 BUG_ON(index >= dev->num_rx_queues);
3722 return index;
3723}
3724#endif
3725
3726#define DEFAULT_MAX_NUM_RSS_QUEUES (8)
3727int netif_get_num_default_rss_queues(void);
3728
3729enum skb_free_reason {
3730 SKB_REASON_CONSUMED,
3731 SKB_REASON_DROPPED,
3732};
3733
3734void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason);
3735void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason);
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756static inline void dev_kfree_skb_irq(struct sk_buff *skb)
3757{
3758 __dev_kfree_skb_irq(skb, SKB_REASON_DROPPED);
3759}
3760
3761static inline void dev_consume_skb_irq(struct sk_buff *skb)
3762{
3763 __dev_kfree_skb_irq(skb, SKB_REASON_CONSUMED);
3764}
3765
3766static inline void dev_kfree_skb_any(struct sk_buff *skb)
3767{
3768 __dev_kfree_skb_any(skb, SKB_REASON_DROPPED);
3769}
3770
3771static inline void dev_consume_skb_any(struct sk_buff *skb)
3772{
3773 __dev_kfree_skb_any(skb, SKB_REASON_CONSUMED);
3774}
3775
3776void generic_xdp_tx(struct sk_buff *skb, struct bpf_prog *xdp_prog);
3777int do_xdp_generic(struct bpf_prog *xdp_prog, struct sk_buff *skb);
3778int netif_rx(struct sk_buff *skb);
3779int netif_rx_ni(struct sk_buff *skb);
3780int netif_receive_skb(struct sk_buff *skb);
3781int netif_receive_skb_core(struct sk_buff *skb);
3782void netif_receive_skb_list(struct list_head *head);
3783gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
3784void napi_gro_flush(struct napi_struct *napi, bool flush_old);
3785struct sk_buff *napi_get_frags(struct napi_struct *napi);
3786gro_result_t napi_gro_frags(struct napi_struct *napi);
3787struct packet_offload *gro_find_receive_by_type(__be16 type);
3788struct packet_offload *gro_find_complete_by_type(__be16 type);
3789
3790static inline void napi_free_frags(struct napi_struct *napi)
3791{
3792 kfree_skb(napi->skb);
3793 napi->skb = NULL;
3794}
3795
3796bool netdev_is_rx_handler_busy(struct net_device *dev);
3797int netdev_rx_handler_register(struct net_device *dev,
3798 rx_handler_func_t *rx_handler,
3799 void *rx_handler_data);
3800void netdev_rx_handler_unregister(struct net_device *dev);
3801
3802bool dev_valid_name(const char *name);
3803int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr,
3804 bool *need_copyout);
3805int dev_ifconf(struct net *net, struct ifconf *, int);
3806int dev_ethtool(struct net *net, struct ifreq *);
3807unsigned int dev_get_flags(const struct net_device *);
3808int __dev_change_flags(struct net_device *dev, unsigned int flags,
3809 struct netlink_ext_ack *extack);
3810int dev_change_flags(struct net_device *dev, unsigned int flags,
3811 struct netlink_ext_ack *extack);
3812void __dev_notify_flags(struct net_device *, unsigned int old_flags,
3813 unsigned int gchanges);
3814int dev_change_name(struct net_device *, const char *);
3815int dev_set_alias(struct net_device *, const char *, size_t);
3816int dev_get_alias(const struct net_device *, char *, size_t);
3817int dev_change_net_namespace(struct net_device *, struct net *, const char *);
3818int __dev_set_mtu(struct net_device *, int);
3819int dev_validate_mtu(struct net_device *dev, int mtu,
3820 struct netlink_ext_ack *extack);
3821int dev_set_mtu_ext(struct net_device *dev, int mtu,
3822 struct netlink_ext_ack *extack);
3823int dev_set_mtu(struct net_device *, int);
3824int dev_change_tx_queue_len(struct net_device *, unsigned long);
3825void dev_set_group(struct net_device *, int);
3826int dev_pre_changeaddr_notify(struct net_device *dev, const char *addr,
3827 struct netlink_ext_ack *extack);
3828int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
3829 struct netlink_ext_ack *extack);
3830int dev_change_carrier(struct net_device *, bool new_carrier);
3831int dev_get_phys_port_id(struct net_device *dev,
3832 struct netdev_phys_item_id *ppid);
3833int dev_get_phys_port_name(struct net_device *dev,
3834 char *name, size_t len);
3835int dev_get_port_parent_id(struct net_device *dev,
3836 struct netdev_phys_item_id *ppid, bool recurse);
3837bool netdev_port_same_parent_id(struct net_device *a, struct net_device *b);
3838int dev_change_proto_down(struct net_device *dev, bool proto_down);
3839int dev_change_proto_down_generic(struct net_device *dev, bool proto_down);
3840void dev_change_proto_down_reason(struct net_device *dev, unsigned long mask,
3841 u32 value);
3842struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev, bool *again);
3843struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
3844 struct netdev_queue *txq, int *ret);
3845
3846typedef int (*bpf_op_t)(struct net_device *dev, struct netdev_bpf *bpf);
3847int dev_change_xdp_fd(struct net_device *dev, struct netlink_ext_ack *extack,
3848 int fd, int expected_fd, u32 flags);
3849int bpf_xdp_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);
3850u32 dev_xdp_prog_id(struct net_device *dev, enum bpf_xdp_mode mode);
3851
3852int xdp_umem_query(struct net_device *dev, u16 queue_id);
3853
3854int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
3855int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
3856bool is_skb_forwardable(const struct net_device *dev,
3857 const struct sk_buff *skb);
3858
3859static __always_inline int ____dev_forward_skb(struct net_device *dev,
3860 struct sk_buff *skb)
3861{
3862 if (skb_orphan_frags(skb, GFP_ATOMIC) ||
3863 unlikely(!is_skb_forwardable(dev, skb))) {
3864 atomic_long_inc(&dev->rx_dropped);
3865 kfree_skb(skb);
3866 return NET_RX_DROP;
3867 }
3868
3869 skb_scrub_packet(skb, true);
3870 skb->priority = 0;
3871 return 0;
3872}
3873
3874bool dev_nit_active(struct net_device *dev);
3875void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
3876
3877extern int netdev_budget;
3878extern unsigned int netdev_budget_usecs;
3879
3880
3881void netdev_run_todo(void);
3882
3883
3884
3885
3886
3887
3888
3889static inline void dev_put(struct net_device *dev)
3890{
3891 this_cpu_dec(*dev->pcpu_refcnt);
3892}
3893
3894
3895
3896
3897
3898
3899
3900static inline void dev_hold(struct net_device *dev)
3901{
3902 this_cpu_inc(*dev->pcpu_refcnt);
3903}
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914void linkwatch_init_dev(struct net_device *dev);
3915void linkwatch_fire_event(struct net_device *dev);
3916void linkwatch_forget_dev(struct net_device *dev);
3917
3918
3919
3920
3921
3922
3923
3924static inline bool netif_carrier_ok(const struct net_device *dev)
3925{
3926 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
3927}
3928
3929unsigned long dev_trans_start(struct net_device *dev);
3930
3931void __netdev_watchdog_up(struct net_device *dev);
3932
3933void netif_carrier_on(struct net_device *dev);
3934
3935void netif_carrier_off(struct net_device *dev);
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
3949static inline void netif_dormant_on(struct net_device *dev)
3950{
3951 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
3952 linkwatch_fire_event(dev);
3953}
3954
3955
3956
3957
3958
3959
3960
3961static inline void netif_dormant_off(struct net_device *dev)
3962{
3963 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
3964 linkwatch_fire_event(dev);
3965}
3966
3967
3968
3969
3970
3971
3972
3973static inline bool netif_dormant(const struct net_device *dev)
3974{
3975 return test_bit(__LINK_STATE_DORMANT, &dev->state);
3976}
3977
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989static inline void netif_testing_on(struct net_device *dev)
3990{
3991 if (!test_and_set_bit(__LINK_STATE_TESTING, &dev->state))
3992 linkwatch_fire_event(dev);
3993}
3994
3995
3996
3997
3998
3999
4000
4001static inline void netif_testing_off(struct net_device *dev)
4002{
4003 if (test_and_clear_bit(__LINK_STATE_TESTING, &dev->state))
4004 linkwatch_fire_event(dev);
4005}
4006
4007
4008
4009
4010
4011
4012
4013static inline bool netif_testing(const struct net_device *dev)
4014{
4015 return test_bit(__LINK_STATE_TESTING, &dev->state);
4016}
4017
4018
4019
4020
4021
4022
4023
4024
4025static inline bool netif_oper_up(const struct net_device *dev)
4026{
4027 return (dev->operstate == IF_OPER_UP ||
4028 dev->operstate == IF_OPER_UNKNOWN );
4029}
4030
4031
4032
4033
4034
4035
4036
4037static inline bool netif_device_present(struct net_device *dev)
4038{
4039 return test_bit(__LINK_STATE_PRESENT, &dev->state);
4040}
4041
4042void netif_device_detach(struct net_device *dev);
4043
4044void netif_device_attach(struct net_device *dev);
4045
4046
4047
4048
4049
4050enum {
4051 NETIF_MSG_DRV_BIT,
4052 NETIF_MSG_PROBE_BIT,
4053 NETIF_MSG_LINK_BIT,
4054 NETIF_MSG_TIMER_BIT,
4055 NETIF_MSG_IFDOWN_BIT,
4056 NETIF_MSG_IFUP_BIT,
4057 NETIF_MSG_RX_ERR_BIT,
4058 NETIF_MSG_TX_ERR_BIT,
4059 NETIF_MSG_TX_QUEUED_BIT,
4060 NETIF_MSG_INTR_BIT,
4061 NETIF_MSG_TX_DONE_BIT,
4062 NETIF_MSG_RX_STATUS_BIT,
4063 NETIF_MSG_PKTDATA_BIT,
4064 NETIF_MSG_HW_BIT,
4065 NETIF_MSG_WOL_BIT,
4066
4067
4068
4069
4070 NETIF_MSG_CLASS_COUNT,
4071};
4072
4073static_assert(NETIF_MSG_CLASS_COUNT <= 32);
4074
4075#define __NETIF_MSG_BIT(bit) ((u32)1 << (bit))
4076#define __NETIF_MSG(name) __NETIF_MSG_BIT(NETIF_MSG_ ## name ## _BIT)
4077
4078#define NETIF_MSG_DRV __NETIF_MSG(DRV)
4079#define NETIF_MSG_PROBE __NETIF_MSG(PROBE)
4080#define NETIF_MSG_LINK __NETIF_MSG(LINK)
4081#define NETIF_MSG_TIMER __NETIF_MSG(TIMER)
4082#define NETIF_MSG_IFDOWN __NETIF_MSG(IFDOWN)
4083#define NETIF_MSG_IFUP __NETIF_MSG(IFUP)
4084#define NETIF_MSG_RX_ERR __NETIF_MSG(RX_ERR)
4085#define NETIF_MSG_TX_ERR __NETIF_MSG(TX_ERR)
4086#define NETIF_MSG_TX_QUEUED __NETIF_MSG(TX_QUEUED)
4087#define NETIF_MSG_INTR __NETIF_MSG(INTR)
4088#define NETIF_MSG_TX_DONE __NETIF_MSG(TX_DONE)
4089#define NETIF_MSG_RX_STATUS __NETIF_MSG(RX_STATUS)
4090#define NETIF_MSG_PKTDATA __NETIF_MSG(PKTDATA)
4091#define NETIF_MSG_HW __NETIF_MSG(HW)
4092#define NETIF_MSG_WOL __NETIF_MSG(WOL)
4093
4094#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
4095#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
4096#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
4097#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
4098#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
4099#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
4100#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
4101#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
4102#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
4103#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
4104#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
4105#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
4106#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
4107#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
4108#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
4109
4110static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
4111{
4112
4113 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
4114 return default_msg_enable_bits;
4115 if (debug_value == 0)
4116 return 0;
4117
4118 return (1U << debug_value) - 1;
4119}
4120
4121static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
4122{
4123 spin_lock(&txq->_xmit_lock);
4124 txq->xmit_lock_owner = cpu;
4125}
4126
4127static inline bool __netif_tx_acquire(struct netdev_queue *txq)
4128{
4129 __acquire(&txq->_xmit_lock);
4130 return true;
4131}
4132
4133static inline void __netif_tx_release(struct netdev_queue *txq)
4134{
4135 __release(&txq->_xmit_lock);
4136}
4137
4138static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
4139{
4140 spin_lock_bh(&txq->_xmit_lock);
4141 txq->xmit_lock_owner = smp_processor_id();
4142}
4143
4144static inline bool __netif_tx_trylock(struct netdev_queue *txq)
4145{
4146 bool ok = spin_trylock(&txq->_xmit_lock);
4147 if (likely(ok))
4148 txq->xmit_lock_owner = smp_processor_id();
4149 return ok;
4150}
4151
4152static inline void __netif_tx_unlock(struct netdev_queue *txq)
4153{
4154 txq->xmit_lock_owner = -1;
4155 spin_unlock(&txq->_xmit_lock);
4156}
4157
4158static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
4159{
4160 txq->xmit_lock_owner = -1;
4161 spin_unlock_bh(&txq->_xmit_lock);
4162}
4163
4164static inline void txq_trans_update(struct netdev_queue *txq)
4165{
4166 if (txq->xmit_lock_owner != -1)
4167 txq->trans_start = jiffies;
4168}
4169
4170
4171static inline void netif_trans_update(struct net_device *dev)
4172{
4173 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
4174
4175 if (txq->trans_start != jiffies)
4176 txq->trans_start = jiffies;
4177}
4178
4179
4180
4181
4182
4183
4184
4185static inline void netif_tx_lock(struct net_device *dev)
4186{
4187 unsigned int i;
4188 int cpu;
4189
4190 spin_lock(&dev->tx_global_lock);
4191 cpu = smp_processor_id();
4192 for (i = 0; i < dev->num_tx_queues; i++) {
4193 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
4194
4195
4196
4197
4198
4199
4200
4201 __netif_tx_lock(txq, cpu);
4202 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
4203 __netif_tx_unlock(txq);
4204 }
4205}
4206
4207static inline void netif_tx_lock_bh(struct net_device *dev)
4208{
4209 local_bh_disable();
4210 netif_tx_lock(dev);
4211}
4212
4213static inline void netif_tx_unlock(struct net_device *dev)
4214{
4215 unsigned int i;
4216
4217 for (i = 0; i < dev->num_tx_queues; i++) {
4218 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
4219
4220
4221
4222
4223
4224 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
4225 netif_schedule_queue(txq);
4226 }
4227 spin_unlock(&dev->tx_global_lock);
4228}
4229
4230static inline void netif_tx_unlock_bh(struct net_device *dev)
4231{
4232 netif_tx_unlock(dev);
4233 local_bh_enable();
4234}
4235
4236#define HARD_TX_LOCK(dev, txq, cpu) { \
4237 if ((dev->features & NETIF_F_LLTX) == 0) { \
4238 __netif_tx_lock(txq, cpu); \
4239 } else { \
4240 __netif_tx_acquire(txq); \
4241 } \
4242}
4243
4244#define HARD_TX_TRYLOCK(dev, txq) \
4245 (((dev->features & NETIF_F_LLTX) == 0) ? \
4246 __netif_tx_trylock(txq) : \
4247 __netif_tx_acquire(txq))
4248
4249#define HARD_TX_UNLOCK(dev, txq) { \
4250 if ((dev->features & NETIF_F_LLTX) == 0) { \
4251 __netif_tx_unlock(txq); \
4252 } else { \
4253 __netif_tx_release(txq); \
4254 } \
4255}
4256
4257static inline void netif_tx_disable(struct net_device *dev)
4258{
4259 unsigned int i;
4260 int cpu;
4261
4262 local_bh_disable();
4263 cpu = smp_processor_id();
4264 for (i = 0; i < dev->num_tx_queues; i++) {
4265 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
4266
4267 __netif_tx_lock(txq, cpu);
4268 netif_tx_stop_queue(txq);
4269 __netif_tx_unlock(txq);
4270 }
4271 local_bh_enable();
4272}
4273
4274static inline void netif_addr_lock(struct net_device *dev)
4275{
4276 unsigned char nest_level = 0;
4277
4278#ifdef CONFIG_LOCKDEP
4279 nest_level = dev->nested_level;
4280#endif
4281 spin_lock_nested(&dev->addr_list_lock, nest_level);
4282}
4283
4284static inline void netif_addr_lock_bh(struct net_device *dev)
4285{
4286 unsigned char nest_level = 0;
4287
4288#ifdef CONFIG_LOCKDEP
4289 nest_level = dev->nested_level;
4290#endif
4291 local_bh_disable();
4292 spin_lock_nested(&dev->addr_list_lock, nest_level);
4293}
4294
4295static inline void netif_addr_unlock(struct net_device *dev)
4296{
4297 spin_unlock(&dev->addr_list_lock);
4298}
4299
4300static inline void netif_addr_unlock_bh(struct net_device *dev)
4301{
4302 spin_unlock_bh(&dev->addr_list_lock);
4303}
4304
4305
4306
4307
4308
4309#define for_each_dev_addr(dev, ha) \
4310 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
4311
4312
4313
4314void ether_setup(struct net_device *dev);
4315
4316
4317struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
4318 unsigned char name_assign_type,
4319 void (*setup)(struct net_device *),
4320 unsigned int txqs, unsigned int rxqs);
4321#define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
4322 alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)
4323
4324#define alloc_netdev_mq(sizeof_priv, name, name_assign_type, setup, count) \
4325 alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, count, \
4326 count)
4327
4328int register_netdev(struct net_device *dev);
4329void unregister_netdev(struct net_device *dev);
4330
4331int devm_register_netdev(struct device *dev, struct net_device *ndev);
4332
4333
4334int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
4335 struct netdev_hw_addr_list *from_list, int addr_len);
4336void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
4337 struct netdev_hw_addr_list *from_list, int addr_len);
4338int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
4339 struct net_device *dev,
4340 int (*sync)(struct net_device *, const unsigned char *),
4341 int (*unsync)(struct net_device *,
4342 const unsigned char *));
4343int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
4344 struct net_device *dev,
4345 int (*sync)(struct net_device *,
4346 const unsigned char *, int),
4347 int (*unsync)(struct net_device *,
4348 const unsigned char *, int));
4349void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
4350 struct net_device *dev,
4351 int (*unsync)(struct net_device *,
4352 const unsigned char *, int));
4353void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
4354 struct net_device *dev,
4355 int (*unsync)(struct net_device *,
4356 const unsigned char *));
4357void __hw_addr_init(struct netdev_hw_addr_list *list);
4358
4359
4360int dev_addr_add(struct net_device *dev, const unsigned char *addr,
4361 unsigned char addr_type);
4362int dev_addr_del(struct net_device *dev, const unsigned char *addr,
4363 unsigned char addr_type);
4364void dev_addr_flush(struct net_device *dev);
4365int dev_addr_init(struct net_device *dev);
4366
4367
4368int dev_uc_add(struct net_device *dev, const unsigned char *addr);
4369int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
4370int dev_uc_del(struct net_device *dev, const unsigned char *addr);
4371int dev_uc_sync(struct net_device *to, struct net_device *from);
4372int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
4373void dev_uc_unsync(struct net_device *to, struct net_device *from);
4374void dev_uc_flush(struct net_device *dev);
4375void dev_uc_init(struct net_device *dev);
4376
4377
4378
4379
4380
4381
4382
4383
4384
4385
4386static inline int __dev_uc_sync(struct net_device *dev,
4387 int (*sync)(struct net_device *,
4388 const unsigned char *),
4389 int (*unsync)(struct net_device *,
4390 const unsigned char *))
4391{
4392 return __hw_addr_sync_dev(&dev->uc, dev, sync, unsync);
4393}
4394
4395
4396
4397
4398
4399
4400
4401
4402static inline void __dev_uc_unsync(struct net_device *dev,
4403 int (*unsync)(struct net_device *,
4404 const unsigned char *))
4405{
4406 __hw_addr_unsync_dev(&dev->uc, dev, unsync);
4407}
4408
4409
4410int dev_mc_add(struct net_device *dev, const unsigned char *addr);
4411int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
4412int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
4413int dev_mc_del(struct net_device *dev, const unsigned char *addr);
4414int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
4415int dev_mc_sync(struct net_device *to, struct net_device *from);
4416int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
4417void dev_mc_unsync(struct net_device *to, struct net_device *from);
4418void dev_mc_flush(struct net_device *dev);
4419void dev_mc_init(struct net_device *dev);
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430static inline int __dev_mc_sync(struct net_device *dev,
4431 int (*sync)(struct net_device *,
4432 const unsigned char *),
4433 int (*unsync)(struct net_device *,
4434 const unsigned char *))
4435{
4436 return __hw_addr_sync_dev(&dev->mc, dev, sync, unsync);
4437}
4438
4439
4440
4441
4442
4443
4444
4445
4446static inline void __dev_mc_unsync(struct net_device *dev,
4447 int (*unsync)(struct net_device *,
4448 const unsigned char *))
4449{
4450 __hw_addr_unsync_dev(&dev->mc, dev, unsync);
4451}
4452
4453
4454void dev_set_rx_mode(struct net_device *dev);
4455void __dev_set_rx_mode(struct net_device *dev);
4456int dev_set_promiscuity(struct net_device *dev, int inc);
4457int dev_set_allmulti(struct net_device *dev, int inc);
4458void netdev_state_change(struct net_device *dev);
4459void netdev_notify_peers(struct net_device *dev);
4460void netdev_features_change(struct net_device *dev);
4461
4462void dev_load(struct net *net, const char *name);
4463struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
4464 struct rtnl_link_stats64 *storage);
4465void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
4466 const struct net_device_stats *netdev_stats);
4467
4468extern int netdev_max_backlog;
4469extern int netdev_tstamp_prequeue;
4470extern int weight_p;
4471extern int dev_weight_rx_bias;
4472extern int dev_weight_tx_bias;
4473extern int dev_rx_weight;
4474extern int dev_tx_weight;
4475extern int gro_normal_batch;
4476
4477enum {
4478 NESTED_SYNC_IMM_BIT,
4479 NESTED_SYNC_TODO_BIT,
4480};
4481
4482#define __NESTED_SYNC_BIT(bit) ((u32)1 << (bit))
4483#define __NESTED_SYNC(name) __NESTED_SYNC_BIT(NESTED_SYNC_ ## name ## _BIT)
4484
4485#define NESTED_SYNC_IMM __NESTED_SYNC(IMM)
4486#define NESTED_SYNC_TODO __NESTED_SYNC(TODO)
4487
4488struct netdev_nested_priv {
4489 unsigned char flags;
4490 void *data;
4491};
4492
4493bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev);
4494struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
4495 struct list_head **iter);
4496struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev,
4497 struct list_head **iter);
4498
4499#ifdef CONFIG_LOCKDEP
4500static LIST_HEAD(net_unlink_list);
4501
4502static inline void net_unlink_todo(struct net_device *dev)
4503{
4504 if (list_empty(&dev->unlink_list))
4505 list_add_tail(&dev->unlink_list, &net_unlink_list);
4506}
4507#endif
4508
4509
4510#define netdev_for_each_upper_dev_rcu(dev, updev, iter) \
4511 for (iter = &(dev)->adj_list.upper, \
4512 updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \
4513 updev; \
4514 updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))
4515
4516int netdev_walk_all_upper_dev_rcu(struct net_device *dev,
4517 int (*fn)(struct net_device *upper_dev,
4518 struct netdev_nested_priv *priv),
4519 struct netdev_nested_priv *priv);
4520
4521bool netdev_has_upper_dev_all_rcu(struct net_device *dev,
4522 struct net_device *upper_dev);
4523
4524bool netdev_has_any_upper_dev(struct net_device *dev);
4525
4526void *netdev_lower_get_next_private(struct net_device *dev,
4527 struct list_head **iter);
4528void *netdev_lower_get_next_private_rcu(struct net_device *dev,
4529 struct list_head **iter);
4530
4531#define netdev_for_each_lower_private(dev, priv, iter) \
4532 for (iter = (dev)->adj_list.lower.next, \
4533 priv = netdev_lower_get_next_private(dev, &(iter)); \
4534 priv; \
4535 priv = netdev_lower_get_next_private(dev, &(iter)))
4536
4537#define netdev_for_each_lower_private_rcu(dev, priv, iter) \
4538 for (iter = &(dev)->adj_list.lower, \
4539 priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \
4540 priv; \
4541 priv = netdev_lower_get_next_private_rcu(dev, &(iter)))
4542
4543void *netdev_lower_get_next(struct net_device *dev,
4544 struct list_head **iter);
4545
4546#define netdev_for_each_lower_dev(dev, ldev, iter) \
4547 for (iter = (dev)->adj_list.lower.next, \
4548 ldev = netdev_lower_get_next(dev, &(iter)); \
4549 ldev; \
4550 ldev = netdev_lower_get_next(dev, &(iter)))
4551
4552struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
4553 struct list_head **iter);
4554int netdev_walk_all_lower_dev(struct net_device *dev,
4555 int (*fn)(struct net_device *lower_dev,
4556 struct netdev_nested_priv *priv),
4557 struct netdev_nested_priv *priv);
4558int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
4559 int (*fn)(struct net_device *lower_dev,
4560 struct netdev_nested_priv *priv),
4561 struct netdev_nested_priv *priv);
4562
4563void *netdev_adjacent_get_private(struct list_head *adj_list);
4564void *netdev_lower_get_first_private_rcu(struct net_device *dev);
4565struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
4566struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
4567int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev,
4568 struct netlink_ext_ack *extack);
4569int netdev_master_upper_dev_link(struct net_device *dev,
4570 struct net_device *upper_dev,
4571 void *upper_priv, void *upper_info,
4572 struct netlink_ext_ack *extack);
4573void netdev_upper_dev_unlink(struct net_device *dev,
4574 struct net_device *upper_dev);
4575int netdev_adjacent_change_prepare(struct net_device *old_dev,
4576 struct net_device *new_dev,
4577 struct net_device *dev,
4578 struct netlink_ext_ack *extack);
4579void netdev_adjacent_change_commit(struct net_device *old_dev,
4580 struct net_device *new_dev,
4581 struct net_device *dev);
4582void netdev_adjacent_change_abort(struct net_device *old_dev,
4583 struct net_device *new_dev,
4584 struct net_device *dev);
4585void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
4586void *netdev_lower_dev_get_private(struct net_device *dev,
4587 struct net_device *lower_dev);
4588void netdev_lower_state_changed(struct net_device *lower_dev,
4589 void *lower_state_info);
4590
4591
4592#define NETDEV_RSS_KEY_LEN 52
4593extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
4594void netdev_rss_key_fill(void *buffer, size_t len);
4595
4596int skb_checksum_help(struct sk_buff *skb);
4597int skb_crc32c_csum_help(struct sk_buff *skb);
4598int skb_csum_hwoffload_help(struct sk_buff *skb,
4599 const netdev_features_t features);
4600
4601struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
4602 netdev_features_t features, bool tx_path);
4603struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
4604 netdev_features_t features);
4605
4606struct netdev_bonding_info {
4607 ifslave slave;
4608 ifbond master;
4609};
4610
4611struct netdev_notifier_bonding_info {
4612 struct netdev_notifier_info info;
4613 struct netdev_bonding_info bonding_info;
4614};
4615
4616void netdev_bonding_info_change(struct net_device *dev,
4617 struct netdev_bonding_info *bonding_info);
4618
4619#if IS_ENABLED(CONFIG_ETHTOOL_NETLINK)
4620void ethtool_notify(struct net_device *dev, unsigned int cmd, const void *data);
4621#else
4622static inline void ethtool_notify(struct net_device *dev, unsigned int cmd,
4623 const void *data)
4624{
4625}
4626#endif
4627
4628static inline
4629struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
4630{
4631 return __skb_gso_segment(skb, features, true);
4632}
4633__be16 skb_network_protocol(struct sk_buff *skb, int *depth);
4634
4635static inline bool can_checksum_protocol(netdev_features_t features,
4636 __be16 protocol)
4637{
4638 if (protocol == htons(ETH_P_FCOE))
4639 return !!(features & NETIF_F_FCOE_CRC);
4640
4641
4642
4643 if (features & NETIF_F_HW_CSUM) {
4644
4645 return true;
4646 }
4647
4648 switch (protocol) {
4649 case htons(ETH_P_IP):
4650 return !!(features & NETIF_F_IP_CSUM);
4651 case htons(ETH_P_IPV6):
4652 return !!(features & NETIF_F_IPV6_CSUM);
4653 default:
4654 return false;
4655 }
4656}
4657
4658#ifdef CONFIG_BUG
4659void netdev_rx_csum_fault(struct net_device *dev, struct sk_buff *skb);
4660#else
4661static inline void netdev_rx_csum_fault(struct net_device *dev,
4662 struct sk_buff *skb)
4663{
4664}
4665#endif
4666
4667void net_enable_timestamp(void);
4668void net_disable_timestamp(void);
4669
4670#ifdef CONFIG_PROC_FS
4671int __init dev_proc_init(void);
4672#else
4673#define dev_proc_init() 0
4674#endif
4675
4676static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
4677 struct sk_buff *skb, struct net_device *dev,
4678 bool more)
4679{
4680 __this_cpu_write(softnet_data.xmit.more, more);
4681 return ops->ndo_start_xmit(skb, dev);
4682}
4683
4684static inline bool netdev_xmit_more(void)
4685{
4686 return __this_cpu_read(softnet_data.xmit.more);
4687}
4688
4689static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
4690 struct netdev_queue *txq, bool more)
4691{
4692 const struct net_device_ops *ops = dev->netdev_ops;
4693 netdev_tx_t rc;
4694
4695 rc = __netdev_start_xmit(ops, skb, dev, more);
4696 if (rc == NETDEV_TX_OK)
4697 txq_trans_update(txq);
4698
4699 return rc;
4700}
4701
4702int netdev_class_create_file_ns(const struct class_attribute *class_attr,
4703 const void *ns);
4704void netdev_class_remove_file_ns(const struct class_attribute *class_attr,
4705 const void *ns);
4706
4707static inline int netdev_class_create_file(const struct class_attribute *class_attr)
4708{
4709 return netdev_class_create_file_ns(class_attr, NULL);
4710}
4711
4712static inline void netdev_class_remove_file(const struct class_attribute *class_attr)
4713{
4714 netdev_class_remove_file_ns(class_attr, NULL);
4715}
4716
4717extern const struct kobj_ns_type_operations net_ns_type_operations;
4718
4719const char *netdev_drivername(const struct net_device *dev);
4720
4721void linkwatch_run_queue(void);
4722
4723static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
4724 netdev_features_t f2)
4725{
4726 if ((f1 ^ f2) & NETIF_F_HW_CSUM) {
4727 if (f1 & NETIF_F_HW_CSUM)
4728 f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4729 else
4730 f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4731 }
4732
4733 return f1 & f2;
4734}
4735
4736static inline netdev_features_t netdev_get_wanted_features(
4737 struct net_device *dev)
4738{
4739 return (dev->features & ~dev->hw_features) | dev->wanted_features;
4740}
4741netdev_features_t netdev_increment_features(netdev_features_t all,
4742 netdev_features_t one, netdev_features_t mask);
4743
4744
4745
4746
4747
4748static inline netdev_features_t netdev_add_tso_features(netdev_features_t features,
4749 netdev_features_t mask)
4750{
4751 return netdev_increment_features(features, NETIF_F_ALL_TSO, mask);
4752}
4753
4754int __netdev_update_features(struct net_device *dev);
4755void netdev_update_features(struct net_device *dev);
4756void netdev_change_features(struct net_device *dev);
4757
4758void netif_stacked_transfer_operstate(const struct net_device *rootdev,
4759 struct net_device *dev);
4760
4761netdev_features_t passthru_features_check(struct sk_buff *skb,
4762 struct net_device *dev,
4763 netdev_features_t features);
4764netdev_features_t netif_skb_features(struct sk_buff *skb);
4765
4766static inline bool net_gso_ok(netdev_features_t features, int gso_type)
4767{
4768 netdev_features_t feature = (netdev_features_t)gso_type << NETIF_F_GSO_SHIFT;
4769
4770
4771 BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
4772 BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
4773 BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
4774 BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO_SHIFT));
4775 BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
4776 BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
4777 BUILD_BUG_ON(SKB_GSO_GRE != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
4778 BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO_SHIFT));
4779 BUILD_BUG_ON(SKB_GSO_IPXIP4 != (NETIF_F_GSO_IPXIP4 >> NETIF_F_GSO_SHIFT));
4780 BUILD_BUG_ON(SKB_GSO_IPXIP6 != (NETIF_F_GSO_IPXIP6 >> NETIF_F_GSO_SHIFT));
4781 BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
4782 BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT));
4783 BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO_SHIFT));
4784 BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT));
4785 BUILD_BUG_ON(SKB_GSO_SCTP != (NETIF_F_GSO_SCTP >> NETIF_F_GSO_SHIFT));
4786 BUILD_BUG_ON(SKB_GSO_ESP != (NETIF_F_GSO_ESP >> NETIF_F_GSO_SHIFT));
4787 BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_GSO_UDP >> NETIF_F_GSO_SHIFT));
4788 BUILD_BUG_ON(SKB_GSO_UDP_L4 != (NETIF_F_GSO_UDP_L4 >> NETIF_F_GSO_SHIFT));
4789 BUILD_BUG_ON(SKB_GSO_FRAGLIST != (NETIF_F_GSO_FRAGLIST >> NETIF_F_GSO_SHIFT));
4790
4791 return (features & feature) == feature;
4792}
4793
4794static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
4795{
4796 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
4797 (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
4798}
4799
4800static inline bool netif_needs_gso(struct sk_buff *skb,
4801 netdev_features_t features)
4802{
4803 return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
4804 unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
4805 (skb->ip_summed != CHECKSUM_UNNECESSARY)));
4806}
4807
4808static inline void netif_set_gso_max_size(struct net_device *dev,
4809 unsigned int size)
4810{
4811 dev->gso_max_size = size;
4812}
4813
4814static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol,
4815 int pulled_hlen, u16 mac_offset,
4816 int mac_len)
4817{
4818 skb->protocol = protocol;
4819 skb->encapsulation = 1;
4820 skb_push(skb, pulled_hlen);
4821 skb_reset_transport_header(skb);
4822 skb->mac_header = mac_offset;
4823 skb->network_header = skb->mac_header + mac_len;
4824 skb->mac_len = mac_len;
4825}
4826
4827static inline bool netif_is_macsec(const struct net_device *dev)
4828{
4829 return dev->priv_flags & IFF_MACSEC;
4830}
4831
4832static inline bool netif_is_macvlan(const struct net_device *dev)
4833{
4834 return dev->priv_flags & IFF_MACVLAN;
4835}
4836
4837static inline bool netif_is_macvlan_port(const struct net_device *dev)
4838{
4839 return dev->priv_flags & IFF_MACVLAN_PORT;
4840}
4841
4842static inline bool netif_is_bond_master(const struct net_device *dev)
4843{
4844 return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
4845}
4846
4847static inline bool netif_is_bond_slave(const struct net_device *dev)
4848{
4849 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
4850}
4851
4852static inline bool netif_supports_nofcs(struct net_device *dev)
4853{
4854 return dev->priv_flags & IFF_SUPP_NOFCS;
4855}
4856
4857static inline bool netif_has_l3_rx_handler(const struct net_device *dev)
4858{
4859 return dev->priv_flags & IFF_L3MDEV_RX_HANDLER;
4860}
4861
4862static inline bool netif_is_l3_master(const struct net_device *dev)
4863{
4864 return dev->priv_flags & IFF_L3MDEV_MASTER;
4865}
4866
4867static inline bool netif_is_l3_slave(const struct net_device *dev)
4868{
4869 return dev->priv_flags & IFF_L3MDEV_SLAVE;
4870}
4871
4872static inline bool netif_is_bridge_master(const struct net_device *dev)
4873{
4874 return dev->priv_flags & IFF_EBRIDGE;
4875}
4876
4877static inline bool netif_is_bridge_port(const struct net_device *dev)
4878{
4879 return dev->priv_flags & IFF_BRIDGE_PORT;
4880}
4881
4882static inline bool netif_is_ovs_master(const struct net_device *dev)
4883{
4884 return dev->priv_flags & IFF_OPENVSWITCH;
4885}
4886
4887static inline bool netif_is_ovs_port(const struct net_device *dev)
4888{
4889 return dev->priv_flags & IFF_OVS_DATAPATH;
4890}
4891
4892static inline bool netif_is_any_bridge_port(const struct net_device *dev)
4893{
4894 return netif_is_bridge_port(dev) || netif_is_ovs_port(dev);
4895}
4896
4897static inline bool netif_is_team_master(const struct net_device *dev)
4898{
4899 return dev->priv_flags & IFF_TEAM;
4900}
4901
4902static inline bool netif_is_team_port(const struct net_device *dev)
4903{
4904 return dev->priv_flags & IFF_TEAM_PORT;
4905}
4906
4907static inline bool netif_is_lag_master(const struct net_device *dev)
4908{
4909 return netif_is_bond_master(dev) || netif_is_team_master(dev);
4910}
4911
4912static inline bool netif_is_lag_port(const struct net_device *dev)
4913{
4914 return netif_is_bond_slave(dev) || netif_is_team_port(dev);
4915}
4916
4917static inline bool netif_is_rxfh_configured(const struct net_device *dev)
4918{
4919 return dev->priv_flags & IFF_RXFH_CONFIGURED;
4920}
4921
4922static inline bool netif_is_failover(const struct net_device *dev)
4923{
4924 return dev->priv_flags & IFF_FAILOVER;
4925}
4926
4927static inline bool netif_is_failover_slave(const struct net_device *dev)
4928{
4929 return dev->priv_flags & IFF_FAILOVER_SLAVE;
4930}
4931
4932
4933static inline void netif_keep_dst(struct net_device *dev)
4934{
4935 dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
4936}
4937
4938
4939static inline bool netif_reduces_vlan_mtu(struct net_device *dev)
4940{
4941
4942 return dev->priv_flags & IFF_MACSEC;
4943}
4944
4945extern struct pernet_operations __net_initdata loopback_net_ops;
4946
4947
4948
4949
4950
4951static inline const char *netdev_name(const struct net_device *dev)
4952{
4953 if (!dev->name[0] || strchr(dev->name, '%'))
4954 return "(unnamed net_device)";
4955 return dev->name;
4956}
4957
4958static inline bool netdev_unregistering(const struct net_device *dev)
4959{
4960 return dev->reg_state == NETREG_UNREGISTERING;
4961}
4962
4963static inline const char *netdev_reg_state(const struct net_device *dev)
4964{
4965 switch (dev->reg_state) {
4966 case NETREG_UNINITIALIZED: return " (uninitialized)";
4967 case NETREG_REGISTERED: return "";
4968 case NETREG_UNREGISTERING: return " (unregistering)";
4969 case NETREG_UNREGISTERED: return " (unregistered)";
4970 case NETREG_RELEASED: return " (released)";
4971 case NETREG_DUMMY: return " (dummy)";
4972 }
4973
4974 WARN_ONCE(1, "%s: unknown reg_state %d\n", dev->name, dev->reg_state);
4975 return " (unknown)";
4976}
4977
4978__printf(3, 4) __cold
4979void netdev_printk(const char *level, const struct net_device *dev,
4980 const char *format, ...);
4981__printf(2, 3) __cold
4982void netdev_emerg(const struct net_device *dev, const char *format, ...);
4983__printf(2, 3) __cold
4984void netdev_alert(const struct net_device *dev, const char *format, ...);
4985__printf(2, 3) __cold
4986void netdev_crit(const struct net_device *dev, const char *format, ...);
4987__printf(2, 3) __cold
4988void netdev_err(const struct net_device *dev, const char *format, ...);
4989__printf(2, 3) __cold
4990void netdev_warn(const struct net_device *dev, const char *format, ...);
4991__printf(2, 3) __cold
4992void netdev_notice(const struct net_device *dev, const char *format, ...);
4993__printf(2, 3) __cold
4994void netdev_info(const struct net_device *dev, const char *format, ...);
4995
4996#define netdev_level_once(level, dev, fmt, ...) \
4997do { \
4998 static bool __print_once __read_mostly; \
4999 \
5000 if (!__print_once) { \
5001 __print_once = true; \
5002 netdev_printk(level, dev, fmt, ##__VA_ARGS__); \
5003 } \
5004} while (0)
5005
5006#define netdev_emerg_once(dev, fmt, ...) \
5007 netdev_level_once(KERN_EMERG, dev, fmt, ##__VA_ARGS__)
5008#define netdev_alert_once(dev, fmt, ...) \
5009 netdev_level_once(KERN_ALERT, dev, fmt, ##__VA_ARGS__)
5010#define netdev_crit_once(dev, fmt, ...) \
5011 netdev_level_once(KERN_CRIT, dev, fmt, ##__VA_ARGS__)
5012#define netdev_err_once(dev, fmt, ...) \
5013 netdev_level_once(KERN_ERR, dev, fmt, ##__VA_ARGS__)
5014#define netdev_warn_once(dev, fmt, ...) \
5015 netdev_level_once(KERN_WARNING, dev, fmt, ##__VA_ARGS__)
5016#define netdev_notice_once(dev, fmt, ...) \
5017 netdev_level_once(KERN_NOTICE, dev, fmt, ##__VA_ARGS__)
5018#define netdev_info_once(dev, fmt, ...) \
5019 netdev_level_once(KERN_INFO, dev, fmt, ##__VA_ARGS__)
5020
5021#define MODULE_ALIAS_NETDEV(device) \
5022 MODULE_ALIAS("netdev-" device)
5023
5024#if defined(CONFIG_DYNAMIC_DEBUG) || \
5025 (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))
5026#define netdev_dbg(__dev, format, args...) \
5027do { \
5028 dynamic_netdev_dbg(__dev, format, ##args); \
5029} while (0)
5030#elif defined(DEBUG)
5031#define netdev_dbg(__dev, format, args...) \
5032 netdev_printk(KERN_DEBUG, __dev, format, ##args)
5033#else
5034#define netdev_dbg(__dev, format, args...) \
5035({ \
5036 if (0) \
5037 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
5038})
5039#endif
5040
5041#if defined(VERBOSE_DEBUG)
5042#define netdev_vdbg netdev_dbg
5043#else
5044
5045#define netdev_vdbg(dev, format, args...) \
5046({ \
5047 if (0) \
5048 netdev_printk(KERN_DEBUG, dev, format, ##args); \
5049 0; \
5050})
5051#endif
5052
5053
5054
5055
5056
5057
5058#define netdev_WARN(dev, format, args...) \
5059 WARN(1, "netdevice: %s%s: " format, netdev_name(dev), \
5060 netdev_reg_state(dev), ##args)
5061
5062#define netdev_WARN_ONCE(dev, format, args...) \
5063 WARN_ONCE(1, "netdevice: %s%s: " format, netdev_name(dev), \
5064 netdev_reg_state(dev), ##args)
5065
5066
5067
5068#define netif_printk(priv, type, level, dev, fmt, args...) \
5069do { \
5070 if (netif_msg_##type(priv)) \
5071 netdev_printk(level, (dev), fmt, ##args); \
5072} while (0)
5073
5074#define netif_level(level, priv, type, dev, fmt, args...) \
5075do { \
5076 if (netif_msg_##type(priv)) \
5077 netdev_##level(dev, fmt, ##args); \
5078} while (0)
5079
5080#define netif_emerg(priv, type, dev, fmt, args...) \
5081 netif_level(emerg, priv, type, dev, fmt, ##args)
5082#define netif_alert(priv, type, dev, fmt, args...) \
5083 netif_level(alert, priv, type, dev, fmt, ##args)
5084#define netif_crit(priv, type, dev, fmt, args...) \
5085 netif_level(crit, priv, type, dev, fmt, ##args)
5086#define netif_err(priv, type, dev, fmt, args...) \
5087 netif_level(err, priv, type, dev, fmt, ##args)
5088#define netif_warn(priv, type, dev, fmt, args...) \
5089 netif_level(warn, priv, type, dev, fmt, ##args)
5090#define netif_notice(priv, type, dev, fmt, args...) \
5091 netif_level(notice, priv, type, dev, fmt, ##args)
5092#define netif_info(priv, type, dev, fmt, args...) \
5093 netif_level(info, priv, type, dev, fmt, ##args)
5094
5095#if defined(CONFIG_DYNAMIC_DEBUG) || \
5096 (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))
5097#define netif_dbg(priv, type, netdev, format, args...) \
5098do { \
5099 if (netif_msg_##type(priv)) \
5100 dynamic_netdev_dbg(netdev, format, ##args); \
5101} while (0)
5102#elif defined(DEBUG)
5103#define netif_dbg(priv, type, dev, format, args...) \
5104 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
5105#else
5106#define netif_dbg(priv, type, dev, format, args...) \
5107({ \
5108 if (0) \
5109 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
5110 0; \
5111})
5112#endif
5113
5114
5115#define netif_cond_dbg(priv, type, netdev, cond, level, fmt, args...) \
5116 do { \
5117 if (cond) \
5118 netif_dbg(priv, type, netdev, fmt, ##args); \
5119 else \
5120 netif_ ## level(priv, type, netdev, fmt, ##args); \
5121 } while (0)
5122
5123#if defined(VERBOSE_DEBUG)
5124#define netif_vdbg netif_dbg
5125#else
5126#define netif_vdbg(priv, type, dev, format, args...) \
5127({ \
5128 if (0) \
5129 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
5130 0; \
5131})
5132#endif
5133
5134
5135
5136
5137
5138
5139
5140
5141
5142
5143
5144
5145
5146
5147
5148
5149
5150
5151
5152
5153#define PTYPE_HASH_SIZE (16)
5154#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
5155
5156extern struct net_device *blackhole_netdev;
5157
5158#endif
5159