]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blame - include/linux/if_vlan.h
Merge tag '5.2-rc6-smb3-fix' of git://git.samba.org/sfrench/cifs-2.6
[mirror_ubuntu-eoan-kernel.git] / include / linux / if_vlan.h
CommitLineData
2874c5fd 1/* SPDX-License-Identifier: GPL-2.0-or-later */
1da177e4
LT
2/*
3 * VLAN An implementation of 802.1Q VLAN tagging.
4 *
5 * Authors: Ben Greear <greearb@candelatech.com>
1da177e4 6 */
1da177e4
LT
7#ifndef _LINUX_IF_VLAN_H_
8#define _LINUX_IF_VLAN_H_
9
1da177e4 10#include <linux/netdevice.h>
0610d11b 11#include <linux/etherdevice.h>
65ac6a5f 12#include <linux/rtnetlink.h>
187f1882 13#include <linux/bug.h>
607ca46e 14#include <uapi/linux/if_vlan.h>
1da177e4 15
a3f671b3
JP
16#define VLAN_HLEN 4 /* The additional bytes required by VLAN
17 * (in addition to the Ethernet header)
1da177e4 18 */
1da177e4
LT
19#define VLAN_ETH_HLEN 18 /* Total octets in header. */
20#define VLAN_ETH_ZLEN 64 /* Min. octets in frame sans FCS */
21
22/*
23 * According to 802.3ac, the packet can be 4 bytes longer. --Klika Jan
24 */
25#define VLAN_ETH_DATA_LEN 1500 /* Max. octets in payload */
26#define VLAN_ETH_FRAME_LEN 1518 /* Max. octets in frame sans FCS */
27
740c15d0
PM
28/*
29 * struct vlan_hdr - vlan header
30 * @h_vlan_TCI: priority and VLAN ID
31 * @h_vlan_encapsulated_proto: packet type ID or len
32 */
33struct vlan_hdr {
34 __be16 h_vlan_TCI;
35 __be16 h_vlan_encapsulated_proto;
36};
37
38/**
39 * struct vlan_ethhdr - vlan ethernet header (ethhdr + vlan_hdr)
40 * @h_dest: destination ethernet address
41 * @h_source: source ethernet address
a7bf5804 42 * @h_vlan_proto: ethernet protocol
740c15d0
PM
43 * @h_vlan_TCI: priority and VLAN ID
44 * @h_vlan_encapsulated_proto: packet type ID or len
45 */
1da177e4 46struct vlan_ethhdr {
740c15d0
PM
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;
1da177e4
LT
52};
53
54#include <linux/skbuff.h>
55
56static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
57{
98e399f8 58 return (struct vlan_ethhdr *)skb_mac_header(skb);
1da177e4
LT
59}
60
05423b24
ED
61#define VLAN_PRIO_MASK 0xe000 /* Priority Code Point */
62#define VLAN_PRIO_SHIFT 13
a2e768b8 63#define VLAN_CFI_MASK 0x1000 /* Canonical Format Indicator / Drop Eligible Indicator */
05423b24 64#define VLAN_VID_MASK 0x0fff /* VLAN Identifier */
b738127d 65#define VLAN_N_VID 4096
1da177e4
LT
66
67/* found in socket.c */
881d966b 68extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *));
1da177e4 69
b618aaa9 70static inline bool is_vlan_dev(const struct net_device *dev)
6dcbbe25
NH
71{
72 return dev->priv_flags & IFF_802_1Q_VLAN;
73}
74
0c4b2d37
MM
75#define skb_vlan_tag_present(__skb) ((__skb)->vlan_present)
76#define skb_vlan_tag_get(__skb) ((__skb)->vlan_tci)
df8a39de 77#define skb_vlan_tag_get_id(__skb) ((__skb)->vlan_tci & VLAN_VID_MASK)
a2e768b8 78#define skb_vlan_tag_get_cfi(__skb) (!!((__skb)->vlan_tci & VLAN_CFI_MASK))
9b319148 79#define skb_vlan_tag_get_prio(__skb) (((__skb)->vlan_tci & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT)
1da177e4 80
9daae9bd
GP
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
e267cb96
DM
105/**
106 * struct vlan_pcpu_stats - VLAN percpu rx/tx stats
107 * @rx_packets: number of received packets
108 * @rx_bytes: number of received bytes
109 * @rx_multicast: number of received multicast packets
110 * @tx_packets: number of transmitted packets
111 * @tx_bytes: number of transmitted bytes
112 * @syncp: synchronization point for 64bit counters
113 * @rx_errors: number of rx errors
114 * @tx_dropped: number of tx drops
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
1e85c9b6
HFS
127#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
128
f06c7f9f 129extern struct net_device *__vlan_find_dev_deep_rcu(struct net_device *real_dev,
1e85c9b6 130 __be16 vlan_proto, u16 vlan_id);
960abf68
IK
131extern int vlan_for_each(struct net_device *dev,
132 int (*action)(struct net_device *dev, int vid,
133 void *arg), void *arg);
1e85c9b6
HFS
134extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
135extern u16 vlan_dev_vlan_id(const struct net_device *dev);
71e415e4 136extern __be16 vlan_dev_vlan_proto(const struct net_device *dev);
1e85c9b6
HFS
137
138/**
139 * struct vlan_priority_tci_mapping - vlan egress priority mappings
140 * @priority: skb priority
141 * @vlan_qos: vlan priority: (skb->priority << 13) & 0xE000
142 * @next: pointer to next struct
143 */
144struct vlan_priority_tci_mapping {
145 u32 priority;
146 u16 vlan_qos;
147 struct vlan_priority_tci_mapping *next;
148};
149
e267cb96
DM
150struct proc_dir_entry;
151struct netpoll;
152
153/**
154 * struct vlan_dev_priv - VLAN private device data
155 * @nr_ingress_mappings: number of ingress priority mappings
156 * @ingress_priority_map: ingress priority mappings
157 * @nr_egress_mappings: number of egress priority mappings
158 * @egress_priority_map: hash of egress priority mappings
159 * @vlan_proto: VLAN encapsulation protocol
160 * @vlan_id: VLAN identifier
161 * @flags: device flags
162 * @real_dev: underlying netdevice
163 * @real_dev_addr: address of underlying netdevice
164 * @dent: proc dir entry
165 * @vlan_pcpu_stats: ptr to percpu rx stats
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
d38569ab 185 unsigned int nest_level;
e267cb96
DM
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(); /* coupled with smp_wmb() in vlan_dev_set_egress_priority() */
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; /* This should already be shifted
204 * to mask correctly with the
205 * VLAN's TCI */
206 }
207 mp = mp->next;
208 }
209 return 0;
210}
211
48cc32d3 212extern bool vlan_do_receive(struct sk_buff **skb);
9b22ea56 213
80d5c368
PM
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);
87002b03 216
348a1443
JP
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);
9b361c13
JP
221
222extern bool vlan_uses_dev(const struct net_device *dev);
e1618d46
VY
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}
7750f403 229#else
cec9c133 230static inline struct net_device *
f06c7f9f 231__vlan_find_dev_deep_rcu(struct net_device *real_dev,
9fae27b3 232 __be16 vlan_proto, u16 vlan_id)
cec9c133
JP
233{
234 return NULL;
235}
236
960abf68
IK
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
22d1ba74
PM
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
71e415e4 257static inline __be16 vlan_dev_vlan_proto(const struct net_device *dev)
258{
259 BUG();
260 return 0;
261}
262
d3243539
EP
263static inline u16 vlan_dev_get_egress_qos_mask(struct net_device *dev,
264 u32 skprio)
265{
266 return 0;
267}
268
48cc32d3 269static inline bool vlan_do_receive(struct sk_buff **skb)
9b22ea56 270{
3701e513 271 return false;
9b22ea56 272}
e1c096e2 273
9fae27b3 274static inline int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid)
87002b03
JP
275{
276 return 0;
277}
278
9fae27b3 279static inline void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid)
87002b03
JP
280{
281}
348a1443
JP
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}
9b361c13
JP
293
294static inline bool vlan_uses_dev(const struct net_device *dev)
295{
296 return false;
297}
e1618d46
VY
298static inline int vlan_get_encap_level(struct net_device *dev)
299{
300 BUG();
301 return 0;
302}
7750f403 303#endif
1da177e4 304
fe19c4f9
EG
305/**
306 * eth_type_vlan - check for valid vlan ether type.
307 * @ethertype: ether type to check
308 *
309 * Returns true if the ether type is a vlan ether type.
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
86a9bad3
PM
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;
8ad227ff
PM
327 if (proto == htons(ETH_P_8021AD) && features & NETIF_F_HW_VLAN_STAG_TX)
328 return true;
86a9bad3
PM
329 return false;
330}
331
1da177e4 332/**
cbe7128c 333 * __vlan_insert_inner_tag - inner VLAN tag inserting
1da177e4 334 * @skb: skbuff to tag
86a9bad3 335 * @vlan_proto: VLAN encapsulation protocol
9bb8582e 336 * @vlan_tci: VLAN TCI to insert
cbe7128c 337 * @mac_len: MAC header length including outer vlan headers
1da177e4 338 *
cbe7128c 339 * Inserts the VLAN tag into @skb as part of the payload at offset mac_len
8051ac76 340 * Returns error if skb_cow_head fails.
0b5c9db1
JP
341 *
342 * Does not change skb->protocol so this function can be used during receive.
1da177e4 343 */
cbe7128c
TM
344static inline int __vlan_insert_inner_tag(struct sk_buff *skb,
345 __be16 vlan_proto, u16 vlan_tci,
346 unsigned int mac_len)
1da177e4
LT
347{
348 struct vlan_ethhdr *veth;
349
15255a43
JP
350 if (skb_cow_head(skb, VLAN_HLEN) < 0)
351 return -ENOMEM;
352
cbe7128c 353 skb_push(skb, VLAN_HLEN);
1da177e4 354
cbe7128c 355 /* Move the mac header sans proto to the beginning of the new header. */
c769accd
TM
356 if (likely(mac_len > ETH_TLEN))
357 memmove(skb->data, skb->data + VLAN_HLEN, mac_len - ETH_TLEN);
e4dd6188 358 skb->mac_header -= VLAN_HLEN;
1da177e4 359
cbe7128c
TM
360 veth = (struct vlan_ethhdr *)(skb->data + mac_len - ETH_HLEN);
361
1da177e4 362 /* first, the ethernet type */
c769accd
TM
363 if (likely(mac_len >= ETH_TLEN)) {
364 /* h_vlan_encapsulated_proto should already be populated, and
365 * skb->data has space for h_vlan_proto
366 */
367 veth->h_vlan_proto = vlan_proto;
368 } else {
369 /* h_vlan_encapsulated_proto should not be populated, and
370 * skb->data has no space for h_vlan_proto
371 */
372 veth->h_vlan_encapsulated_proto = skb->protocol;
373 }
1da177e4 374
9bb8582e
PM
375 /* now, the TCI */
376 veth->h_vlan_TCI = htons(vlan_tci);
1da177e4 377
15255a43
JP
378 return 0;
379}
380
381/**
cbe7128c 382 * __vlan_insert_tag - regular VLAN tag inserting
15255a43
JP
383 * @skb: skbuff to tag
384 * @vlan_proto: VLAN encapsulation protocol
385 * @vlan_tci: VLAN TCI to insert
386 *
387 * Inserts the VLAN tag into @skb as part of the payload
8051ac76 388 * Returns error if skb_cow_head fails.
cbe7128c
TM
389 *
390 * Does not change skb->protocol so this function can be used during receive.
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 * vlan_insert_inner_tag - inner VLAN tag inserting
400 * @skb: skbuff to tag
401 * @vlan_proto: VLAN encapsulation protocol
402 * @vlan_tci: VLAN TCI to insert
403 * @mac_len: MAC header length including outer vlan headers
404 *
405 * Inserts the VLAN tag into @skb as part of the payload at offset mac_len
15255a43
JP
406 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
407 *
408 * Following the skb_unshare() example, in case of error, the calling function
409 * doesn't have to worry about freeing the original skb.
410 *
411 * Does not change skb->protocol so this function can be used during receive.
412 */
cbe7128c
TM
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)
15255a43
JP
417{
418 int err;
419
cbe7128c 420 err = __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, mac_len);
15255a43
JP
421 if (err) {
422 dev_kfree_skb_any(skb);
423 return NULL;
424 }
0b5c9db1
JP
425 return skb;
426}
1da177e4 427
cbe7128c
TM
428/**
429 * vlan_insert_tag - regular VLAN tag inserting
430 * @skb: skbuff to tag
431 * @vlan_proto: VLAN encapsulation protocol
432 * @vlan_tci: VLAN TCI to insert
433 *
434 * Inserts the VLAN tag into @skb as part of the payload
435 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
436 *
437 * Following the skb_unshare() example, in case of error, the calling function
438 * doesn't have to worry about freeing the original skb.
439 *
440 * Does not change skb->protocol so this function can be used during receive.
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
0b5c9db1 448/**
62749e2c 449 * vlan_insert_tag_set_proto - regular VLAN tag inserting
0b5c9db1 450 * @skb: skbuff to tag
62749e2c 451 * @vlan_proto: VLAN encapsulation protocol
0b5c9db1
JP
452 * @vlan_tci: VLAN TCI to insert
453 *
454 * Inserts the VLAN tag into @skb as part of the payload
455 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
456 *
457 * Following the skb_unshare() example, in case of error, the calling function
458 * doesn't have to worry about freeing the original skb.
459 */
62749e2c
JP
460static inline struct sk_buff *vlan_insert_tag_set_proto(struct sk_buff *skb,
461 __be16 vlan_proto,
462 u16 vlan_tci)
0b5c9db1 463{
86a9bad3 464 skb = vlan_insert_tag(skb, vlan_proto, vlan_tci);
0b5c9db1 465 if (skb)
86a9bad3 466 skb->protocol = vlan_proto;
1da177e4
LT
467 return skb;
468}
469
c8accd5a
MM
470/**
471 * __vlan_hwaccel_clear_tag - clear hardware accelerated VLAN info
472 * @skb: skbuff to clear
473 *
474 * Clears the VLAN information from @skb
475 */
476static inline void __vlan_hwaccel_clear_tag(struct sk_buff *skb)
477{
0c4b2d37 478 skb->vlan_present = 0;
c8accd5a
MM
479}
480
e0a6b809
MM
481/**
482 * __vlan_hwaccel_copy_tag - copy hardware accelerated VLAN info from another skb
483 * @dst: skbuff to copy to
484 * @src: skbuff to copy from
485 *
486 * Copies VLAN information from @src to @dst (for branchless code)
487 */
488static inline void __vlan_hwaccel_copy_tag(struct sk_buff *dst, const struct sk_buff *src)
489{
0c4b2d37 490 dst->vlan_present = src->vlan_present;
e0a6b809
MM
491 dst->vlan_proto = src->vlan_proto;
492 dst->vlan_tci = src->vlan_tci;
493}
494
5968250c
JP
495/*
496 * __vlan_hwaccel_push_inside - pushes vlan tag to the payload
497 * @skb: skbuff to tag
498 *
499 * Pushes the VLAN tag from @skb->vlan_tci inside to the payload.
500 *
501 * Following the skb_unshare() example, in case of error, the calling function
502 * doesn't have to worry about freeing the original skb.
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,
df8a39de 507 skb_vlan_tag_get(skb));
5968250c 508 if (likely(skb))
c8accd5a 509 __vlan_hwaccel_clear_tag(skb);
5968250c
JP
510 return skb;
511}
5968250c 512
1da177e4
LT
513/**
514 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
515 * @skb: skbuff to tag
86a9bad3 516 * @vlan_proto: VLAN encapsulation protocol
9bb8582e 517 * @vlan_tci: VLAN TCI to insert
1da177e4 518 *
6aa895b0 519 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest
1da177e4 520 */
b960a0ac
JP
521static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb,
522 __be16 vlan_proto, u16 vlan_tci)
1da177e4 523{
86a9bad3 524 skb->vlan_proto = vlan_proto;
0c4b2d37
MM
525 skb->vlan_tci = vlan_tci;
526 skb->vlan_present = 1;
1da177e4
LT
527}
528
1da177e4
LT
529/**
530 * __vlan_get_tag - get the VLAN ID that is part of the payload
531 * @skb: skbuff to query
f4fb874c 532 * @vlan_tci: buffer to store value
9bb8582e 533 *
1da177e4
LT
534 * Returns error if the skb is not of VLAN type
535 */
9bb8582e 536static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
1da177e4
LT
537{
538 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
539
fe19c4f9 540 if (!eth_type_vlan(veth->h_vlan_proto))
1da177e4 541 return -EINVAL;
1da177e4 542
9bb8582e 543 *vlan_tci = ntohs(veth->h_vlan_TCI);
1da177e4
LT
544 return 0;
545}
546
547/**
548 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
549 * @skb: skbuff to query
f4fb874c 550 * @vlan_tci: buffer to store value
9bb8582e 551 *
6aa895b0 552 * Returns error if @skb->vlan_tci is not set correctly
1da177e4 553 */
18149935 554static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
9bb8582e 555 u16 *vlan_tci)
1da177e4 556{
df8a39de
JP
557 if (skb_vlan_tag_present(skb)) {
558 *vlan_tci = skb_vlan_tag_get(skb);
1da177e4
LT
559 return 0;
560 } else {
9bb8582e 561 *vlan_tci = 0;
1da177e4
LT
562 return -EINVAL;
563 }
564}
565
1da177e4
LT
566/**
567 * vlan_get_tag - get the VLAN ID from the skb
568 * @skb: skbuff to query
f4fb874c 569 * @vlan_tci: buffer to store value
9bb8582e 570 *
1da177e4
LT
571 * Returns error if the skb is not VLAN tagged
572 */
9bb8582e 573static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
1da177e4 574{
f646968f 575 if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) {
9bb8582e 576 return __vlan_hwaccel_get_tag(skb, vlan_tci);
1da177e4 577 } else {
9bb8582e 578 return __vlan_get_tag(skb, vlan_tci);
1da177e4
LT
579 }
580}
581
0a85df00
HZ
582/**
583 * vlan_get_protocol - get protocol EtherType.
584 * @skb: skbuff to query
d4bcef3f
TM
585 * @type: first vlan protocol
586 * @depth: buffer to store length of eth and vlan tags in bytes
0a85df00
HZ
587 *
588 * Returns the EtherType of the packet, regardless of whether it is
589 * vlan encapsulated (normal or hardware accelerated) or not.
590 */
d4bcef3f
TM
591static inline __be16 __vlan_get_protocol(struct sk_buff *skb, __be16 type,
592 int *depth)
0a85df00 593{
d4bcef3f
TM
594 unsigned int vlan_depth = skb->mac_len;
595
596 /* if type is 802.1Q/AD then the header should already be
597 * present at mac_len - VLAN_HLEN (if mac_len > 0), or at
598 * ETH_HLEN otherwise
599 */
fe19c4f9 600 if (eth_type_vlan(type)) {
d4bcef3f
TM
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;
fe19c4f9 618 } while (eth_type_vlan(type));
0a85df00
HZ
619 }
620
d4bcef3f
TM
621 if (depth)
622 *depth = vlan_depth;
623
624 return type;
625}
626
627/**
628 * vlan_get_protocol - get protocol EtherType.
629 * @skb: skbuff to query
630 *
631 * Returns the EtherType of the packet, regardless of whether it is
632 * vlan encapsulated (normal or hardware accelerated) or not.
633 */
634static inline __be16 vlan_get_protocol(struct sk_buff *skb)
635{
636 return __vlan_get_protocol(skb, skb->protocol, NULL);
0a85df00 637}
396cf943
PS
638
639static inline void vlan_set_encap_proto(struct sk_buff *skb,
640 struct vlan_hdr *vhdr)
641{
642 __be16 proto;
da8c8724 643 unsigned short *rawp;
396cf943
PS
644
645 /*
646 * Was a VLAN packet, grab the encapsulated protocol, which the layer
647 * three protocols care about.
648 */
649
650 proto = vhdr->h_vlan_encapsulated_proto;
9545b22d 651 if (eth_proto_is_802_3(proto)) {
396cf943
PS
652 skb->protocol = proto;
653 return;
654 }
655
da8c8724
CW
656 rawp = (unsigned short *)(vhdr + 1);
657 if (*rawp == 0xFFFF)
396cf943
PS
658 /*
659 * This is a magic hack to spot IPX packets. Older Novell
660 * breaks the protocol design and runs IPX over 802.3 without
661 * an 802.2 LLC layer. We look for FFFF which isn't a used
662 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware
663 * but does for the rest.
664 */
665 skb->protocol = htons(ETH_P_802_3);
666 else
667 /*
668 * Real 802.2 LLC
669 */
670 skb->protocol = htons(ETH_P_802_2);
671}
44a40855 672
f5a7fb88
TM
673/**
674 * skb_vlan_tagged - check if skb is vlan tagged.
675 * @skb: skbuff to query
676 *
677 * Returns true if the skb is tagged, regardless of whether it is hardware
678 * accelerated or not.
679 */
680static inline bool skb_vlan_tagged(const struct sk_buff *skb)
681{
682 if (!skb_vlan_tag_present(skb) &&
fe19c4f9 683 likely(!eth_type_vlan(skb->protocol)))
f5a7fb88
TM
684 return false;
685
686 return true;
687}
688
689/**
690 * skb_vlan_tagged_multi - check if skb is vlan tagged with multiple headers.
691 * @skb: skbuff to query
692 *
693 * Returns true if the skb is tagged with multiple vlan headers, regardless
694 * of whether it is hardware accelerated or not.
695 */
7ce23672 696static inline bool skb_vlan_tagged_multi(struct sk_buff *skb)
f5a7fb88
TM
697{
698 __be16 protocol = skb->protocol;
699
700 if (!skb_vlan_tag_present(skb)) {
701 struct vlan_ethhdr *veh;
702
fe19c4f9 703 if (likely(!eth_type_vlan(protocol)))
f5a7fb88
TM
704 return false;
705
7ce23672
TM
706 if (unlikely(!pskb_may_pull(skb, VLAN_ETH_HLEN)))
707 return false;
708
f5a7fb88
TM
709 veh = (struct vlan_ethhdr *)skb->data;
710 protocol = veh->h_vlan_encapsulated_proto;
711 }
712
fe19c4f9 713 if (!eth_type_vlan(protocol))
f5a7fb88
TM
714 return false;
715
716 return true;
717}
718
8cb65d00
TM
719/**
720 * vlan_features_check - drop unsafe features for skb with multiple tags.
721 * @skb: skbuff to query
722 * @features: features to be checked
723 *
724 * Returns features without unsafe ones if the skb has multiple tags.
725 */
7ce23672 726static inline netdev_features_t vlan_features_check(struct sk_buff *skb,
8cb65d00
TM
727 netdev_features_t features)
728{
35d2f80b
VY
729 if (skb_vlan_tagged_multi(skb)) {
730 /* In the case of multi-tagged packets, use a direct mask
731 * instead of using netdev_interesect_features(), to make
732 * sure that only devices supporting NETIF_F_HW_CSUM will
733 * have checksum offloading support.
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 }
8cb65d00
TM
739
740 return features;
741}
742
66e5133f
TM
743/**
744 * compare_vlan_header - Compare two vlan headers
745 * @h1: Pointer to vlan header
746 * @h2: Pointer to vlan header
747 *
748 * Compare two vlan headers, returns 0 if equal.
749 *
750 * Please note that alignment of h1 & h2 are only guaranteed to be 16 bits.
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}
1da177e4 763#endif /* !(_LINUX_IF_VLAN_H_) */