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