1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#ifndef _LINUX_NETDEVICE_H
26#define _LINUX_NETDEVICE_H
27
28#include <linux/timer.h>
29#include <linux/bug.h>
30#include <linux/delay.h>
31#include <linux/atomic.h>
32#include <linux/prefetch.h>
33#include <asm/cache.h>
34#include <asm/byteorder.h>
35
36#include <linux/percpu.h>
37#include <linux/rculist.h>
38#include <linux/dmaengine.h>
39#include <linux/workqueue.h>
40#include <linux/dynamic_queue_limits.h>
41
42#include <linux/ethtool.h>
43#include <net/net_namespace.h>
44#include <net/dsa.h>
45#ifdef CONFIG_DCB
46#include <net/dcbnl.h>
47#endif
48#include <net/netprio_cgroup.h>
49
50#include <linux/netdev_features.h>
51#include <linux/neighbour.h>
52#include <uapi/linux/netdevice.h>
53#include <uapi/linux/if_bonding.h>
54#include <uapi/linux/pkt_cls.h>
55
56struct netpoll_info;
57struct device;
58struct phy_device;
59
60struct wireless_dev;
61
62struct wpan_dev;
63struct mpls_dev;
64
65struct udp_tunnel_info;
66struct bpf_prog;
67
68void netdev_set_default_ethtool_ops(struct net_device *dev,
69 const struct ethtool_ops *ops);
70
71
72#define NET_RX_SUCCESS 0
73#define NET_RX_DROP 1
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93#define NET_XMIT_SUCCESS 0x00
94#define NET_XMIT_DROP 0x01
95#define NET_XMIT_CN 0x02
96#define NET_XMIT_MASK 0x0f
97
98
99
100
101#define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
102#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
103
104
105#define NETDEV_TX_MASK 0xf0
106
107enum netdev_tx {
108 __NETDEV_TX_MIN = INT_MIN,
109 NETDEV_TX_OK = 0x00,
110 NETDEV_TX_BUSY = 0x10,
111};
112typedef enum netdev_tx netdev_tx_t;
113
114
115
116
117
118static inline bool dev_xmit_complete(int rc)
119{
120
121
122
123
124
125
126 if (likely(rc < NET_XMIT_MASK))
127 return true;
128
129 return false;
130}
131
132
133
134
135
136
137#if defined(CONFIG_HYPERV_NET)
138# define LL_MAX_HEADER 128
139#elif defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
140# if defined(CONFIG_MAC80211_MESH)
141# define LL_MAX_HEADER 128
142# else
143# define LL_MAX_HEADER 96
144# endif
145#else
146# define LL_MAX_HEADER 32
147#endif
148
149#if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
150 !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)
151#define MAX_HEADER LL_MAX_HEADER
152#else
153#define MAX_HEADER (LL_MAX_HEADER + 48)
154#endif
155
156
157
158
159
160
161struct net_device_stats {
162 unsigned long rx_packets;
163 unsigned long tx_packets;
164 unsigned long rx_bytes;
165 unsigned long tx_bytes;
166 unsigned long rx_errors;
167 unsigned long tx_errors;
168 unsigned long rx_dropped;
169 unsigned long tx_dropped;
170 unsigned long multicast;
171 unsigned long collisions;
172 unsigned long rx_length_errors;
173 unsigned long rx_over_errors;
174 unsigned long rx_crc_errors;
175 unsigned long rx_frame_errors;
176 unsigned long rx_fifo_errors;
177 unsigned long rx_missed_errors;
178 unsigned long tx_aborted_errors;
179 unsigned long tx_carrier_errors;
180 unsigned long tx_fifo_errors;
181 unsigned long tx_heartbeat_errors;
182 unsigned long tx_window_errors;
183 unsigned long rx_compressed;
184 unsigned long tx_compressed;
185};
186
187
188#include <linux/cache.h>
189#include <linux/skbuff.h>
190
191#ifdef CONFIG_RPS
192#include <linux/static_key.h>
193extern struct static_key rps_needed;
194#endif
195
196struct neighbour;
197struct neigh_parms;
198struct sk_buff;
199
200struct netdev_hw_addr {
201 struct list_head list;
202 unsigned char addr[MAX_ADDR_LEN];
203 unsigned char type;
204#define NETDEV_HW_ADDR_T_LAN 1
205#define NETDEV_HW_ADDR_T_SAN 2
206#define NETDEV_HW_ADDR_T_SLAVE 3
207#define NETDEV_HW_ADDR_T_UNICAST 4
208#define NETDEV_HW_ADDR_T_MULTICAST 5
209 bool global_use;
210 int sync_cnt;
211 int refcount;
212 int synced;
213 struct rcu_head rcu_head;
214};
215
216struct netdev_hw_addr_list {
217 struct list_head list;
218 int count;
219};
220
221#define netdev_hw_addr_list_count(l) ((l)->count)
222#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
223#define netdev_hw_addr_list_for_each(ha, l) \
224 list_for_each_entry(ha, &(l)->list, list)
225
226#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
227#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
228#define netdev_for_each_uc_addr(ha, dev) \
229 netdev_hw_addr_list_for_each(ha, &(dev)->uc)
230
231#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
232#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
233#define netdev_for_each_mc_addr(ha, dev) \
234 netdev_hw_addr_list_for_each(ha, &(dev)->mc)
235
236struct hh_cache {
237 u16 hh_len;
238 u16 __pad;
239 seqlock_t hh_lock;
240
241
242#define HH_DATA_MOD 16
243#define HH_DATA_OFF(__len) \
244 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
245#define HH_DATA_ALIGN(__len) \
246 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
247 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
248};
249
250
251
252
253
254
255
256
257
258#define LL_RESERVED_SPACE(dev) \
259 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
260#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
261 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
262
263struct header_ops {
264 int (*create) (struct sk_buff *skb, struct net_device *dev,
265 unsigned short type, const void *daddr,
266 const void *saddr, unsigned int len);
267 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
268 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
269 void (*cache_update)(struct hh_cache *hh,
270 const struct net_device *dev,
271 const unsigned char *haddr);
272 bool (*validate)(const char *ll_header, unsigned int len);
273};
274
275
276
277
278
279
280enum netdev_state_t {
281 __LINK_STATE_START,
282 __LINK_STATE_PRESENT,
283 __LINK_STATE_NOCARRIER,
284 __LINK_STATE_LINKWATCH_PENDING,
285 __LINK_STATE_DORMANT,
286};
287
288
289
290
291
292
293struct netdev_boot_setup {
294 char name[IFNAMSIZ];
295 struct ifmap map;
296};
297#define NETDEV_BOOT_SETUP_MAX 8
298
299int __init netdev_boot_setup(char *str);
300
301
302
303
304struct napi_struct {
305
306
307
308
309
310
311 struct list_head poll_list;
312
313 unsigned long state;
314 int weight;
315 unsigned int gro_count;
316 int (*poll)(struct napi_struct *, int);
317#ifdef CONFIG_NETPOLL
318 spinlock_t poll_lock;
319 int poll_owner;
320#endif
321 struct net_device *dev;
322 struct sk_buff *gro_list;
323 struct sk_buff *skb;
324 struct hrtimer timer;
325 struct list_head dev_list;
326 struct hlist_node napi_hash_node;
327 unsigned int napi_id;
328};
329
330enum {
331 NAPI_STATE_SCHED,
332 NAPI_STATE_DISABLE,
333 NAPI_STATE_NPSVC,
334 NAPI_STATE_HASHED,
335 NAPI_STATE_NO_BUSY_POLL,
336};
337
338enum gro_result {
339 GRO_MERGED,
340 GRO_MERGED_FREE,
341 GRO_HELD,
342 GRO_NORMAL,
343 GRO_DROP,
344};
345typedef enum gro_result gro_result_t;
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388enum rx_handler_result {
389 RX_HANDLER_CONSUMED,
390 RX_HANDLER_ANOTHER,
391 RX_HANDLER_EXACT,
392 RX_HANDLER_PASS,
393};
394typedef enum rx_handler_result rx_handler_result_t;
395typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
396
397void __napi_schedule(struct napi_struct *n);
398void __napi_schedule_irqoff(struct napi_struct *n);
399
400static inline bool napi_disable_pending(struct napi_struct *n)
401{
402 return test_bit(NAPI_STATE_DISABLE, &n->state);
403}
404
405
406
407
408
409
410
411
412
413
414static inline bool napi_schedule_prep(struct napi_struct *n)
415{
416 return !napi_disable_pending(n) &&
417 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
418}
419
420
421
422
423
424
425
426
427static inline void napi_schedule(struct napi_struct *n)
428{
429 if (napi_schedule_prep(n))
430 __napi_schedule(n);
431}
432
433
434
435
436
437
438
439static inline void napi_schedule_irqoff(struct napi_struct *n)
440{
441 if (napi_schedule_prep(n))
442 __napi_schedule_irqoff(n);
443}
444
445
446static inline bool napi_reschedule(struct napi_struct *napi)
447{
448 if (napi_schedule_prep(napi)) {
449 __napi_schedule(napi);
450 return true;
451 }
452 return false;
453}
454
455void __napi_complete(struct napi_struct *n);
456void napi_complete_done(struct napi_struct *n, int work_done);
457
458
459
460
461
462
463
464static inline void napi_complete(struct napi_struct *n)
465{
466 return napi_complete_done(n, 0);
467}
468
469
470
471
472
473
474
475
476
477
478void napi_hash_add(struct napi_struct *napi);
479
480
481
482
483
484
485
486
487
488
489
490
491
492bool napi_hash_del(struct napi_struct *napi);
493
494
495
496
497
498
499
500
501void napi_disable(struct napi_struct *n);
502
503
504
505
506
507
508
509
510static inline void napi_enable(struct napi_struct *n)
511{
512 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
513 smp_mb__before_atomic();
514 clear_bit(NAPI_STATE_SCHED, &n->state);
515 clear_bit(NAPI_STATE_NPSVC, &n->state);
516}
517
518
519
520
521
522
523
524
525
526static inline void napi_synchronize(const struct napi_struct *n)
527{
528 if (IS_ENABLED(CONFIG_SMP))
529 while (test_bit(NAPI_STATE_SCHED, &n->state))
530 msleep(1);
531 else
532 barrier();
533}
534
535enum netdev_queue_state_t {
536 __QUEUE_STATE_DRV_XOFF,
537 __QUEUE_STATE_STACK_XOFF,
538 __QUEUE_STATE_FROZEN,
539};
540
541#define QUEUE_STATE_DRV_XOFF (1 << __QUEUE_STATE_DRV_XOFF)
542#define QUEUE_STATE_STACK_XOFF (1 << __QUEUE_STATE_STACK_XOFF)
543#define QUEUE_STATE_FROZEN (1 << __QUEUE_STATE_FROZEN)
544
545#define QUEUE_STATE_ANY_XOFF (QUEUE_STATE_DRV_XOFF | QUEUE_STATE_STACK_XOFF)
546#define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
547 QUEUE_STATE_FROZEN)
548#define QUEUE_STATE_DRV_XOFF_OR_FROZEN (QUEUE_STATE_DRV_XOFF | \
549 QUEUE_STATE_FROZEN)
550
551
552
553
554
555
556
557
558
559
560
561struct netdev_queue {
562
563
564
565 struct net_device *dev;
566 struct Qdisc __rcu *qdisc;
567 struct Qdisc *qdisc_sleeping;
568#ifdef CONFIG_SYSFS
569 struct kobject kobj;
570#endif
571#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
572 int numa_node;
573#endif
574 unsigned long tx_maxrate;
575
576
577
578
579 unsigned long trans_timeout;
580
581
582
583 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
584 int xmit_lock_owner;
585
586
587
588 unsigned long trans_start;
589
590 unsigned long state;
591
592#ifdef CONFIG_BQL
593 struct dql dql;
594#endif
595} ____cacheline_aligned_in_smp;
596
597static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
598{
599#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
600 return q->numa_node;
601#else
602 return NUMA_NO_NODE;
603#endif
604}
605
606static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
607{
608#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
609 q->numa_node = node;
610#endif
611}
612
613#ifdef CONFIG_RPS
614
615
616
617
618struct rps_map {
619 unsigned int len;
620 struct rcu_head rcu;
621 u16 cpus[0];
622};
623#define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + ((_num) * sizeof(u16)))
624
625
626
627
628
629
630struct rps_dev_flow {
631 u16 cpu;
632 u16 filter;
633 unsigned int last_qtail;
634};
635#define RPS_NO_FILTER 0xffff
636
637
638
639
640struct rps_dev_flow_table {
641 unsigned int mask;
642 struct rcu_head rcu;
643 struct rps_dev_flow flows[0];
644};
645#define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
646 ((_num) * sizeof(struct rps_dev_flow)))
647
648
649
650
651
652
653
654
655
656
657
658struct rps_sock_flow_table {
659 u32 mask;
660
661 u32 ents[0] ____cacheline_aligned_in_smp;
662};
663#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (offsetof(struct rps_sock_flow_table, ents[_num]))
664
665#define RPS_NO_CPU 0xffff
666
667extern u32 rps_cpu_mask;
668extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
669
670static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
671 u32 hash)
672{
673 if (table && hash) {
674 unsigned int index = hash & table->mask;
675 u32 val = hash & ~rps_cpu_mask;
676
677
678 val |= raw_smp_processor_id();
679
680 if (table->ents[index] != val)
681 table->ents[index] = val;
682 }
683}
684
685#ifdef CONFIG_RFS_ACCEL
686bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id,
687 u16 filter_id);
688#endif
689#endif
690
691
692struct netdev_rx_queue {
693#ifdef CONFIG_RPS
694 struct rps_map __rcu *rps_map;
695 struct rps_dev_flow_table __rcu *rps_flow_table;
696#endif
697 struct kobject kobj;
698 struct net_device *dev;
699} ____cacheline_aligned_in_smp;
700
701
702
703
704struct rx_queue_attribute {
705 struct attribute attr;
706 ssize_t (*show)(struct netdev_rx_queue *queue,
707 struct rx_queue_attribute *attr, char *buf);
708 ssize_t (*store)(struct netdev_rx_queue *queue,
709 struct rx_queue_attribute *attr, const char *buf, size_t len);
710};
711
712#ifdef CONFIG_XPS
713
714
715
716
717struct xps_map {
718 unsigned int len;
719 unsigned int alloc_len;
720 struct rcu_head rcu;
721 u16 queues[0];
722};
723#define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16)))
724#define XPS_MIN_MAP_ALLOC ((L1_CACHE_ALIGN(offsetof(struct xps_map, queues[1])) \
725 - sizeof(struct xps_map)) / sizeof(u16))
726
727
728
729
730struct xps_dev_maps {
731 struct rcu_head rcu;
732 struct xps_map __rcu *cpu_map[0];
733};
734#define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) + \
735 (nr_cpu_ids * sizeof(struct xps_map *)))
736#endif
737
738#define TC_MAX_QUEUE 16
739#define TC_BITMASK 15
740
741struct netdev_tc_txq {
742 u16 count;
743 u16 offset;
744};
745
746#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
747
748
749
750
751struct netdev_fcoe_hbainfo {
752 char manufacturer[64];
753 char serial_number[64];
754 char hardware_version[64];
755 char driver_version[64];
756 char optionrom_version[64];
757 char firmware_version[64];
758 char model[256];
759 char model_description[256];
760};
761#endif
762
763#define MAX_PHYS_ITEM_ID_LEN 32
764
765
766
767
768struct netdev_phys_item_id {
769 unsigned char id[MAX_PHYS_ITEM_ID_LEN];
770 unsigned char id_len;
771};
772
773static inline bool netdev_phys_item_id_same(struct netdev_phys_item_id *a,
774 struct netdev_phys_item_id *b)
775{
776 return a->id_len == b->id_len &&
777 memcmp(a->id, b->id, a->id_len) == 0;
778}
779
780typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
781 struct sk_buff *skb);
782
783
784
785
786enum {
787 TC_SETUP_MQPRIO,
788 TC_SETUP_CLSU32,
789 TC_SETUP_CLSFLOWER,
790 TC_SETUP_MATCHALL,
791};
792
793struct tc_cls_u32_offload;
794
795struct tc_to_netdev {
796 unsigned int type;
797 union {
798 u8 tc;
799 struct tc_cls_u32_offload *cls_u32;
800 struct tc_cls_flower_offload *cls_flower;
801 struct tc_cls_matchall_offload *cls_mall;
802 };
803};
804
805
806
807
808enum xdp_netdev_command {
809
810
811
812
813
814
815
816 XDP_SETUP_PROG,
817
818
819
820 XDP_QUERY_PROG,
821};
822
823struct netdev_xdp {
824 enum xdp_netdev_command command;
825 union {
826
827 struct bpf_prog *prog;
828
829 bool prog_attached;
830 };
831};
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
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
1125struct net_device_ops {
1126 int (*ndo_init)(struct net_device *dev);
1127 void (*ndo_uninit)(struct net_device *dev);
1128 int (*ndo_open)(struct net_device *dev);
1129 int (*ndo_stop)(struct net_device *dev);
1130 netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
1131 struct net_device *dev);
1132 netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
1133 struct net_device *dev,
1134 netdev_features_t features);
1135 u16 (*ndo_select_queue)(struct net_device *dev,
1136 struct sk_buff *skb,
1137 void *accel_priv,
1138 select_queue_fallback_t fallback);
1139 void (*ndo_change_rx_flags)(struct net_device *dev,
1140 int flags);
1141 void (*ndo_set_rx_mode)(struct net_device *dev);
1142 int (*ndo_set_mac_address)(struct net_device *dev,
1143 void *addr);
1144 int (*ndo_validate_addr)(struct net_device *dev);
1145 int (*ndo_do_ioctl)(struct net_device *dev,
1146 struct ifreq *ifr, int cmd);
1147 int (*ndo_set_config)(struct net_device *dev,
1148 struct ifmap *map);
1149 int (*ndo_change_mtu)(struct net_device *dev,
1150 int new_mtu);
1151 int (*ndo_neigh_setup)(struct net_device *dev,
1152 struct neigh_parms *);
1153 void (*ndo_tx_timeout) (struct net_device *dev);
1154
1155 struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
1156 struct rtnl_link_stats64 *storage);
1157 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
1158
1159 int (*ndo_vlan_rx_add_vid)(struct net_device *dev,
1160 __be16 proto, u16 vid);
1161 int (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
1162 __be16 proto, u16 vid);
1163#ifdef CONFIG_NET_POLL_CONTROLLER
1164 void (*ndo_poll_controller)(struct net_device *dev);
1165 int (*ndo_netpoll_setup)(struct net_device *dev,
1166 struct netpoll_info *info);
1167 void (*ndo_netpoll_cleanup)(struct net_device *dev);
1168#endif
1169#ifdef CONFIG_NET_RX_BUSY_POLL
1170 int (*ndo_busy_poll)(struct napi_struct *dev);
1171#endif
1172 int (*ndo_set_vf_mac)(struct net_device *dev,
1173 int queue, u8 *mac);
1174 int (*ndo_set_vf_vlan)(struct net_device *dev,
1175 int queue, u16 vlan, u8 qos);
1176 int (*ndo_set_vf_rate)(struct net_device *dev,
1177 int vf, int min_tx_rate,
1178 int max_tx_rate);
1179 int (*ndo_set_vf_spoofchk)(struct net_device *dev,
1180 int vf, bool setting);
1181 int (*ndo_set_vf_trust)(struct net_device *dev,
1182 int vf, bool setting);
1183 int (*ndo_get_vf_config)(struct net_device *dev,
1184 int vf,
1185 struct ifla_vf_info *ivf);
1186 int (*ndo_set_vf_link_state)(struct net_device *dev,
1187 int vf, int link_state);
1188 int (*ndo_get_vf_stats)(struct net_device *dev,
1189 int vf,
1190 struct ifla_vf_stats
1191 *vf_stats);
1192 int (*ndo_set_vf_port)(struct net_device *dev,
1193 int vf,
1194 struct nlattr *port[]);
1195 int (*ndo_get_vf_port)(struct net_device *dev,
1196 int vf, struct sk_buff *skb);
1197 int (*ndo_set_vf_guid)(struct net_device *dev,
1198 int vf, u64 guid,
1199 int guid_type);
1200 int (*ndo_set_vf_rss_query_en)(
1201 struct net_device *dev,
1202 int vf, bool setting);
1203 int (*ndo_setup_tc)(struct net_device *dev,
1204 u32 handle,
1205 __be16 protocol,
1206 struct tc_to_netdev *tc);
1207#if IS_ENABLED(CONFIG_FCOE)
1208 int (*ndo_fcoe_enable)(struct net_device *dev);
1209 int (*ndo_fcoe_disable)(struct net_device *dev);
1210 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
1211 u16 xid,
1212 struct scatterlist *sgl,
1213 unsigned int sgc);
1214 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
1215 u16 xid);
1216 int (*ndo_fcoe_ddp_target)(struct net_device *dev,
1217 u16 xid,
1218 struct scatterlist *sgl,
1219 unsigned int sgc);
1220 int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
1221 struct netdev_fcoe_hbainfo *hbainfo);
1222#endif
1223
1224#if IS_ENABLED(CONFIG_LIBFCOE)
1225#define NETDEV_FCOE_WWNN 0
1226#define NETDEV_FCOE_WWPN 1
1227 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
1228 u64 *wwn, int type);
1229#endif
1230
1231#ifdef CONFIG_RFS_ACCEL
1232 int (*ndo_rx_flow_steer)(struct net_device *dev,
1233 const struct sk_buff *skb,
1234 u16 rxq_index,
1235 u32 flow_id);
1236#endif
1237 int (*ndo_add_slave)(struct net_device *dev,
1238 struct net_device *slave_dev);
1239 int (*ndo_del_slave)(struct net_device *dev,
1240 struct net_device *slave_dev);
1241 netdev_features_t (*ndo_fix_features)(struct net_device *dev,
1242 netdev_features_t features);
1243 int (*ndo_set_features)(struct net_device *dev,
1244 netdev_features_t features);
1245 int (*ndo_neigh_construct)(struct net_device *dev,
1246 struct neighbour *n);
1247 void (*ndo_neigh_destroy)(struct net_device *dev,
1248 struct neighbour *n);
1249
1250 int (*ndo_fdb_add)(struct ndmsg *ndm,
1251 struct nlattr *tb[],
1252 struct net_device *dev,
1253 const unsigned char *addr,
1254 u16 vid,
1255 u16 flags);
1256 int (*ndo_fdb_del)(struct ndmsg *ndm,
1257 struct nlattr *tb[],
1258 struct net_device *dev,
1259 const unsigned char *addr,
1260 u16 vid);
1261 int (*ndo_fdb_dump)(struct sk_buff *skb,
1262 struct netlink_callback *cb,
1263 struct net_device *dev,
1264 struct net_device *filter_dev,
1265 int idx);
1266
1267 int (*ndo_bridge_setlink)(struct net_device *dev,
1268 struct nlmsghdr *nlh,
1269 u16 flags);
1270 int (*ndo_bridge_getlink)(struct sk_buff *skb,
1271 u32 pid, u32 seq,
1272 struct net_device *dev,
1273 u32 filter_mask,
1274 int nlflags);
1275 int (*ndo_bridge_dellink)(struct net_device *dev,
1276 struct nlmsghdr *nlh,
1277 u16 flags);
1278 int (*ndo_change_carrier)(struct net_device *dev,
1279 bool new_carrier);
1280 int (*ndo_get_phys_port_id)(struct net_device *dev,
1281 struct netdev_phys_item_id *ppid);
1282 int (*ndo_get_phys_port_name)(struct net_device *dev,
1283 char *name, size_t len);
1284 void (*ndo_udp_tunnel_add)(struct net_device *dev,
1285 struct udp_tunnel_info *ti);
1286 void (*ndo_udp_tunnel_del)(struct net_device *dev,
1287 struct udp_tunnel_info *ti);
1288 void* (*ndo_dfwd_add_station)(struct net_device *pdev,
1289 struct net_device *dev);
1290 void (*ndo_dfwd_del_station)(struct net_device *pdev,
1291 void *priv);
1292
1293 netdev_tx_t (*ndo_dfwd_start_xmit) (struct sk_buff *skb,
1294 struct net_device *dev,
1295 void *priv);
1296 int (*ndo_get_lock_subclass)(struct net_device *dev);
1297 int (*ndo_set_tx_maxrate)(struct net_device *dev,
1298 int queue_index,
1299 u32 maxrate);
1300 int (*ndo_get_iflink)(const struct net_device *dev);
1301 int (*ndo_change_proto_down)(struct net_device *dev,
1302 bool proto_down);
1303 int (*ndo_fill_metadata_dst)(struct net_device *dev,
1304 struct sk_buff *skb);
1305 void (*ndo_set_rx_headroom)(struct net_device *dev,
1306 int needed_headroom);
1307 int (*ndo_xdp)(struct net_device *dev,
1308 struct netdev_xdp *xdp);
1309};
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354enum netdev_priv_flags {
1355 IFF_802_1Q_VLAN = 1<<0,
1356 IFF_EBRIDGE = 1<<1,
1357 IFF_BONDING = 1<<2,
1358 IFF_ISATAP = 1<<3,
1359 IFF_WAN_HDLC = 1<<4,
1360 IFF_XMIT_DST_RELEASE = 1<<5,
1361 IFF_DONT_BRIDGE = 1<<6,
1362 IFF_DISABLE_NETPOLL = 1<<7,
1363 IFF_MACVLAN_PORT = 1<<8,
1364 IFF_BRIDGE_PORT = 1<<9,
1365 IFF_OVS_DATAPATH = 1<<10,
1366 IFF_TX_SKB_SHARING = 1<<11,
1367 IFF_UNICAST_FLT = 1<<12,
1368 IFF_TEAM_PORT = 1<<13,
1369 IFF_SUPP_NOFCS = 1<<14,
1370 IFF_LIVE_ADDR_CHANGE = 1<<15,
1371 IFF_MACVLAN = 1<<16,
1372 IFF_XMIT_DST_RELEASE_PERM = 1<<17,
1373 IFF_IPVLAN_MASTER = 1<<18,
1374 IFF_IPVLAN_SLAVE = 1<<19,
1375 IFF_L3MDEV_MASTER = 1<<20,
1376 IFF_NO_QUEUE = 1<<21,
1377 IFF_OPENVSWITCH = 1<<22,
1378 IFF_L3MDEV_SLAVE = 1<<23,
1379 IFF_TEAM = 1<<24,
1380 IFF_RXFH_CONFIGURED = 1<<25,
1381 IFF_PHONY_HEADROOM = 1<<26,
1382 IFF_MACSEC = 1<<27,
1383};
1384
1385#define IFF_802_1Q_VLAN IFF_802_1Q_VLAN
1386#define IFF_EBRIDGE IFF_EBRIDGE
1387#define IFF_BONDING IFF_BONDING
1388#define IFF_ISATAP IFF_ISATAP
1389#define IFF_WAN_HDLC IFF_WAN_HDLC
1390#define IFF_XMIT_DST_RELEASE IFF_XMIT_DST_RELEASE
1391#define IFF_DONT_BRIDGE IFF_DONT_BRIDGE
1392#define IFF_DISABLE_NETPOLL IFF_DISABLE_NETPOLL
1393#define IFF_MACVLAN_PORT IFF_MACVLAN_PORT
1394#define IFF_BRIDGE_PORT IFF_BRIDGE_PORT
1395#define IFF_OVS_DATAPATH IFF_OVS_DATAPATH
1396#define IFF_TX_SKB_SHARING IFF_TX_SKB_SHARING
1397#define IFF_UNICAST_FLT IFF_UNICAST_FLT
1398#define IFF_TEAM_PORT IFF_TEAM_PORT
1399#define IFF_SUPP_NOFCS IFF_SUPP_NOFCS
1400#define IFF_LIVE_ADDR_CHANGE IFF_LIVE_ADDR_CHANGE
1401#define IFF_MACVLAN IFF_MACVLAN
1402#define IFF_XMIT_DST_RELEASE_PERM IFF_XMIT_DST_RELEASE_PERM
1403#define IFF_IPVLAN_MASTER IFF_IPVLAN_MASTER
1404#define IFF_IPVLAN_SLAVE IFF_IPVLAN_SLAVE
1405#define IFF_L3MDEV_MASTER IFF_L3MDEV_MASTER
1406#define IFF_NO_QUEUE IFF_NO_QUEUE
1407#define IFF_OPENVSWITCH IFF_OPENVSWITCH
1408#define IFF_L3MDEV_SLAVE IFF_L3MDEV_SLAVE
1409#define IFF_TEAM IFF_TEAM
1410#define IFF_RXFH_CONFIGURED IFF_RXFH_CONFIGURED
1411#define IFF_MACSEC IFF_MACSEC
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
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
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626struct net_device {
1627 char name[IFNAMSIZ];
1628 struct hlist_node name_hlist;
1629 char *ifalias;
1630
1631
1632
1633
1634 unsigned long mem_end;
1635 unsigned long mem_start;
1636 unsigned long base_addr;
1637 int irq;
1638
1639 atomic_t carrier_changes;
1640
1641
1642
1643
1644
1645
1646
1647 unsigned long state;
1648
1649 struct list_head dev_list;
1650 struct list_head napi_list;
1651 struct list_head unreg_list;
1652 struct list_head close_list;
1653 struct list_head ptype_all;
1654 struct list_head ptype_specific;
1655
1656 struct {
1657 struct list_head upper;
1658 struct list_head lower;
1659 } adj_list;
1660
1661 struct {
1662 struct list_head upper;
1663 struct list_head lower;
1664 } all_adj_list;
1665
1666 netdev_features_t features;
1667 netdev_features_t hw_features;
1668 netdev_features_t wanted_features;
1669 netdev_features_t vlan_features;
1670 netdev_features_t hw_enc_features;
1671 netdev_features_t mpls_features;
1672 netdev_features_t gso_partial_features;
1673
1674 int ifindex;
1675 int group;
1676
1677 struct net_device_stats stats;
1678
1679 atomic_long_t rx_dropped;
1680 atomic_long_t tx_dropped;
1681 atomic_long_t rx_nohandler;
1682
1683#ifdef CONFIG_WIRELESS_EXT
1684 const struct iw_handler_def *wireless_handlers;
1685 struct iw_public_data *wireless_data;
1686#endif
1687 const struct net_device_ops *netdev_ops;
1688 const struct ethtool_ops *ethtool_ops;
1689#ifdef CONFIG_NET_SWITCHDEV
1690 const struct switchdev_ops *switchdev_ops;
1691#endif
1692#ifdef CONFIG_NET_L3_MASTER_DEV
1693 const struct l3mdev_ops *l3mdev_ops;
1694#endif
1695#if IS_ENABLED(CONFIG_IPV6)
1696 const struct ndisc_ops *ndisc_ops;
1697#endif
1698
1699 const struct header_ops *header_ops;
1700
1701 unsigned int flags;
1702 unsigned int priv_flags;
1703
1704 unsigned short gflags;
1705 unsigned short padded;
1706
1707 unsigned char operstate;
1708 unsigned char link_mode;
1709
1710 unsigned char if_port;
1711 unsigned char dma;
1712
1713 unsigned int mtu;
1714 unsigned short type;
1715 unsigned short hard_header_len;
1716
1717 unsigned short needed_headroom;
1718 unsigned short needed_tailroom;
1719
1720
1721 unsigned char perm_addr[MAX_ADDR_LEN];
1722 unsigned char addr_assign_type;
1723 unsigned char addr_len;
1724 unsigned short neigh_priv_len;
1725 unsigned short dev_id;
1726 unsigned short dev_port;
1727 spinlock_t addr_list_lock;
1728 unsigned char name_assign_type;
1729 bool uc_promisc;
1730 struct netdev_hw_addr_list uc;
1731 struct netdev_hw_addr_list mc;
1732 struct netdev_hw_addr_list dev_addrs;
1733
1734#ifdef CONFIG_SYSFS
1735 struct kset *queues_kset;
1736#endif
1737 unsigned int promiscuity;
1738 unsigned int allmulti;
1739
1740
1741
1742
1743#if IS_ENABLED(CONFIG_VLAN_8021Q)
1744 struct vlan_info __rcu *vlan_info;
1745#endif
1746#if IS_ENABLED(CONFIG_NET_DSA)
1747 struct dsa_switch_tree *dsa_ptr;
1748#endif
1749#if IS_ENABLED(CONFIG_TIPC)
1750 struct tipc_bearer __rcu *tipc_ptr;
1751#endif
1752 void *atalk_ptr;
1753 struct in_device __rcu *ip_ptr;
1754 struct dn_dev __rcu *dn_ptr;
1755 struct inet6_dev __rcu *ip6_ptr;
1756 void *ax25_ptr;
1757 struct wireless_dev *ieee80211_ptr;
1758 struct wpan_dev *ieee802154_ptr;
1759#if IS_ENABLED(CONFIG_MPLS_ROUTING)
1760 struct mpls_dev __rcu *mpls_ptr;
1761#endif
1762
1763
1764
1765
1766 unsigned long last_rx;
1767
1768
1769 unsigned char *dev_addr;
1770
1771#ifdef CONFIG_SYSFS
1772 struct netdev_rx_queue *_rx;
1773
1774 unsigned int num_rx_queues;
1775 unsigned int real_num_rx_queues;
1776#endif
1777
1778 unsigned long gro_flush_timeout;
1779 rx_handler_func_t __rcu *rx_handler;
1780 void __rcu *rx_handler_data;
1781
1782#ifdef CONFIG_NET_CLS_ACT
1783 struct tcf_proto __rcu *ingress_cl_list;
1784#endif
1785 struct netdev_queue __rcu *ingress_queue;
1786#ifdef CONFIG_NETFILTER_INGRESS
1787 struct list_head nf_hooks_ingress;
1788#endif
1789
1790 unsigned char broadcast[MAX_ADDR_LEN];
1791#ifdef CONFIG_RFS_ACCEL
1792 struct cpu_rmap *rx_cpu_rmap;
1793#endif
1794 struct hlist_node index_hlist;
1795
1796
1797
1798
1799 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
1800 unsigned int num_tx_queues;
1801 unsigned int real_num_tx_queues;
1802 struct Qdisc *qdisc;
1803 unsigned long tx_queue_len;
1804 spinlock_t tx_global_lock;
1805 int watchdog_timeo;
1806
1807#ifdef CONFIG_XPS
1808 struct xps_dev_maps __rcu *xps_maps;
1809#endif
1810#ifdef CONFIG_NET_CLS_ACT
1811 struct tcf_proto __rcu *egress_cl_list;
1812#endif
1813#ifdef CONFIG_NET_SWITCHDEV
1814 u32 offload_fwd_mark;
1815#endif
1816
1817
1818 struct timer_list watchdog_timer;
1819
1820 int __percpu *pcpu_refcnt;
1821 struct list_head todo_list;
1822
1823 struct list_head link_watch_list;
1824
1825 enum { NETREG_UNINITIALIZED=0,
1826 NETREG_REGISTERED,
1827 NETREG_UNREGISTERING,
1828 NETREG_UNREGISTERED,
1829 NETREG_RELEASED,
1830 NETREG_DUMMY,
1831 } reg_state:8;
1832
1833 bool dismantle;
1834
1835 enum {
1836 RTNL_LINK_INITIALIZED,
1837 RTNL_LINK_INITIALIZING,
1838 } rtnl_link_state:16;
1839
1840 void (*destructor)(struct net_device *dev);
1841
1842#ifdef CONFIG_NETPOLL
1843 struct netpoll_info __rcu *npinfo;
1844#endif
1845
1846 possible_net_t nd_net;
1847
1848
1849 union {
1850 void *ml_priv;
1851 struct pcpu_lstats __percpu *lstats;
1852 struct pcpu_sw_netstats __percpu *tstats;
1853 struct pcpu_dstats __percpu *dstats;
1854 struct pcpu_vstats __percpu *vstats;
1855 };
1856
1857 struct garp_port __rcu *garp_port;
1858 struct mrp_port __rcu *mrp_port;
1859
1860 struct device dev;
1861 const struct attribute_group *sysfs_groups[4];
1862 const struct attribute_group *sysfs_rx_queue_group;
1863
1864 const struct rtnl_link_ops *rtnl_link_ops;
1865
1866
1867#define GSO_MAX_SIZE 65536
1868 unsigned int gso_max_size;
1869#define GSO_MAX_SEGS 65535
1870 u16 gso_max_segs;
1871
1872#ifdef CONFIG_DCB
1873 const struct dcbnl_rtnl_ops *dcbnl_ops;
1874#endif
1875 u8 num_tc;
1876 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
1877 u8 prio_tc_map[TC_BITMASK + 1];
1878
1879#if IS_ENABLED(CONFIG_FCOE)
1880 unsigned int fcoe_ddp_xid;
1881#endif
1882#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
1883 struct netprio_map __rcu *priomap;
1884#endif
1885 struct phy_device *phydev;
1886 struct lock_class_key *qdisc_tx_busylock;
1887 struct lock_class_key *qdisc_running_key;
1888 bool proto_down;
1889};
1890#define to_net_dev(d) container_of(d, struct net_device, dev)
1891
1892#define NETDEV_ALIGN 32
1893
1894static inline
1895int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
1896{
1897 return dev->prio_tc_map[prio & TC_BITMASK];
1898}
1899
1900static inline
1901int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
1902{
1903 if (tc >= dev->num_tc)
1904 return -EINVAL;
1905
1906 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
1907 return 0;
1908}
1909
1910static inline
1911void netdev_reset_tc(struct net_device *dev)
1912{
1913 dev->num_tc = 0;
1914 memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
1915 memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
1916}
1917
1918static inline
1919int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
1920{
1921 if (tc >= dev->num_tc)
1922 return -EINVAL;
1923
1924 dev->tc_to_txq[tc].count = count;
1925 dev->tc_to_txq[tc].offset = offset;
1926 return 0;
1927}
1928
1929static inline
1930int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
1931{
1932 if (num_tc > TC_MAX_QUEUE)
1933 return -EINVAL;
1934
1935 dev->num_tc = num_tc;
1936 return 0;
1937}
1938
1939static inline
1940int netdev_get_num_tc(struct net_device *dev)
1941{
1942 return dev->num_tc;
1943}
1944
1945static inline
1946struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
1947 unsigned int index)
1948{
1949 return &dev->_tx[index];
1950}
1951
1952static inline struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
1953 const struct sk_buff *skb)
1954{
1955 return netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
1956}
1957
1958static inline void netdev_for_each_tx_queue(struct net_device *dev,
1959 void (*f)(struct net_device *,
1960 struct netdev_queue *,
1961 void *),
1962 void *arg)
1963{
1964 unsigned int i;
1965
1966 for (i = 0; i < dev->num_tx_queues; i++)
1967 f(dev, &dev->_tx[i], arg);
1968}
1969
1970#define netdev_lockdep_set_classes(dev) \
1971{ \
1972 static struct lock_class_key qdisc_tx_busylock_key; \
1973 static struct lock_class_key qdisc_running_key; \
1974 static struct lock_class_key qdisc_xmit_lock_key; \
1975 static struct lock_class_key dev_addr_list_lock_key; \
1976 unsigned int i; \
1977 \
1978 (dev)->qdisc_tx_busylock = &qdisc_tx_busylock_key; \
1979 (dev)->qdisc_running_key = &qdisc_running_key; \
1980 lockdep_set_class(&(dev)->addr_list_lock, \
1981 &dev_addr_list_lock_key); \
1982 for (i = 0; i < (dev)->num_tx_queues; i++) \
1983 lockdep_set_class(&(dev)->_tx[i]._xmit_lock, \
1984 &qdisc_xmit_lock_key); \
1985}
1986
1987struct netdev_queue *netdev_pick_tx(struct net_device *dev,
1988 struct sk_buff *skb,
1989 void *accel_priv);
1990
1991
1992
1993
1994static inline unsigned netdev_get_fwd_headroom(struct net_device *dev)
1995{
1996 return dev->priv_flags & IFF_PHONY_HEADROOM ? 0 : dev->needed_headroom;
1997}
1998
1999static inline void netdev_set_rx_headroom(struct net_device *dev, int new_hr)
2000{
2001 if (dev->netdev_ops->ndo_set_rx_headroom)
2002 dev->netdev_ops->ndo_set_rx_headroom(dev, new_hr);
2003}
2004
2005
2006static inline void netdev_reset_rx_headroom(struct net_device *dev)
2007{
2008 netdev_set_rx_headroom(dev, -1);
2009}
2010
2011
2012
2013
2014static inline
2015struct net *dev_net(const struct net_device *dev)
2016{
2017 return read_pnet(&dev->nd_net);
2018}
2019
2020static inline
2021void dev_net_set(struct net_device *dev, struct net *net)
2022{
2023 write_pnet(&dev->nd_net, net);
2024}
2025
2026static inline bool netdev_uses_dsa(struct net_device *dev)
2027{
2028#if IS_ENABLED(CONFIG_NET_DSA)
2029 if (dev->dsa_ptr != NULL)
2030 return dsa_uses_tagged_protocol(dev->dsa_ptr);
2031#endif
2032 return false;
2033}
2034
2035
2036
2037
2038
2039
2040
2041static inline void *netdev_priv(const struct net_device *dev)
2042{
2043 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
2044}
2045
2046
2047
2048
2049#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
2050
2051
2052
2053
2054
2055#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
2056
2057
2058
2059
2060#define NAPI_POLL_WEIGHT 64
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
2073 int (*poll)(struct napi_struct *, int), int weight);
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086static inline void netif_tx_napi_add(struct net_device *dev,
2087 struct napi_struct *napi,
2088 int (*poll)(struct napi_struct *, int),
2089 int weight)
2090{
2091 set_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state);
2092 netif_napi_add(dev, napi, poll, weight);
2093}
2094
2095
2096
2097
2098
2099
2100
2101void netif_napi_del(struct napi_struct *napi);
2102
2103struct napi_gro_cb {
2104
2105 void *frag0;
2106
2107
2108 unsigned int frag0_len;
2109
2110
2111 int data_offset;
2112
2113
2114 u16 flush;
2115
2116
2117 u16 flush_id;
2118
2119
2120 u16 count;
2121
2122
2123 u16 gro_remcsum_start;
2124
2125
2126 unsigned long age;
2127
2128
2129 u16 proto;
2130
2131
2132 u8 same_flow:1;
2133
2134
2135 u8 encap_mark:1;
2136
2137
2138 u8 csum_valid:1;
2139
2140
2141 u8 csum_cnt:3;
2142
2143
2144 u8 free:2;
2145#define NAPI_GRO_FREE 1
2146#define NAPI_GRO_FREE_STOLEN_HEAD 2
2147
2148
2149 u8 is_ipv6:1;
2150
2151
2152 u8 is_fou:1;
2153
2154
2155 u8 is_atomic:1;
2156
2157
2158
2159
2160 __wsum csum;
2161
2162
2163 struct sk_buff *last;
2164};
2165
2166#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
2167
2168struct packet_type {
2169 __be16 type;
2170 struct net_device *dev;
2171 int (*func) (struct sk_buff *,
2172 struct net_device *,
2173 struct packet_type *,
2174 struct net_device *);
2175 bool (*id_match)(struct packet_type *ptype,
2176 struct sock *sk);
2177 void *af_packet_priv;
2178 struct list_head list;
2179};
2180
2181struct offload_callbacks {
2182 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
2183 netdev_features_t features);
2184 struct sk_buff **(*gro_receive)(struct sk_buff **head,
2185 struct sk_buff *skb);
2186 int (*gro_complete)(struct sk_buff *skb, int nhoff);
2187};
2188
2189struct packet_offload {
2190 __be16 type;
2191 u16 priority;
2192 struct offload_callbacks callbacks;
2193 struct list_head list;
2194};
2195
2196
2197struct pcpu_sw_netstats {
2198 u64 rx_packets;
2199 u64 rx_bytes;
2200 u64 tx_packets;
2201 u64 tx_bytes;
2202 struct u64_stats_sync syncp;
2203};
2204
2205#define __netdev_alloc_pcpu_stats(type, gfp) \
2206({ \
2207 typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
2208 if (pcpu_stats) { \
2209 int __cpu; \
2210 for_each_possible_cpu(__cpu) { \
2211 typeof(type) *stat; \
2212 stat = per_cpu_ptr(pcpu_stats, __cpu); \
2213 u64_stats_init(&stat->syncp); \
2214 } \
2215 } \
2216 pcpu_stats; \
2217})
2218
2219#define netdev_alloc_pcpu_stats(type) \
2220 __netdev_alloc_pcpu_stats(type, GFP_KERNEL)
2221
2222enum netdev_lag_tx_type {
2223 NETDEV_LAG_TX_TYPE_UNKNOWN,
2224 NETDEV_LAG_TX_TYPE_RANDOM,
2225 NETDEV_LAG_TX_TYPE_BROADCAST,
2226 NETDEV_LAG_TX_TYPE_ROUNDROBIN,
2227 NETDEV_LAG_TX_TYPE_ACTIVEBACKUP,
2228 NETDEV_LAG_TX_TYPE_HASH,
2229};
2230
2231struct netdev_lag_upper_info {
2232 enum netdev_lag_tx_type tx_type;
2233};
2234
2235struct netdev_lag_lower_state_info {
2236 u8 link_up : 1,
2237 tx_enabled : 1;
2238};
2239
2240#include <linux/notifier.h>
2241
2242
2243
2244
2245
2246#define NETDEV_UP 0x0001
2247#define NETDEV_DOWN 0x0002
2248#define NETDEV_REBOOT 0x0003
2249
2250
2251
2252#define NETDEV_CHANGE 0x0004
2253#define NETDEV_REGISTER 0x0005
2254#define NETDEV_UNREGISTER 0x0006
2255#define NETDEV_CHANGEMTU 0x0007
2256#define NETDEV_CHANGEADDR 0x0008
2257#define NETDEV_GOING_DOWN 0x0009
2258#define NETDEV_CHANGENAME 0x000A
2259#define NETDEV_FEAT_CHANGE 0x000B
2260#define NETDEV_BONDING_FAILOVER 0x000C
2261#define NETDEV_PRE_UP 0x000D
2262#define NETDEV_PRE_TYPE_CHANGE 0x000E
2263#define NETDEV_POST_TYPE_CHANGE 0x000F
2264#define NETDEV_POST_INIT 0x0010
2265#define NETDEV_UNREGISTER_FINAL 0x0011
2266#define NETDEV_RELEASE 0x0012
2267#define NETDEV_NOTIFY_PEERS 0x0013
2268#define NETDEV_JOIN 0x0014
2269#define NETDEV_CHANGEUPPER 0x0015
2270#define NETDEV_RESEND_IGMP 0x0016
2271#define NETDEV_PRECHANGEMTU 0x0017
2272#define NETDEV_CHANGEINFODATA 0x0018
2273#define NETDEV_BONDING_INFO 0x0019
2274#define NETDEV_PRECHANGEUPPER 0x001A
2275#define NETDEV_CHANGELOWERSTATE 0x001B
2276#define NETDEV_UDP_TUNNEL_PUSH_INFO 0x001C
2277#define NETDEV_CHANGE_TX_QUEUE_LEN 0x001E
2278
2279int register_netdevice_notifier(struct notifier_block *nb);
2280int unregister_netdevice_notifier(struct notifier_block *nb);
2281
2282struct netdev_notifier_info {
2283 struct net_device *dev;
2284};
2285
2286struct netdev_notifier_change_info {
2287 struct netdev_notifier_info info;
2288 unsigned int flags_changed;
2289};
2290
2291struct netdev_notifier_changeupper_info {
2292 struct netdev_notifier_info info;
2293 struct net_device *upper_dev;
2294 bool master;
2295 bool linking;
2296 void *upper_info;
2297};
2298
2299struct netdev_notifier_changelowerstate_info {
2300 struct netdev_notifier_info info;
2301 void *lower_state_info;
2302};
2303
2304static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
2305 struct net_device *dev)
2306{
2307 info->dev = dev;
2308}
2309
2310static inline struct net_device *
2311netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
2312{
2313 return info->dev;
2314}
2315
2316int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
2317
2318
2319extern rwlock_t dev_base_lock;
2320
2321#define for_each_netdev(net, d) \
2322 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
2323#define for_each_netdev_reverse(net, d) \
2324 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
2325#define for_each_netdev_rcu(net, d) \
2326 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
2327#define for_each_netdev_safe(net, d, n) \
2328 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
2329#define for_each_netdev_continue(net, d) \
2330 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
2331#define for_each_netdev_continue_rcu(net, d) \
2332 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
2333#define for_each_netdev_in_bond_rcu(bond, slave) \
2334 for_each_netdev_rcu(&init_net, slave) \
2335 if (netdev_master_upper_dev_get_rcu(slave) == (bond))
2336#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
2337
2338static inline struct net_device *next_net_device(struct net_device *dev)
2339{
2340 struct list_head *lh;
2341 struct net *net;
2342
2343 net = dev_net(dev);
2344 lh = dev->dev_list.next;
2345 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2346}
2347
2348static inline struct net_device *next_net_device_rcu(struct net_device *dev)
2349{
2350 struct list_head *lh;
2351 struct net *net;
2352
2353 net = dev_net(dev);
2354 lh = rcu_dereference(list_next_rcu(&dev->dev_list));
2355 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2356}
2357
2358static inline struct net_device *first_net_device(struct net *net)
2359{
2360 return list_empty(&net->dev_base_head) ? NULL :
2361 net_device_entry(net->dev_base_head.next);
2362}
2363
2364static inline struct net_device *first_net_device_rcu(struct net *net)
2365{
2366 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
2367
2368 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2369}
2370
2371int netdev_boot_setup_check(struct net_device *dev);
2372unsigned long netdev_boot_base(const char *prefix, int unit);
2373struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
2374 const char *hwaddr);
2375struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
2376struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
2377void dev_add_pack(struct packet_type *pt);
2378void dev_remove_pack(struct packet_type *pt);
2379void __dev_remove_pack(struct packet_type *pt);
2380void dev_add_offload(struct packet_offload *po);
2381void dev_remove_offload(struct packet_offload *po);
2382
2383int dev_get_iflink(const struct net_device *dev);
2384int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb);
2385struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
2386 unsigned short mask);
2387struct net_device *dev_get_by_name(struct net *net, const char *name);
2388struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
2389struct net_device *__dev_get_by_name(struct net *net, const char *name);
2390int dev_alloc_name(struct net_device *dev, const char *name);
2391int dev_open(struct net_device *dev);
2392int dev_close(struct net_device *dev);
2393int dev_close_many(struct list_head *head, bool unlink);
2394void dev_disable_lro(struct net_device *dev);
2395int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *newskb);
2396int dev_queue_xmit(struct sk_buff *skb);
2397int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv);
2398int register_netdevice(struct net_device *dev);
2399void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
2400void unregister_netdevice_many(struct list_head *head);
2401static inline void unregister_netdevice(struct net_device *dev)
2402{
2403 unregister_netdevice_queue(dev, NULL);
2404}
2405
2406int netdev_refcnt_read(const struct net_device *dev);
2407void free_netdev(struct net_device *dev);
2408void netdev_freemem(struct net_device *dev);
2409void synchronize_net(void);
2410int init_dummy_netdev(struct net_device *dev);
2411
2412DECLARE_PER_CPU(int, xmit_recursion);
2413#define XMIT_RECURSION_LIMIT 10
2414
2415static inline int dev_recursion_level(void)
2416{
2417 return this_cpu_read(xmit_recursion);
2418}
2419
2420struct net_device *dev_get_by_index(struct net *net, int ifindex);
2421struct net_device *__dev_get_by_index(struct net *net, int ifindex);
2422struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
2423int netdev_get_name(struct net *net, char *name, int ifindex);
2424int dev_restart(struct net_device *dev);
2425int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb);
2426
2427static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
2428{
2429 return NAPI_GRO_CB(skb)->data_offset;
2430}
2431
2432static inline unsigned int skb_gro_len(const struct sk_buff *skb)
2433{
2434 return skb->len - NAPI_GRO_CB(skb)->data_offset;
2435}
2436
2437static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
2438{
2439 NAPI_GRO_CB(skb)->data_offset += len;
2440}
2441
2442static inline void *skb_gro_header_fast(struct sk_buff *skb,
2443 unsigned int offset)
2444{
2445 return NAPI_GRO_CB(skb)->frag0 + offset;
2446}
2447
2448static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
2449{
2450 return NAPI_GRO_CB(skb)->frag0_len < hlen;
2451}
2452
2453static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
2454 unsigned int offset)
2455{
2456 if (!pskb_may_pull(skb, hlen))
2457 return NULL;
2458
2459 NAPI_GRO_CB(skb)->frag0 = NULL;
2460 NAPI_GRO_CB(skb)->frag0_len = 0;
2461 return skb->data + offset;
2462}
2463
2464static inline void *skb_gro_network_header(struct sk_buff *skb)
2465{
2466 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
2467 skb_network_offset(skb);
2468}
2469
2470static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
2471 const void *start, unsigned int len)
2472{
2473 if (NAPI_GRO_CB(skb)->csum_valid)
2474 NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
2475 csum_partial(start, len, 0));
2476}
2477
2478
2479
2480
2481
2482
2483__sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
2484
2485static inline bool skb_at_gro_remcsum_start(struct sk_buff *skb)
2486{
2487 return (NAPI_GRO_CB(skb)->gro_remcsum_start == skb_gro_offset(skb));
2488}
2489
2490static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
2491 bool zero_okay,
2492 __sum16 check)
2493{
2494 return ((skb->ip_summed != CHECKSUM_PARTIAL ||
2495 skb_checksum_start_offset(skb) <
2496 skb_gro_offset(skb)) &&
2497 !skb_at_gro_remcsum_start(skb) &&
2498 NAPI_GRO_CB(skb)->csum_cnt == 0 &&
2499 (!zero_okay || check));
2500}
2501
2502static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
2503 __wsum psum)
2504{
2505 if (NAPI_GRO_CB(skb)->csum_valid &&
2506 !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
2507 return 0;
2508
2509 NAPI_GRO_CB(skb)->csum = psum;
2510
2511 return __skb_gro_checksum_complete(skb);
2512}
2513
2514static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
2515{
2516 if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
2517
2518 NAPI_GRO_CB(skb)->csum_cnt--;
2519 } else {
2520
2521
2522
2523
2524 __skb_incr_checksum_unnecessary(skb);
2525 }
2526}
2527
2528#define __skb_gro_checksum_validate(skb, proto, zero_okay, check, \
2529 compute_pseudo) \
2530({ \
2531 __sum16 __ret = 0; \
2532 if (__skb_gro_checksum_validate_needed(skb, zero_okay, check)) \
2533 __ret = __skb_gro_checksum_validate_complete(skb, \
2534 compute_pseudo(skb, proto)); \
2535 if (__ret) \
2536 __skb_mark_checksum_bad(skb); \
2537 else \
2538 skb_gro_incr_csum_unnecessary(skb); \
2539 __ret; \
2540})
2541
2542#define skb_gro_checksum_validate(skb, proto, compute_pseudo) \
2543 __skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)
2544
2545#define skb_gro_checksum_validate_zero_check(skb, proto, check, \
2546 compute_pseudo) \
2547 __skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)
2548
2549#define skb_gro_checksum_simple_validate(skb) \
2550 __skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)
2551
2552static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
2553{
2554 return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
2555 !NAPI_GRO_CB(skb)->csum_valid);
2556}
2557
2558static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
2559 __sum16 check, __wsum pseudo)
2560{
2561 NAPI_GRO_CB(skb)->csum = ~pseudo;
2562 NAPI_GRO_CB(skb)->csum_valid = 1;
2563}
2564
2565#define skb_gro_checksum_try_convert(skb, proto, check, compute_pseudo) \
2566do { \
2567 if (__skb_gro_checksum_convert_check(skb)) \
2568 __skb_gro_checksum_convert(skb, check, \
2569 compute_pseudo(skb, proto)); \
2570} while (0)
2571
2572struct gro_remcsum {
2573 int offset;
2574 __wsum delta;
2575};
2576
2577static inline void skb_gro_remcsum_init(struct gro_remcsum *grc)
2578{
2579 grc->offset = 0;
2580 grc->delta = 0;
2581}
2582
2583static inline void *skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
2584 unsigned int off, size_t hdrlen,
2585 int start, int offset,
2586 struct gro_remcsum *grc,
2587 bool nopartial)
2588{
2589 __wsum delta;
2590 size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);
2591
2592 BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);
2593
2594 if (!nopartial) {
2595 NAPI_GRO_CB(skb)->gro_remcsum_start = off + hdrlen + start;
2596 return ptr;
2597 }
2598
2599 ptr = skb_gro_header_fast(skb, off);
2600 if (skb_gro_header_hard(skb, off + plen)) {
2601 ptr = skb_gro_header_slow(skb, off + plen, off);
2602 if (!ptr)
2603 return NULL;
2604 }
2605
2606 delta = remcsum_adjust(ptr + hdrlen, NAPI_GRO_CB(skb)->csum,
2607 start, offset);
2608
2609
2610 NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);
2611
2612 grc->offset = off + hdrlen + offset;
2613 grc->delta = delta;
2614
2615 return ptr;
2616}
2617
2618static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
2619 struct gro_remcsum *grc)
2620{
2621 void *ptr;
2622 size_t plen = grc->offset + sizeof(u16);
2623
2624 if (!grc->delta)
2625 return;
2626
2627 ptr = skb_gro_header_fast(skb, grc->offset);
2628 if (skb_gro_header_hard(skb, grc->offset + sizeof(u16))) {
2629 ptr = skb_gro_header_slow(skb, plen, grc->offset);
2630 if (!ptr)
2631 return;
2632 }
2633
2634 remcsum_unadjust((__sum16 *)ptr, grc->delta);
2635}
2636
2637struct skb_csum_offl_spec {
2638 __u16 ipv4_okay:1,
2639 ipv6_okay:1,
2640 encap_okay:1,
2641 ip_options_okay:1,
2642 ext_hdrs_okay:1,
2643 tcp_okay:1,
2644 udp_okay:1,
2645 sctp_okay:1,
2646 vlan_okay:1,
2647 no_encapped_ipv6:1,
2648 no_not_encapped:1;
2649};
2650
2651bool __skb_csum_offload_chk(struct sk_buff *skb,
2652 const struct skb_csum_offl_spec *spec,
2653 bool *csum_encapped,
2654 bool csum_help);
2655
2656static inline bool skb_csum_offload_chk(struct sk_buff *skb,
2657 const struct skb_csum_offl_spec *spec,
2658 bool *csum_encapped,
2659 bool csum_help)
2660{
2661 if (skb->ip_summed != CHECKSUM_PARTIAL)
2662 return false;
2663
2664 return __skb_csum_offload_chk(skb, spec, csum_encapped, csum_help);
2665}
2666
2667static inline bool skb_csum_offload_chk_help(struct sk_buff *skb,
2668 const struct skb_csum_offl_spec *spec)
2669{
2670 bool csum_encapped;
2671
2672 return skb_csum_offload_chk(skb, spec, &csum_encapped, true);
2673}
2674
2675static inline bool skb_csum_off_chk_help_cmn(struct sk_buff *skb)
2676{
2677 static const struct skb_csum_offl_spec csum_offl_spec = {
2678 .ipv4_okay = 1,
2679 .ip_options_okay = 1,
2680 .ipv6_okay = 1,
2681 .vlan_okay = 1,
2682 .tcp_okay = 1,
2683 .udp_okay = 1,
2684 };
2685
2686 return skb_csum_offload_chk_help(skb, &csum_offl_spec);
2687}
2688
2689static inline bool skb_csum_off_chk_help_cmn_v4_only(struct sk_buff *skb)
2690{
2691 static const struct skb_csum_offl_spec csum_offl_spec = {
2692 .ipv4_okay = 1,
2693 .ip_options_okay = 1,
2694 .tcp_okay = 1,
2695 .udp_okay = 1,
2696 .vlan_okay = 1,
2697 };
2698
2699 return skb_csum_offload_chk_help(skb, &csum_offl_spec);
2700}
2701
2702static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
2703 unsigned short type,
2704 const void *daddr, const void *saddr,
2705 unsigned int len)
2706{
2707 if (!dev->header_ops || !dev->header_ops->create)
2708 return 0;
2709
2710 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
2711}
2712
2713static inline int dev_parse_header(const struct sk_buff *skb,
2714 unsigned char *haddr)
2715{
2716 const struct net_device *dev = skb->dev;
2717
2718 if (!dev->header_ops || !dev->header_ops->parse)
2719 return 0;
2720 return dev->header_ops->parse(skb, haddr);
2721}
2722
2723
2724static inline bool dev_validate_header(const struct net_device *dev,
2725 char *ll_header, int len)
2726{
2727 if (likely(len >= dev->hard_header_len))
2728 return true;
2729
2730 if (capable(CAP_SYS_RAWIO)) {
2731 memset(ll_header + len, 0, dev->hard_header_len - len);
2732 return true;
2733 }
2734
2735 if (dev->header_ops && dev->header_ops->validate)
2736 return dev->header_ops->validate(ll_header, len);
2737
2738 return false;
2739}
2740
2741typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
2742int register_gifconf(unsigned int family, gifconf_func_t *gifconf);
2743static inline int unregister_gifconf(unsigned int family)
2744{
2745 return register_gifconf(family, NULL);
2746}
2747
2748#ifdef CONFIG_NET_FLOW_LIMIT
2749#define FLOW_LIMIT_HISTORY (1 << 7)
2750struct sd_flow_limit {
2751 u64 count;
2752 unsigned int num_buckets;
2753 unsigned int history_head;
2754 u16 history[FLOW_LIMIT_HISTORY];
2755 u8 buckets[];
2756};
2757
2758extern int netdev_flow_limit_table_len;
2759#endif
2760
2761
2762
2763
2764struct softnet_data {
2765 struct list_head poll_list;
2766 struct sk_buff_head process_queue;
2767
2768
2769 unsigned int processed;
2770 unsigned int time_squeeze;
2771 unsigned int received_rps;
2772#ifdef CONFIG_RPS
2773 struct softnet_data *rps_ipi_list;
2774#endif
2775#ifdef CONFIG_NET_FLOW_LIMIT
2776 struct sd_flow_limit __rcu *flow_limit;
2777#endif
2778 struct Qdisc *output_queue;
2779 struct Qdisc **output_queue_tailp;
2780 struct sk_buff *completion_queue;
2781
2782#ifdef CONFIG_RPS
2783
2784
2785
2786 unsigned int input_queue_head ____cacheline_aligned_in_smp;
2787
2788
2789 struct call_single_data csd ____cacheline_aligned_in_smp;
2790 struct softnet_data *rps_ipi_next;
2791 unsigned int cpu;
2792 unsigned int input_queue_tail;
2793#endif
2794 unsigned int dropped;
2795 struct sk_buff_head input_pkt_queue;
2796 struct napi_struct backlog;
2797
2798};
2799
2800static inline void input_queue_head_incr(struct softnet_data *sd)
2801{
2802#ifdef CONFIG_RPS
2803 sd->input_queue_head++;
2804#endif
2805}
2806
2807static inline void input_queue_tail_incr_save(struct softnet_data *sd,
2808 unsigned int *qtail)
2809{
2810#ifdef CONFIG_RPS
2811 *qtail = ++sd->input_queue_tail;
2812#endif
2813}
2814
2815DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
2816
2817void __netif_schedule(struct Qdisc *q);
2818void netif_schedule_queue(struct netdev_queue *txq);
2819
2820static inline void netif_tx_schedule_all(struct net_device *dev)
2821{
2822 unsigned int i;
2823
2824 for (i = 0; i < dev->num_tx_queues; i++)
2825 netif_schedule_queue(netdev_get_tx_queue(dev, i));
2826}
2827
2828static __always_inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
2829{
2830 clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
2831}
2832
2833
2834
2835
2836
2837
2838
2839static inline void netif_start_queue(struct net_device *dev)
2840{
2841 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
2842}
2843
2844static inline void netif_tx_start_all_queues(struct net_device *dev)
2845{
2846 unsigned int i;
2847
2848 for (i = 0; i < dev->num_tx_queues; i++) {
2849 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2850 netif_tx_start_queue(txq);
2851 }
2852}
2853
2854void netif_tx_wake_queue(struct netdev_queue *dev_queue);
2855
2856
2857
2858
2859
2860
2861
2862
2863static inline void netif_wake_queue(struct net_device *dev)
2864{
2865 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
2866}
2867
2868static inline void netif_tx_wake_all_queues(struct net_device *dev)
2869{
2870 unsigned int i;
2871
2872 for (i = 0; i < dev->num_tx_queues; i++) {
2873 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2874 netif_tx_wake_queue(txq);
2875 }
2876}
2877
2878static __always_inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
2879{
2880 set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
2881}
2882
2883
2884
2885
2886
2887
2888
2889
2890static inline void netif_stop_queue(struct net_device *dev)
2891{
2892 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
2893}
2894
2895void netif_tx_stop_all_queues(struct net_device *dev);
2896
2897static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
2898{
2899 return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
2900}
2901
2902
2903
2904
2905
2906
2907
2908static inline bool netif_queue_stopped(const struct net_device *dev)
2909{
2910 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
2911}
2912
2913static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
2914{
2915 return dev_queue->state & QUEUE_STATE_ANY_XOFF;
2916}
2917
2918static inline bool
2919netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
2920{
2921 return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
2922}
2923
2924static inline bool
2925netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
2926{
2927 return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
2928}
2929
2930
2931
2932
2933
2934
2935
2936
2937static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
2938{
2939#ifdef CONFIG_BQL
2940 prefetchw(&dev_queue->dql.num_queued);
2941#endif
2942}
2943
2944
2945
2946
2947
2948
2949
2950
2951static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
2952{
2953#ifdef CONFIG_BQL
2954 prefetchw(&dev_queue->dql.limit);
2955#endif
2956}
2957
2958static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
2959 unsigned int bytes)
2960{
2961#ifdef CONFIG_BQL
2962 dql_queued(&dev_queue->dql, bytes);
2963
2964 if (likely(dql_avail(&dev_queue->dql) >= 0))
2965 return;
2966
2967 set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
2968
2969
2970
2971
2972
2973
2974 smp_mb();
2975
2976
2977 if (unlikely(dql_avail(&dev_queue->dql) >= 0))
2978 clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
2979#endif
2980}
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
2992{
2993 netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes);
2994}
2995
2996static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
2997 unsigned int pkts, unsigned int bytes)
2998{
2999#ifdef CONFIG_BQL
3000 if (unlikely(!bytes))
3001 return;
3002
3003 dql_completed(&dev_queue->dql, bytes);
3004
3005
3006
3007
3008
3009
3010 smp_mb();
3011
3012 if (dql_avail(&dev_queue->dql) < 0)
3013 return;
3014
3015 if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
3016 netif_schedule_queue(dev_queue);
3017#endif
3018}
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030static inline void netdev_completed_queue(struct net_device *dev,
3031 unsigned int pkts, unsigned int bytes)
3032{
3033 netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes);
3034}
3035
3036static inline void netdev_tx_reset_queue(struct netdev_queue *q)
3037{
3038#ifdef CONFIG_BQL
3039 clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
3040 dql_reset(&q->dql);
3041#endif
3042}
3043
3044
3045
3046
3047
3048
3049
3050
3051static inline void netdev_reset_queue(struct net_device *dev_queue)
3052{
3053 netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0));
3054}
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
3065{
3066 if (unlikely(queue_index >= dev->real_num_tx_queues)) {
3067 net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
3068 dev->name, queue_index,
3069 dev->real_num_tx_queues);
3070 return 0;
3071 }
3072
3073 return queue_index;
3074}
3075
3076
3077
3078
3079
3080
3081
3082static inline bool netif_running(const struct net_device *dev)
3083{
3084 return test_bit(__LINK_STATE_START, &dev->state);
3085}
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
3102{
3103 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
3104
3105 netif_tx_start_queue(txq);
3106}
3107
3108
3109
3110
3111
3112
3113
3114
3115static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
3116{
3117 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
3118 netif_tx_stop_queue(txq);
3119}
3120
3121
3122
3123
3124
3125
3126
3127
3128static inline bool __netif_subqueue_stopped(const struct net_device *dev,
3129 u16 queue_index)
3130{
3131 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
3132
3133 return netif_tx_queue_stopped(txq);
3134}
3135
3136static inline bool netif_subqueue_stopped(const struct net_device *dev,
3137 struct sk_buff *skb)
3138{
3139 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
3140}
3141
3142void netif_wake_subqueue(struct net_device *dev, u16 queue_index);
3143
3144#ifdef CONFIG_XPS
3145int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
3146 u16 index);
3147#else
3148static inline int netif_set_xps_queue(struct net_device *dev,
3149 const struct cpumask *mask,
3150 u16 index)
3151{
3152 return 0;
3153}
3154#endif
3155
3156u16 __skb_tx_hash(const struct net_device *dev, struct sk_buff *skb,
3157 unsigned int num_tx_queues);
3158
3159
3160
3161
3162
3163static inline u16 skb_tx_hash(const struct net_device *dev,
3164 struct sk_buff *skb)
3165{
3166 return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
3167}
3168
3169
3170
3171
3172
3173
3174
3175static inline bool netif_is_multiqueue(const struct net_device *dev)
3176{
3177 return dev->num_tx_queues > 1;
3178}
3179
3180int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
3181
3182#ifdef CONFIG_SYSFS
3183int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq);
3184#else
3185static inline int netif_set_real_num_rx_queues(struct net_device *dev,
3186 unsigned int rxq)
3187{
3188 return 0;
3189}
3190#endif
3191
3192#ifdef CONFIG_SYSFS
3193static inline unsigned int get_netdev_rx_queue_index(
3194 struct netdev_rx_queue *queue)
3195{
3196 struct net_device *dev = queue->dev;
3197 int index = queue - dev->_rx;
3198
3199 BUG_ON(index >= dev->num_rx_queues);
3200 return index;
3201}
3202#endif
3203
3204#define DEFAULT_MAX_NUM_RSS_QUEUES (8)
3205int netif_get_num_default_rss_queues(void);
3206
3207enum skb_free_reason {
3208 SKB_REASON_CONSUMED,
3209 SKB_REASON_DROPPED,
3210};
3211
3212void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason);
3213void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason);
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234static inline void dev_kfree_skb_irq(struct sk_buff *skb)
3235{
3236 __dev_kfree_skb_irq(skb, SKB_REASON_DROPPED);
3237}
3238
3239static inline void dev_consume_skb_irq(struct sk_buff *skb)
3240{
3241 __dev_kfree_skb_irq(skb, SKB_REASON_CONSUMED);
3242}
3243
3244static inline void dev_kfree_skb_any(struct sk_buff *skb)
3245{
3246 __dev_kfree_skb_any(skb, SKB_REASON_DROPPED);
3247}
3248
3249static inline void dev_consume_skb_any(struct sk_buff *skb)
3250{
3251 __dev_kfree_skb_any(skb, SKB_REASON_CONSUMED);
3252}
3253
3254int netif_rx(struct sk_buff *skb);
3255int netif_rx_ni(struct sk_buff *skb);
3256int netif_receive_skb(struct sk_buff *skb);
3257gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
3258void napi_gro_flush(struct napi_struct *napi, bool flush_old);
3259struct sk_buff *napi_get_frags(struct napi_struct *napi);
3260gro_result_t napi_gro_frags(struct napi_struct *napi);
3261struct packet_offload *gro_find_receive_by_type(__be16 type);
3262struct packet_offload *gro_find_complete_by_type(__be16 type);
3263
3264static inline void napi_free_frags(struct napi_struct *napi)
3265{
3266 kfree_skb(napi->skb);
3267 napi->skb = NULL;
3268}
3269
3270bool netdev_is_rx_handler_busy(struct net_device *dev);
3271int netdev_rx_handler_register(struct net_device *dev,
3272 rx_handler_func_t *rx_handler,
3273 void *rx_handler_data);
3274void netdev_rx_handler_unregister(struct net_device *dev);
3275
3276bool dev_valid_name(const char *name);
3277int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
3278int dev_ethtool(struct net *net, struct ifreq *);
3279unsigned int dev_get_flags(const struct net_device *);
3280int __dev_change_flags(struct net_device *, unsigned int flags);
3281int dev_change_flags(struct net_device *, unsigned int);
3282void __dev_notify_flags(struct net_device *, unsigned int old_flags,
3283 unsigned int gchanges);
3284int dev_change_name(struct net_device *, const char *);
3285int dev_set_alias(struct net_device *, const char *, size_t);
3286int dev_change_net_namespace(struct net_device *, struct net *, const char *);
3287int dev_set_mtu(struct net_device *, int);
3288void dev_set_group(struct net_device *, int);
3289int dev_set_mac_address(struct net_device *, struct sockaddr *);
3290int dev_change_carrier(struct net_device *, bool new_carrier);
3291int dev_get_phys_port_id(struct net_device *dev,
3292 struct netdev_phys_item_id *ppid);
3293int dev_get_phys_port_name(struct net_device *dev,
3294 char *name, size_t len);
3295int dev_change_proto_down(struct net_device *dev, bool proto_down);
3296int dev_change_xdp_fd(struct net_device *dev, int fd);
3297struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev);
3298struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
3299 struct netdev_queue *txq, int *ret);
3300int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
3301int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
3302bool is_skb_forwardable(const struct net_device *dev,
3303 const struct sk_buff *skb);
3304
3305void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
3306
3307extern int netdev_budget;
3308
3309
3310void netdev_run_todo(void);
3311
3312
3313
3314
3315
3316
3317
3318static inline void dev_put(struct net_device *dev)
3319{
3320 this_cpu_dec(*dev->pcpu_refcnt);
3321}
3322
3323
3324
3325
3326
3327
3328
3329static inline void dev_hold(struct net_device *dev)
3330{
3331 this_cpu_inc(*dev->pcpu_refcnt);
3332}
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343void linkwatch_init_dev(struct net_device *dev);
3344void linkwatch_fire_event(struct net_device *dev);
3345void linkwatch_forget_dev(struct net_device *dev);
3346
3347
3348
3349
3350
3351
3352
3353static inline bool netif_carrier_ok(const struct net_device *dev)
3354{
3355 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
3356}
3357
3358unsigned long dev_trans_start(struct net_device *dev);
3359
3360void __netdev_watchdog_up(struct net_device *dev);
3361
3362void netif_carrier_on(struct net_device *dev);
3363
3364void netif_carrier_off(struct net_device *dev);
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378static inline void netif_dormant_on(struct net_device *dev)
3379{
3380 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
3381 linkwatch_fire_event(dev);
3382}
3383
3384
3385
3386
3387
3388
3389
3390static inline void netif_dormant_off(struct net_device *dev)
3391{
3392 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
3393 linkwatch_fire_event(dev);
3394}
3395
3396
3397
3398
3399
3400
3401
3402static inline bool netif_dormant(const struct net_device *dev)
3403{
3404 return test_bit(__LINK_STATE_DORMANT, &dev->state);
3405}
3406
3407
3408
3409
3410
3411
3412
3413
3414static inline bool netif_oper_up(const struct net_device *dev)
3415{
3416 return (dev->operstate == IF_OPER_UP ||
3417 dev->operstate == IF_OPER_UNKNOWN );
3418}
3419
3420
3421
3422
3423
3424
3425
3426static inline bool netif_device_present(struct net_device *dev)
3427{
3428 return test_bit(__LINK_STATE_PRESENT, &dev->state);
3429}
3430
3431void netif_device_detach(struct net_device *dev);
3432
3433void netif_device_attach(struct net_device *dev);
3434
3435
3436
3437
3438
3439enum {
3440 NETIF_MSG_DRV = 0x0001,
3441 NETIF_MSG_PROBE = 0x0002,
3442 NETIF_MSG_LINK = 0x0004,
3443 NETIF_MSG_TIMER = 0x0008,
3444 NETIF_MSG_IFDOWN = 0x0010,
3445 NETIF_MSG_IFUP = 0x0020,
3446 NETIF_MSG_RX_ERR = 0x0040,
3447 NETIF_MSG_TX_ERR = 0x0080,
3448 NETIF_MSG_TX_QUEUED = 0x0100,
3449 NETIF_MSG_INTR = 0x0200,
3450 NETIF_MSG_TX_DONE = 0x0400,
3451 NETIF_MSG_RX_STATUS = 0x0800,
3452 NETIF_MSG_PKTDATA = 0x1000,
3453 NETIF_MSG_HW = 0x2000,
3454 NETIF_MSG_WOL = 0x4000,
3455};
3456
3457#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
3458#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
3459#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
3460#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
3461#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
3462#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
3463#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
3464#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
3465#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
3466#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
3467#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
3468#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
3469#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
3470#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
3471#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
3472
3473static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
3474{
3475
3476 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
3477 return default_msg_enable_bits;
3478 if (debug_value == 0)
3479 return 0;
3480
3481 return (1 << debug_value) - 1;
3482}
3483
3484static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
3485{
3486 spin_lock(&txq->_xmit_lock);
3487 txq->xmit_lock_owner = cpu;
3488}
3489
3490static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
3491{
3492 spin_lock_bh(&txq->_xmit_lock);
3493 txq->xmit_lock_owner = smp_processor_id();
3494}
3495
3496static inline bool __netif_tx_trylock(struct netdev_queue *txq)
3497{
3498 bool ok = spin_trylock(&txq->_xmit_lock);
3499 if (likely(ok))
3500 txq->xmit_lock_owner = smp_processor_id();
3501 return ok;
3502}
3503
3504static inline void __netif_tx_unlock(struct netdev_queue *txq)
3505{
3506 txq->xmit_lock_owner = -1;
3507 spin_unlock(&txq->_xmit_lock);
3508}
3509
3510static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
3511{
3512 txq->xmit_lock_owner = -1;
3513 spin_unlock_bh(&txq->_xmit_lock);
3514}
3515
3516static inline void txq_trans_update(struct netdev_queue *txq)
3517{
3518 if (txq->xmit_lock_owner != -1)
3519 txq->trans_start = jiffies;
3520}
3521
3522
3523static inline void netif_trans_update(struct net_device *dev)
3524{
3525 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
3526
3527 if (txq->trans_start != jiffies)
3528 txq->trans_start = jiffies;
3529}
3530
3531
3532
3533
3534
3535
3536
3537static inline void netif_tx_lock(struct net_device *dev)
3538{
3539 unsigned int i;
3540 int cpu;
3541
3542 spin_lock(&dev->tx_global_lock);
3543 cpu = smp_processor_id();
3544 for (i = 0; i < dev->num_tx_queues; i++) {
3545 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
3546
3547
3548
3549
3550
3551
3552
3553 __netif_tx_lock(txq, cpu);
3554 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
3555 __netif_tx_unlock(txq);
3556 }
3557}
3558
3559static inline void netif_tx_lock_bh(struct net_device *dev)
3560{
3561 local_bh_disable();
3562 netif_tx_lock(dev);
3563}
3564
3565static inline void netif_tx_unlock(struct net_device *dev)
3566{
3567 unsigned int i;
3568
3569 for (i = 0; i < dev->num_tx_queues; i++) {
3570 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
3571
3572
3573
3574
3575
3576 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
3577 netif_schedule_queue(txq);
3578 }
3579 spin_unlock(&dev->tx_global_lock);
3580}
3581
3582static inline void netif_tx_unlock_bh(struct net_device *dev)
3583{
3584 netif_tx_unlock(dev);
3585 local_bh_enable();
3586}
3587
3588#define HARD_TX_LOCK(dev, txq, cpu) { \
3589 if ((dev->features & NETIF_F_LLTX) == 0) { \
3590 __netif_tx_lock(txq, cpu); \
3591 } \
3592}
3593
3594#define HARD_TX_TRYLOCK(dev, txq) \
3595 (((dev->features & NETIF_F_LLTX) == 0) ? \
3596 __netif_tx_trylock(txq) : \
3597 true )
3598
3599#define HARD_TX_UNLOCK(dev, txq) { \
3600 if ((dev->features & NETIF_F_LLTX) == 0) { \
3601 __netif_tx_unlock(txq); \
3602 } \
3603}
3604
3605static inline void netif_tx_disable(struct net_device *dev)
3606{
3607 unsigned int i;
3608 int cpu;
3609
3610 local_bh_disable();
3611 cpu = smp_processor_id();
3612 for (i = 0; i < dev->num_tx_queues; i++) {
3613 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
3614
3615 __netif_tx_lock(txq, cpu);
3616 netif_tx_stop_queue(txq);
3617 __netif_tx_unlock(txq);
3618 }
3619 local_bh_enable();
3620}
3621
3622static inline void netif_addr_lock(struct net_device *dev)
3623{
3624 spin_lock(&dev->addr_list_lock);
3625}
3626
3627static inline void netif_addr_lock_nested(struct net_device *dev)
3628{
3629 int subclass = SINGLE_DEPTH_NESTING;
3630
3631 if (dev->netdev_ops->ndo_get_lock_subclass)
3632 subclass = dev->netdev_ops->ndo_get_lock_subclass(dev);
3633
3634 spin_lock_nested(&dev->addr_list_lock, subclass);
3635}
3636
3637static inline void netif_addr_lock_bh(struct net_device *dev)
3638{
3639 spin_lock_bh(&dev->addr_list_lock);
3640}
3641
3642static inline void netif_addr_unlock(struct net_device *dev)
3643{
3644 spin_unlock(&dev->addr_list_lock);
3645}
3646
3647static inline void netif_addr_unlock_bh(struct net_device *dev)
3648{
3649 spin_unlock_bh(&dev->addr_list_lock);
3650}
3651
3652
3653
3654
3655
3656#define for_each_dev_addr(dev, ha) \
3657 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
3658
3659
3660
3661void ether_setup(struct net_device *dev);
3662
3663
3664struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
3665 unsigned char name_assign_type,
3666 void (*setup)(struct net_device *),
3667 unsigned int txqs, unsigned int rxqs);
3668#define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
3669 alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)
3670
3671#define alloc_netdev_mq(sizeof_priv, name, name_assign_type, setup, count) \
3672 alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, count, \
3673 count)
3674
3675int register_netdev(struct net_device *dev);
3676void unregister_netdev(struct net_device *dev);
3677
3678
3679int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
3680 struct netdev_hw_addr_list *from_list, int addr_len);
3681void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
3682 struct netdev_hw_addr_list *from_list, int addr_len);
3683int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
3684 struct net_device *dev,
3685 int (*sync)(struct net_device *, const unsigned char *),
3686 int (*unsync)(struct net_device *,
3687 const unsigned char *));
3688void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
3689 struct net_device *dev,
3690 int (*unsync)(struct net_device *,
3691 const unsigned char *));
3692void __hw_addr_init(struct netdev_hw_addr_list *list);
3693
3694
3695int dev_addr_add(struct net_device *dev, const unsigned char *addr,
3696 unsigned char addr_type);
3697int dev_addr_del(struct net_device *dev, const unsigned char *addr,
3698 unsigned char addr_type);
3699void dev_addr_flush(struct net_device *dev);
3700int dev_addr_init(struct net_device *dev);
3701
3702
3703int dev_uc_add(struct net_device *dev, const unsigned char *addr);
3704int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
3705int dev_uc_del(struct net_device *dev, const unsigned char *addr);
3706int dev_uc_sync(struct net_device *to, struct net_device *from);
3707int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
3708void dev_uc_unsync(struct net_device *to, struct net_device *from);
3709void dev_uc_flush(struct net_device *dev);
3710void dev_uc_init(struct net_device *dev);
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721static inline int __dev_uc_sync(struct net_device *dev,
3722 int (*sync)(struct net_device *,
3723 const unsigned char *),
3724 int (*unsync)(struct net_device *,
3725 const unsigned char *))
3726{
3727 return __hw_addr_sync_dev(&dev->uc, dev, sync, unsync);
3728}
3729
3730
3731
3732
3733
3734
3735
3736
3737static inline void __dev_uc_unsync(struct net_device *dev,
3738 int (*unsync)(struct net_device *,
3739 const unsigned char *))
3740{
3741 __hw_addr_unsync_dev(&dev->uc, dev, unsync);
3742}
3743
3744
3745int dev_mc_add(struct net_device *dev, const unsigned char *addr);
3746int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
3747int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
3748int dev_mc_del(struct net_device *dev, const unsigned char *addr);
3749int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
3750int dev_mc_sync(struct net_device *to, struct net_device *from);
3751int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
3752void dev_mc_unsync(struct net_device *to, struct net_device *from);
3753void dev_mc_flush(struct net_device *dev);
3754void dev_mc_init(struct net_device *dev);
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765static inline int __dev_mc_sync(struct net_device *dev,
3766 int (*sync)(struct net_device *,
3767 const unsigned char *),
3768 int (*unsync)(struct net_device *,
3769 const unsigned char *))
3770{
3771 return __hw_addr_sync_dev(&dev->mc, dev, sync, unsync);
3772}
3773
3774
3775
3776
3777
3778
3779
3780
3781static inline void __dev_mc_unsync(struct net_device *dev,
3782 int (*unsync)(struct net_device *,
3783 const unsigned char *))
3784{
3785 __hw_addr_unsync_dev(&dev->mc, dev, unsync);
3786}
3787
3788
3789void dev_set_rx_mode(struct net_device *dev);
3790void __dev_set_rx_mode(struct net_device *dev);
3791int dev_set_promiscuity(struct net_device *dev, int inc);
3792int dev_set_allmulti(struct net_device *dev, int inc);
3793void netdev_state_change(struct net_device *dev);
3794void netdev_notify_peers(struct net_device *dev);
3795void netdev_features_change(struct net_device *dev);
3796
3797void dev_load(struct net *net, const char *name);
3798struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
3799 struct rtnl_link_stats64 *storage);
3800void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
3801 const struct net_device_stats *netdev_stats);
3802
3803extern int netdev_max_backlog;
3804extern int netdev_tstamp_prequeue;
3805extern int weight_p;
3806
3807bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev);
3808struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
3809 struct list_head **iter);
3810struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev,
3811 struct list_head **iter);
3812
3813
3814#define netdev_for_each_upper_dev_rcu(dev, updev, iter) \
3815 for (iter = &(dev)->adj_list.upper, \
3816 updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \
3817 updev; \
3818 updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))
3819
3820
3821#define netdev_for_each_all_upper_dev_rcu(dev, updev, iter) \
3822 for (iter = &(dev)->all_adj_list.upper, \
3823 updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)); \
3824 updev; \
3825 updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)))
3826
3827void *netdev_lower_get_next_private(struct net_device *dev,
3828 struct list_head **iter);
3829void *netdev_lower_get_next_private_rcu(struct net_device *dev,
3830 struct list_head **iter);
3831
3832#define netdev_for_each_lower_private(dev, priv, iter) \
3833 for (iter = (dev)->adj_list.lower.next, \
3834 priv = netdev_lower_get_next_private(dev, &(iter)); \
3835 priv; \
3836 priv = netdev_lower_get_next_private(dev, &(iter)))
3837
3838#define netdev_for_each_lower_private_rcu(dev, priv, iter) \
3839 for (iter = &(dev)->adj_list.lower, \
3840 priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \
3841 priv; \
3842 priv = netdev_lower_get_next_private_rcu(dev, &(iter)))
3843
3844void *netdev_lower_get_next(struct net_device *dev,
3845 struct list_head **iter);
3846
3847#define netdev_for_each_lower_dev(dev, ldev, iter) \
3848 for (iter = (dev)->adj_list.lower.next, \
3849 ldev = netdev_lower_get_next(dev, &(iter)); \
3850 ldev; \
3851 ldev = netdev_lower_get_next(dev, &(iter)))
3852
3853struct net_device *netdev_all_lower_get_next(struct net_device *dev,
3854 struct list_head **iter);
3855struct net_device *netdev_all_lower_get_next_rcu(struct net_device *dev,
3856 struct list_head **iter);
3857
3858#define netdev_for_each_all_lower_dev(dev, ldev, iter) \
3859 for (iter = (dev)->all_adj_list.lower.next, \
3860 ldev = netdev_all_lower_get_next(dev, &(iter)); \
3861 ldev; \
3862 ldev = netdev_all_lower_get_next(dev, &(iter)))
3863
3864#define netdev_for_each_all_lower_dev_rcu(dev, ldev, iter) \
3865 for (iter = (dev)->all_adj_list.lower.next, \
3866 ldev = netdev_all_lower_get_next_rcu(dev, &(iter)); \
3867 ldev; \
3868 ldev = netdev_all_lower_get_next_rcu(dev, &(iter)))
3869
3870void *netdev_adjacent_get_private(struct list_head *adj_list);
3871void *netdev_lower_get_first_private_rcu(struct net_device *dev);
3872struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
3873struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
3874int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev);
3875int netdev_master_upper_dev_link(struct net_device *dev,
3876 struct net_device *upper_dev,
3877 void *upper_priv, void *upper_info);
3878void netdev_upper_dev_unlink(struct net_device *dev,
3879 struct net_device *upper_dev);
3880void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
3881void *netdev_lower_dev_get_private(struct net_device *dev,
3882 struct net_device *lower_dev);
3883void netdev_lower_state_changed(struct net_device *lower_dev,
3884 void *lower_state_info);
3885int netdev_default_l2upper_neigh_construct(struct net_device *dev,
3886 struct neighbour *n);
3887void netdev_default_l2upper_neigh_destroy(struct net_device *dev,
3888 struct neighbour *n);
3889
3890
3891#define NETDEV_RSS_KEY_LEN 52
3892extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
3893void netdev_rss_key_fill(void *buffer, size_t len);
3894
3895int dev_get_nest_level(struct net_device *dev);
3896int skb_checksum_help(struct sk_buff *skb);
3897struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
3898 netdev_features_t features, bool tx_path);
3899struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
3900 netdev_features_t features);
3901
3902struct netdev_bonding_info {
3903 ifslave slave;
3904 ifbond master;
3905};
3906
3907struct netdev_notifier_bonding_info {
3908 struct netdev_notifier_info info;
3909 struct netdev_bonding_info bonding_info;
3910};
3911
3912void netdev_bonding_info_change(struct net_device *dev,
3913 struct netdev_bonding_info *bonding_info);
3914
3915static inline
3916struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
3917{
3918 return __skb_gso_segment(skb, features, true);
3919}
3920__be16 skb_network_protocol(struct sk_buff *skb, int *depth);
3921
3922static inline bool can_checksum_protocol(netdev_features_t features,
3923 __be16 protocol)
3924{
3925 if (protocol == htons(ETH_P_FCOE))
3926 return !!(features & NETIF_F_FCOE_CRC);
3927
3928
3929
3930 if (features & NETIF_F_HW_CSUM) {
3931
3932 return true;
3933 }
3934
3935 switch (protocol) {
3936 case htons(ETH_P_IP):
3937 return !!(features & NETIF_F_IP_CSUM);
3938 case htons(ETH_P_IPV6):
3939 return !!(features & NETIF_F_IPV6_CSUM);
3940 default:
3941 return false;
3942 }
3943}
3944
3945
3946static inline int eproto_to_ipproto(int eproto)
3947{
3948 switch (eproto) {
3949 case htons(ETH_P_IP):
3950 return IPPROTO_IP;
3951 case htons(ETH_P_IPV6):
3952 return IPPROTO_IPV6;
3953 default:
3954 return -1;
3955 }
3956}
3957
3958#ifdef CONFIG_BUG
3959void netdev_rx_csum_fault(struct net_device *dev);
3960#else
3961static inline void netdev_rx_csum_fault(struct net_device *dev)
3962{
3963}
3964#endif
3965
3966void net_enable_timestamp(void);
3967void net_disable_timestamp(void);
3968
3969#ifdef CONFIG_PROC_FS
3970int __init dev_proc_init(void);
3971#else
3972#define dev_proc_init() 0
3973#endif
3974
3975static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
3976 struct sk_buff *skb, struct net_device *dev,
3977 bool more)
3978{
3979 skb->xmit_more = more ? 1 : 0;
3980 return ops->ndo_start_xmit(skb, dev);
3981}
3982
3983static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
3984 struct netdev_queue *txq, bool more)
3985{
3986 const struct net_device_ops *ops = dev->netdev_ops;
3987 int rc;
3988
3989 rc = __netdev_start_xmit(ops, skb, dev, more);
3990 if (rc == NETDEV_TX_OK)
3991 txq_trans_update(txq);
3992
3993 return rc;
3994}
3995
3996int netdev_class_create_file_ns(struct class_attribute *class_attr,
3997 const void *ns);
3998void netdev_class_remove_file_ns(struct class_attribute *class_attr,
3999 const void *ns);
4000
4001static inline int netdev_class_create_file(struct class_attribute *class_attr)
4002{
4003 return netdev_class_create_file_ns(class_attr, NULL);
4004}
4005
4006static inline void netdev_class_remove_file(struct class_attribute *class_attr)
4007{
4008 netdev_class_remove_file_ns(class_attr, NULL);
4009}
4010
4011extern struct kobj_ns_type_operations net_ns_type_operations;
4012
4013const char *netdev_drivername(const struct net_device *dev);
4014
4015void linkwatch_run_queue(void);
4016
4017static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
4018 netdev_features_t f2)
4019{
4020 if ((f1 ^ f2) & NETIF_F_HW_CSUM) {
4021 if (f1 & NETIF_F_HW_CSUM)
4022 f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4023 else
4024 f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4025 }
4026
4027 return f1 & f2;
4028}
4029
4030static inline netdev_features_t netdev_get_wanted_features(
4031 struct net_device *dev)
4032{
4033 return (dev->features & ~dev->hw_features) | dev->wanted_features;
4034}
4035netdev_features_t netdev_increment_features(netdev_features_t all,
4036 netdev_features_t one, netdev_features_t mask);
4037
4038
4039
4040
4041
4042static inline netdev_features_t netdev_add_tso_features(netdev_features_t features,
4043 netdev_features_t mask)
4044{
4045 return netdev_increment_features(features, NETIF_F_ALL_TSO, mask);
4046}
4047
4048int __netdev_update_features(struct net_device *dev);
4049void netdev_update_features(struct net_device *dev);
4050void netdev_change_features(struct net_device *dev);
4051
4052void netif_stacked_transfer_operstate(const struct net_device *rootdev,
4053 struct net_device *dev);
4054
4055netdev_features_t passthru_features_check(struct sk_buff *skb,
4056 struct net_device *dev,
4057 netdev_features_t features);
4058netdev_features_t netif_skb_features(struct sk_buff *skb);
4059
4060static inline bool net_gso_ok(netdev_features_t features, int gso_type)
4061{
4062 netdev_features_t feature = (netdev_features_t)gso_type << NETIF_F_GSO_SHIFT;
4063
4064
4065 BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
4066 BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_UFO >> NETIF_F_GSO_SHIFT));
4067 BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
4068 BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
4069 BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO_SHIFT));
4070 BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
4071 BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
4072 BUILD_BUG_ON(SKB_GSO_GRE != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
4073 BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO_SHIFT));
4074 BUILD_BUG_ON(SKB_GSO_IPXIP4 != (NETIF_F_GSO_IPXIP4 >> NETIF_F_GSO_SHIFT));
4075 BUILD_BUG_ON(SKB_GSO_IPXIP6 != (NETIF_F_GSO_IPXIP6 >> NETIF_F_GSO_SHIFT));
4076 BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
4077 BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT));
4078 BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO_SHIFT));
4079 BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT));
4080 BUILD_BUG_ON(SKB_GSO_SCTP != (NETIF_F_GSO_SCTP >> NETIF_F_GSO_SHIFT));
4081
4082 return (features & feature) == feature;
4083}
4084
4085static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
4086{
4087 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
4088 (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
4089}
4090
4091static inline bool netif_needs_gso(struct sk_buff *skb,
4092 netdev_features_t features)
4093{
4094 return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
4095 unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
4096 (skb->ip_summed != CHECKSUM_UNNECESSARY)));
4097}
4098
4099static inline void netif_set_gso_max_size(struct net_device *dev,
4100 unsigned int size)
4101{
4102 dev->gso_max_size = size;
4103}
4104
4105static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol,
4106 int pulled_hlen, u16 mac_offset,
4107 int mac_len)
4108{
4109 skb->protocol = protocol;
4110 skb->encapsulation = 1;
4111 skb_push(skb, pulled_hlen);
4112 skb_reset_transport_header(skb);
4113 skb->mac_header = mac_offset;
4114 skb->network_header = skb->mac_header + mac_len;
4115 skb->mac_len = mac_len;
4116}
4117
4118static inline bool netif_is_macsec(const struct net_device *dev)
4119{
4120 return dev->priv_flags & IFF_MACSEC;
4121}
4122
4123static inline bool netif_is_macvlan(const struct net_device *dev)
4124{
4125 return dev->priv_flags & IFF_MACVLAN;
4126}
4127
4128static inline bool netif_is_macvlan_port(const struct net_device *dev)
4129{
4130 return dev->priv_flags & IFF_MACVLAN_PORT;
4131}
4132
4133static inline bool netif_is_ipvlan(const struct net_device *dev)
4134{
4135 return dev->priv_flags & IFF_IPVLAN_SLAVE;
4136}
4137
4138static inline bool netif_is_ipvlan_port(const struct net_device *dev)
4139{
4140 return dev->priv_flags & IFF_IPVLAN_MASTER;
4141}
4142
4143static inline bool netif_is_bond_master(const struct net_device *dev)
4144{
4145 return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
4146}
4147
4148static inline bool netif_is_bond_slave(const struct net_device *dev)
4149{
4150 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
4151}
4152
4153static inline bool netif_supports_nofcs(struct net_device *dev)
4154{
4155 return dev->priv_flags & IFF_SUPP_NOFCS;
4156}
4157
4158static inline bool netif_is_l3_master(const struct net_device *dev)
4159{
4160 return dev->priv_flags & IFF_L3MDEV_MASTER;
4161}
4162
4163static inline bool netif_is_l3_slave(const struct net_device *dev)
4164{
4165 return dev->priv_flags & IFF_L3MDEV_SLAVE;
4166}
4167
4168static inline bool netif_is_bridge_master(const struct net_device *dev)
4169{
4170 return dev->priv_flags & IFF_EBRIDGE;
4171}
4172
4173static inline bool netif_is_bridge_port(const struct net_device *dev)
4174{
4175 return dev->priv_flags & IFF_BRIDGE_PORT;
4176}
4177
4178static inline bool netif_is_ovs_master(const struct net_device *dev)
4179{
4180 return dev->priv_flags & IFF_OPENVSWITCH;
4181}
4182
4183static inline bool netif_is_team_master(const struct net_device *dev)
4184{
4185 return dev->priv_flags & IFF_TEAM;
4186}
4187
4188static inline bool netif_is_team_port(const struct net_device *dev)
4189{
4190 return dev->priv_flags & IFF_TEAM_PORT;
4191}
4192
4193static inline bool netif_is_lag_master(const struct net_device *dev)
4194{
4195 return netif_is_bond_master(dev) || netif_is_team_master(dev);
4196}
4197
4198static inline bool netif_is_lag_port(const struct net_device *dev)
4199{
4200 return netif_is_bond_slave(dev) || netif_is_team_port(dev);
4201}
4202
4203static inline bool netif_is_rxfh_configured(const struct net_device *dev)
4204{
4205 return dev->priv_flags & IFF_RXFH_CONFIGURED;
4206}
4207
4208
4209static inline void netif_keep_dst(struct net_device *dev)
4210{
4211 dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
4212}
4213
4214
4215static inline bool netif_reduces_vlan_mtu(struct net_device *dev)
4216{
4217
4218 return dev->priv_flags & IFF_MACSEC;
4219}
4220
4221extern struct pernet_operations __net_initdata loopback_net_ops;
4222
4223
4224
4225
4226
4227static inline const char *netdev_name(const struct net_device *dev)
4228{
4229 if (!dev->name[0] || strchr(dev->name, '%'))
4230 return "(unnamed net_device)";
4231 return dev->name;
4232}
4233
4234static inline const char *netdev_reg_state(const struct net_device *dev)
4235{
4236 switch (dev->reg_state) {
4237 case NETREG_UNINITIALIZED: return " (uninitialized)";
4238 case NETREG_REGISTERED: return "";
4239 case NETREG_UNREGISTERING: return " (unregistering)";
4240 case NETREG_UNREGISTERED: return " (unregistered)";
4241 case NETREG_RELEASED: return " (released)";
4242 case NETREG_DUMMY: return " (dummy)";
4243 }
4244
4245 WARN_ONCE(1, "%s: unknown reg_state %d\n", dev->name, dev->reg_state);
4246 return " (unknown)";
4247}
4248
4249__printf(3, 4)
4250void netdev_printk(const char *level, const struct net_device *dev,
4251 const char *format, ...);
4252__printf(2, 3)
4253void netdev_emerg(const struct net_device *dev, const char *format, ...);
4254__printf(2, 3)
4255void netdev_alert(const struct net_device *dev, const char *format, ...);
4256__printf(2, 3)
4257void netdev_crit(const struct net_device *dev, const char *format, ...);
4258__printf(2, 3)
4259void netdev_err(const struct net_device *dev, const char *format, ...);
4260__printf(2, 3)
4261void netdev_warn(const struct net_device *dev, const char *format, ...);
4262__printf(2, 3)
4263void netdev_notice(const struct net_device *dev, const char *format, ...);
4264__printf(2, 3)
4265void netdev_info(const struct net_device *dev, const char *format, ...);
4266
4267#define MODULE_ALIAS_NETDEV(device) \
4268 MODULE_ALIAS("netdev-" device)
4269
4270#if defined(CONFIG_DYNAMIC_DEBUG)
4271#define netdev_dbg(__dev, format, args...) \
4272do { \
4273 dynamic_netdev_dbg(__dev, format, ##args); \
4274} while (0)
4275#elif defined(DEBUG)
4276#define netdev_dbg(__dev, format, args...) \
4277 netdev_printk(KERN_DEBUG, __dev, format, ##args)
4278#else
4279#define netdev_dbg(__dev, format, args...) \
4280({ \
4281 if (0) \
4282 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
4283})
4284#endif
4285
4286#if defined(VERBOSE_DEBUG)
4287#define netdev_vdbg netdev_dbg
4288#else
4289
4290#define netdev_vdbg(dev, format, args...) \
4291({ \
4292 if (0) \
4293 netdev_printk(KERN_DEBUG, dev, format, ##args); \
4294 0; \
4295})
4296#endif
4297
4298
4299
4300
4301
4302
4303#define netdev_WARN(dev, format, args...) \
4304 WARN(1, "netdevice: %s%s\n" format, netdev_name(dev), \
4305 netdev_reg_state(dev), ##args)
4306
4307
4308
4309#define netif_printk(priv, type, level, dev, fmt, args...) \
4310do { \
4311 if (netif_msg_##type(priv)) \
4312 netdev_printk(level, (dev), fmt, ##args); \
4313} while (0)
4314
4315#define netif_level(level, priv, type, dev, fmt, args...) \
4316do { \
4317 if (netif_msg_##type(priv)) \
4318 netdev_##level(dev, fmt, ##args); \
4319} while (0)
4320
4321#define netif_emerg(priv, type, dev, fmt, args...) \
4322 netif_level(emerg, priv, type, dev, fmt, ##args)
4323#define netif_alert(priv, type, dev, fmt, args...) \
4324 netif_level(alert, priv, type, dev, fmt, ##args)
4325#define netif_crit(priv, type, dev, fmt, args...) \
4326 netif_level(crit, priv, type, dev, fmt, ##args)
4327#define netif_err(priv, type, dev, fmt, args...) \
4328 netif_level(err, priv, type, dev, fmt, ##args)
4329#define netif_warn(priv, type, dev, fmt, args...) \
4330 netif_level(warn, priv, type, dev, fmt, ##args)
4331#define netif_notice(priv, type, dev, fmt, args...) \
4332 netif_level(notice, priv, type, dev, fmt, ##args)
4333#define netif_info(priv, type, dev, fmt, args...) \
4334 netif_level(info, priv, type, dev, fmt, ##args)
4335
4336#if defined(CONFIG_DYNAMIC_DEBUG)
4337#define netif_dbg(priv, type, netdev, format, args...) \
4338do { \
4339 if (netif_msg_##type(priv)) \
4340 dynamic_netdev_dbg(netdev, format, ##args); \
4341} while (0)
4342#elif defined(DEBUG)
4343#define netif_dbg(priv, type, dev, format, args...) \
4344 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
4345#else
4346#define netif_dbg(priv, type, dev, format, args...) \
4347({ \
4348 if (0) \
4349 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
4350 0; \
4351})
4352#endif
4353
4354#if defined(VERBOSE_DEBUG)
4355#define netif_vdbg netif_dbg
4356#else
4357#define netif_vdbg(priv, type, dev, format, args...) \
4358({ \
4359 if (0) \
4360 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
4361 0; \
4362})
4363#endif
4364
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375
4376
4377
4378
4379
4380
4381
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392#define PTYPE_HASH_SIZE (16)
4393#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
4394
4395#endif
4396