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