1
2
3
4
5
6
7#ifndef _LINUX_IF_VLAN_H_
8#define _LINUX_IF_VLAN_H_
9
10#include <linux/netdevice.h>
11#include <linux/etherdevice.h>
12#include <linux/rtnetlink.h>
13#include <linux/bug.h>
14#include <uapi/linux/if_vlan.h>
15
16#define VLAN_HLEN 4
17
18
19#define VLAN_ETH_HLEN 18
20#define VLAN_ETH_ZLEN 64
21
22
23
24
25#define VLAN_ETH_DATA_LEN 1500
26#define VLAN_ETH_FRAME_LEN 1518
27
28
29
30
31
32
33struct vlan_hdr {
34 __be16 h_vlan_TCI;
35 __be16 h_vlan_encapsulated_proto;
36};
37
38
39
40
41
42
43
44
45
46struct vlan_ethhdr {
47 unsigned char h_dest[ETH_ALEN];
48 unsigned char h_source[ETH_ALEN];
49 __be16 h_vlan_proto;
50 __be16 h_vlan_TCI;
51 __be16 h_vlan_encapsulated_proto;
52};
53
54#include <linux/skbuff.h>
55
56static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
57{
58 return (struct vlan_ethhdr *)skb_mac_header(skb);
59}
60
61#define VLAN_PRIO_MASK 0xe000
62#define VLAN_PRIO_SHIFT 13
63#define VLAN_CFI_MASK 0x1000
64#define VLAN_VID_MASK 0x0fff
65#define VLAN_N_VID 4096
66
67
68extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *));
69
70static inline bool is_vlan_dev(const struct net_device *dev)
71{
72 return dev->priv_flags & IFF_802_1Q_VLAN;
73}
74
75#define skb_vlan_tag_present(__skb) ((__skb)->vlan_present)
76#define skb_vlan_tag_get(__skb) ((__skb)->vlan_tci)
77#define skb_vlan_tag_get_id(__skb) ((__skb)->vlan_tci & VLAN_VID_MASK)
78#define skb_vlan_tag_get_cfi(__skb) (!!((__skb)->vlan_tci & VLAN_CFI_MASK))
79#define skb_vlan_tag_get_prio(__skb) (((__skb)->vlan_tci & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT)
80
81static inline int vlan_get_rx_ctag_filter_info(struct net_device *dev)
82{
83 ASSERT_RTNL();
84 return notifier_to_errno(call_netdevice_notifiers(NETDEV_CVLAN_FILTER_PUSH_INFO, dev));
85}
86
87static inline void vlan_drop_rx_ctag_filter_info(struct net_device *dev)
88{
89 ASSERT_RTNL();
90 call_netdevice_notifiers(NETDEV_CVLAN_FILTER_DROP_INFO, dev);
91}
92
93static inline int vlan_get_rx_stag_filter_info(struct net_device *dev)
94{
95 ASSERT_RTNL();
96 return notifier_to_errno(call_netdevice_notifiers(NETDEV_SVLAN_FILTER_PUSH_INFO, dev));
97}
98
99static inline void vlan_drop_rx_stag_filter_info(struct net_device *dev)
100{
101 ASSERT_RTNL();
102 call_netdevice_notifiers(NETDEV_SVLAN_FILTER_DROP_INFO, dev);
103}
104
105
106
107
108
109
110
111
112
113
114
115
116struct vlan_pcpu_stats {
117 u64 rx_packets;
118 u64 rx_bytes;
119 u64 rx_multicast;
120 u64 tx_packets;
121 u64 tx_bytes;
122 struct u64_stats_sync syncp;
123 u32 rx_errors;
124 u32 tx_dropped;
125};
126
127#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
128
129extern struct net_device *__vlan_find_dev_deep_rcu(struct net_device *real_dev,
130 __be16 vlan_proto, u16 vlan_id);
131extern int vlan_for_each(struct net_device *dev,
132 int (*action)(struct net_device *dev, int vid,
133 void *arg), void *arg);
134extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
135extern u16 vlan_dev_vlan_id(const struct net_device *dev);
136extern __be16 vlan_dev_vlan_proto(const struct net_device *dev);
137
138
139
140
141
142
143
144struct vlan_priority_tci_mapping {
145 u32 priority;
146 u16 vlan_qos;
147 struct vlan_priority_tci_mapping *next;
148};
149
150struct proc_dir_entry;
151struct netpoll;
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167struct vlan_dev_priv {
168 unsigned int nr_ingress_mappings;
169 u32 ingress_priority_map[8];
170 unsigned int nr_egress_mappings;
171 struct vlan_priority_tci_mapping *egress_priority_map[16];
172
173 __be16 vlan_proto;
174 u16 vlan_id;
175 u16 flags;
176
177 struct net_device *real_dev;
178 unsigned char real_dev_addr[ETH_ALEN];
179
180 struct proc_dir_entry *dent;
181 struct vlan_pcpu_stats __percpu *vlan_pcpu_stats;
182#ifdef CONFIG_NET_POLL_CONTROLLER
183 struct netpoll *netpoll;
184#endif
185 unsigned int nest_level;
186};
187
188static inline struct vlan_dev_priv *vlan_dev_priv(const struct net_device *dev)
189{
190 return netdev_priv(dev);
191}
192
193static inline u16
194vlan_dev_get_egress_qos_mask(struct net_device *dev, u32 skprio)
195{
196 struct vlan_priority_tci_mapping *mp;
197
198 smp_rmb();
199
200 mp = vlan_dev_priv(dev)->egress_priority_map[(skprio & 0xF)];
201 while (mp) {
202 if (mp->priority == skprio) {
203 return mp->vlan_qos;
204
205
206 }
207 mp = mp->next;
208 }
209 return 0;
210}
211
212extern bool vlan_do_receive(struct sk_buff **skb);
213
214extern int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid);
215extern void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid);
216
217extern int vlan_vids_add_by_dev(struct net_device *dev,
218 const struct net_device *by_dev);
219extern void vlan_vids_del_by_dev(struct net_device *dev,
220 const struct net_device *by_dev);
221
222extern bool vlan_uses_dev(const struct net_device *dev);
223
224static inline int vlan_get_encap_level(struct net_device *dev)
225{
226 BUG_ON(!is_vlan_dev(dev));
227 return vlan_dev_priv(dev)->nest_level;
228}
229#else
230static inline struct net_device *
231__vlan_find_dev_deep_rcu(struct net_device *real_dev,
232 __be16 vlan_proto, u16 vlan_id)
233{
234 return NULL;
235}
236
237static inline int
238vlan_for_each(struct net_device *dev,
239 int (*action)(struct net_device *dev, int vid, void *arg),
240 void *arg)
241{
242 return 0;
243}
244
245static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev)
246{
247 BUG();
248 return NULL;
249}
250
251static inline u16 vlan_dev_vlan_id(const struct net_device *dev)
252{
253 BUG();
254 return 0;
255}
256
257static inline __be16 vlan_dev_vlan_proto(const struct net_device *dev)
258{
259 BUG();
260 return 0;
261}
262
263static inline u16 vlan_dev_get_egress_qos_mask(struct net_device *dev,
264 u32 skprio)
265{
266 return 0;
267}
268
269static inline bool vlan_do_receive(struct sk_buff **skb)
270{
271 return false;
272}
273
274static inline int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid)
275{
276 return 0;
277}
278
279static inline void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid)
280{
281}
282
283static inline int vlan_vids_add_by_dev(struct net_device *dev,
284 const struct net_device *by_dev)
285{
286 return 0;
287}
288
289static inline void vlan_vids_del_by_dev(struct net_device *dev,
290 const struct net_device *by_dev)
291{
292}
293
294static inline bool vlan_uses_dev(const struct net_device *dev)
295{
296 return false;
297}
298static inline int vlan_get_encap_level(struct net_device *dev)
299{
300 BUG();
301 return 0;
302}
303#endif
304
305
306
307
308
309
310
311static inline bool eth_type_vlan(__be16 ethertype)
312{
313 switch (ethertype) {
314 case htons(ETH_P_8021Q):
315 case htons(ETH_P_8021AD):
316 return true;
317 default:
318 return false;
319 }
320}
321
322static inline bool vlan_hw_offload_capable(netdev_features_t features,
323 __be16 proto)
324{
325 if (proto == htons(ETH_P_8021Q) && features & NETIF_F_HW_VLAN_CTAG_TX)
326 return true;
327 if (proto == htons(ETH_P_8021AD) && features & NETIF_F_HW_VLAN_STAG_TX)
328 return true;
329 return false;
330}
331
332
333
334
335
336
337
338
339
340
341
342
343
344static inline int __vlan_insert_inner_tag(struct sk_buff *skb,
345 __be16 vlan_proto, u16 vlan_tci,
346 unsigned int mac_len)
347{
348 struct vlan_ethhdr *veth;
349
350 if (skb_cow_head(skb, VLAN_HLEN) < 0)
351 return -ENOMEM;
352
353 skb_push(skb, VLAN_HLEN);
354
355
356 if (likely(mac_len > ETH_TLEN))
357 memmove(skb->data, skb->data + VLAN_HLEN, mac_len - ETH_TLEN);
358 skb->mac_header -= VLAN_HLEN;
359
360 veth = (struct vlan_ethhdr *)(skb->data + mac_len - ETH_HLEN);
361
362
363 if (likely(mac_len >= ETH_TLEN)) {
364
365
366
367 veth->h_vlan_proto = vlan_proto;
368 } else {
369
370
371
372 veth->h_vlan_encapsulated_proto = skb->protocol;
373 }
374
375
376 veth->h_vlan_TCI = htons(vlan_tci);
377
378 return 0;
379}
380
381
382
383
384
385
386
387
388
389
390
391
392static inline int __vlan_insert_tag(struct sk_buff *skb,
393 __be16 vlan_proto, u16 vlan_tci)
394{
395 return __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, ETH_HLEN);
396}
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413static inline struct sk_buff *vlan_insert_inner_tag(struct sk_buff *skb,
414 __be16 vlan_proto,
415 u16 vlan_tci,
416 unsigned int mac_len)
417{
418 int err;
419
420 err = __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, mac_len);
421 if (err) {
422 dev_kfree_skb_any(skb);
423 return NULL;
424 }
425 return skb;
426}
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
443 __be16 vlan_proto, u16 vlan_tci)
444{
445 return vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, ETH_HLEN);
446}
447
448
449
450
451
452
453
454
455
456
457
458
459
460static inline struct sk_buff *vlan_insert_tag_set_proto(struct sk_buff *skb,
461 __be16 vlan_proto,
462 u16 vlan_tci)
463{
464 skb = vlan_insert_tag(skb, vlan_proto, vlan_tci);
465 if (skb)
466 skb->protocol = vlan_proto;
467 return skb;
468}
469
470
471
472
473
474
475
476static inline void __vlan_hwaccel_clear_tag(struct sk_buff *skb)
477{
478 skb->vlan_present = 0;
479}
480
481
482
483
484
485
486
487
488static inline void __vlan_hwaccel_copy_tag(struct sk_buff *dst, const struct sk_buff *src)
489{
490 dst->vlan_present = src->vlan_present;
491 dst->vlan_proto = src->vlan_proto;
492 dst->vlan_tci = src->vlan_tci;
493}
494
495
496
497
498
499
500
501
502
503
504static inline struct sk_buff *__vlan_hwaccel_push_inside(struct sk_buff *skb)
505{
506 skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto,
507 skb_vlan_tag_get(skb));
508 if (likely(skb))
509 __vlan_hwaccel_clear_tag(skb);
510 return skb;
511}
512
513
514
515
516
517
518
519
520
521static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb,
522 __be16 vlan_proto, u16 vlan_tci)
523{
524 skb->vlan_proto = vlan_proto;
525 skb->vlan_tci = vlan_tci;
526 skb->vlan_present = 1;
527}
528
529
530
531
532
533
534
535
536static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
537{
538 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
539
540 if (!eth_type_vlan(veth->h_vlan_proto))
541 return -EINVAL;
542
543 *vlan_tci = ntohs(veth->h_vlan_TCI);
544 return 0;
545}
546
547
548
549
550
551
552
553
554static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
555 u16 *vlan_tci)
556{
557 if (skb_vlan_tag_present(skb)) {
558 *vlan_tci = skb_vlan_tag_get(skb);
559 return 0;
560 } else {
561 *vlan_tci = 0;
562 return -EINVAL;
563 }
564}
565
566
567
568
569
570
571
572
573static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
574{
575 if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) {
576 return __vlan_hwaccel_get_tag(skb, vlan_tci);
577 } else {
578 return __vlan_get_tag(skb, vlan_tci);
579 }
580}
581
582
583
584
585
586
587
588
589
590
591static inline __be16 __vlan_get_protocol(struct sk_buff *skb, __be16 type,
592 int *depth)
593{
594 unsigned int vlan_depth = skb->mac_len;
595
596
597
598
599
600 if (eth_type_vlan(type)) {
601 if (vlan_depth) {
602 if (WARN_ON(vlan_depth < VLAN_HLEN))
603 return 0;
604 vlan_depth -= VLAN_HLEN;
605 } else {
606 vlan_depth = ETH_HLEN;
607 }
608 do {
609 struct vlan_hdr *vh;
610
611 if (unlikely(!pskb_may_pull(skb,
612 vlan_depth + VLAN_HLEN)))
613 return 0;
614
615 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
616 type = vh->h_vlan_encapsulated_proto;
617 vlan_depth += VLAN_HLEN;
618 } while (eth_type_vlan(type));
619 }
620
621 if (depth)
622 *depth = vlan_depth;
623
624 return type;
625}
626
627
628
629
630
631
632
633
634static inline __be16 vlan_get_protocol(struct sk_buff *skb)
635{
636 return __vlan_get_protocol(skb, skb->protocol, NULL);
637}
638
639static inline void vlan_set_encap_proto(struct sk_buff *skb,
640 struct vlan_hdr *vhdr)
641{
642 __be16 proto;
643 unsigned short *rawp;
644
645
646
647
648
649
650 proto = vhdr->h_vlan_encapsulated_proto;
651 if (eth_proto_is_802_3(proto)) {
652 skb->protocol = proto;
653 return;
654 }
655
656 rawp = (unsigned short *)(vhdr + 1);
657 if (*rawp == 0xFFFF)
658
659
660
661
662
663
664
665 skb->protocol = htons(ETH_P_802_3);
666 else
667
668
669
670 skb->protocol = htons(ETH_P_802_2);
671}
672
673
674
675
676
677
678
679
680static inline bool skb_vlan_tagged(const struct sk_buff *skb)
681{
682 if (!skb_vlan_tag_present(skb) &&
683 likely(!eth_type_vlan(skb->protocol)))
684 return false;
685
686 return true;
687}
688
689
690
691
692
693
694
695
696static inline bool skb_vlan_tagged_multi(struct sk_buff *skb)
697{
698 __be16 protocol = skb->protocol;
699
700 if (!skb_vlan_tag_present(skb)) {
701 struct vlan_ethhdr *veh;
702
703 if (likely(!eth_type_vlan(protocol)))
704 return false;
705
706 if (unlikely(!pskb_may_pull(skb, VLAN_ETH_HLEN)))
707 return false;
708
709 veh = (struct vlan_ethhdr *)skb->data;
710 protocol = veh->h_vlan_encapsulated_proto;
711 }
712
713 if (!eth_type_vlan(protocol))
714 return false;
715
716 return true;
717}
718
719
720
721
722
723
724
725
726static inline netdev_features_t vlan_features_check(struct sk_buff *skb,
727 netdev_features_t features)
728{
729 if (skb_vlan_tagged_multi(skb)) {
730
731
732
733
734
735 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_CSUM |
736 NETIF_F_FRAGLIST | NETIF_F_HW_VLAN_CTAG_TX |
737 NETIF_F_HW_VLAN_STAG_TX;
738 }
739
740 return features;
741}
742
743
744
745
746
747
748
749
750
751
752static inline unsigned long compare_vlan_header(const struct vlan_hdr *h1,
753 const struct vlan_hdr *h2)
754{
755#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
756 return *(u32 *)h1 ^ *(u32 *)h2;
757#else
758 return ((__force u32)h1->h_vlan_TCI ^ (__force u32)h2->h_vlan_TCI) |
759 ((__force u32)h1->h_vlan_encapsulated_proto ^
760 (__force u32)h2->h_vlan_encapsulated_proto);
761#endif
762}
763#endif
764