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