1 /* 2 * VLAN An implementation of 802.1Q VLAN tagging. 3 * 4 * Authors: Ben Greear <greearb@candelatech.com> 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 * 11 */ 12 #ifndef _LINUX_IF_VLAN_H_ 13 #define _LINUX_IF_VLAN_H_ 14 15 #include <linux/netdevice.h> 16 #include <linux/etherdevice.h> 17 #include <linux/rtnetlink.h> 18 #include <linux/bug.h> 19 #include <uapi/linux/if_vlan.h> 20 21 #define VLAN_HLEN 4 /* The additional bytes required by VLAN 22 * (in addition to the Ethernet header) 23 */ 24 #define VLAN_ETH_HLEN 18 /* Total octets in header. */ 25 #define VLAN_ETH_ZLEN 64 /* Min. octets in frame sans FCS */ 26 27 /* 28 * According to 802.3ac, the packet can be 4 bytes longer. --Klika Jan 29 */ 30 #define VLAN_ETH_DATA_LEN 1500 /* Max. octets in payload */ 31 #define VLAN_ETH_FRAME_LEN 1518 /* Max. octets in frame sans FCS */ 32 33 /* 34 * struct vlan_hdr - vlan header 35 * @h_vlan_TCI: priority and VLAN ID 36 * @h_vlan_encapsulated_proto: packet type ID or len 37 */ 38 struct vlan_hdr { 39 __be16 h_vlan_TCI; 40 __be16 h_vlan_encapsulated_proto; 41 }; 42 43 /** 44 * struct vlan_ethhdr - vlan ethernet header (ethhdr + vlan_hdr) 45 * @h_dest: destination ethernet address 46 * @h_source: source ethernet address 47 * @h_vlan_proto: ethernet protocol 48 * @h_vlan_TCI: priority and VLAN ID 49 * @h_vlan_encapsulated_proto: packet type ID or len 50 */ 51 struct vlan_ethhdr { 52 unsigned char h_dest[ETH_ALEN]; 53 unsigned char h_source[ETH_ALEN]; 54 __be16 h_vlan_proto; 55 __be16 h_vlan_TCI; 56 __be16 h_vlan_encapsulated_proto; 57 }; 58 59 #include <linux/skbuff.h> 60 61 static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb) 62 { 63 return (struct vlan_ethhdr *)skb_mac_header(skb); 64 } 65 66 #define VLAN_PRIO_MASK 0xe000 /* Priority Code Point */ 67 #define VLAN_PRIO_SHIFT 13 68 #define VLAN_CFI_MASK 0x1000 /* Canonical Format Indicator */ 69 #define VLAN_TAG_PRESENT VLAN_CFI_MASK 70 #define VLAN_VID_MASK 0x0fff /* VLAN Identifier */ 71 #define VLAN_N_VID 4096 72 73 /* found in socket.c */ 74 extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *)); 75 76 static inline bool is_vlan_dev(const struct net_device *dev) 77 { 78 return dev->priv_flags & IFF_802_1Q_VLAN; 79 } 80 81 #define skb_vlan_tag_present(__skb) ((__skb)->vlan_tci & VLAN_TAG_PRESENT) 82 #define skb_vlan_tag_get(__skb) ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT) 83 #define skb_vlan_tag_get_id(__skb) ((__skb)->vlan_tci & VLAN_VID_MASK) 84 #define skb_vlan_tag_get_prio(__skb) ((__skb)->vlan_tci & VLAN_PRIO_MASK) 85 86 static inline int vlan_get_rx_ctag_filter_info(struct net_device *dev) 87 { 88 ASSERT_RTNL(); 89 return notifier_to_errno(call_netdevice_notifiers(NETDEV_CVLAN_FILTER_PUSH_INFO, dev)); 90 } 91 92 static inline void vlan_drop_rx_ctag_filter_info(struct net_device *dev) 93 { 94 ASSERT_RTNL(); 95 call_netdevice_notifiers(NETDEV_CVLAN_FILTER_DROP_INFO, dev); 96 } 97 98 static inline int vlan_get_rx_stag_filter_info(struct net_device *dev) 99 { 100 ASSERT_RTNL(); 101 return notifier_to_errno(call_netdevice_notifiers(NETDEV_SVLAN_FILTER_PUSH_INFO, dev)); 102 } 103 104 static inline void vlan_drop_rx_stag_filter_info(struct net_device *dev) 105 { 106 ASSERT_RTNL(); 107 call_netdevice_notifiers(NETDEV_SVLAN_FILTER_DROP_INFO, dev); 108 } 109 110 /** 111 * struct vlan_pcpu_stats - VLAN percpu rx/tx stats 112 * @rx_packets: number of received packets 113 * @rx_bytes: number of received bytes 114 * @rx_multicast: number of received multicast packets 115 * @tx_packets: number of transmitted packets 116 * @tx_bytes: number of transmitted bytes 117 * @syncp: synchronization point for 64bit counters 118 * @rx_errors: number of rx errors 119 * @tx_dropped: number of tx drops 120 */ 121 struct vlan_pcpu_stats { 122 u64 rx_packets; 123 u64 rx_bytes; 124 u64 rx_multicast; 125 u64 tx_packets; 126 u64 tx_bytes; 127 struct u64_stats_sync syncp; 128 u32 rx_errors; 129 u32 tx_dropped; 130 }; 131 132 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) 133 134 extern struct net_device *__vlan_find_dev_deep_rcu(struct net_device *real_dev, 135 __be16 vlan_proto, u16 vlan_id); 136 extern struct net_device *vlan_dev_real_dev(const struct net_device *dev); 137 extern u16 vlan_dev_vlan_id(const struct net_device *dev); 138 extern __be16 vlan_dev_vlan_proto(const struct net_device *dev); 139 140 /** 141 * struct vlan_priority_tci_mapping - vlan egress priority mappings 142 * @priority: skb priority 143 * @vlan_qos: vlan priority: (skb->priority << 13) & 0xE000 144 * @next: pointer to next struct 145 */ 146 struct vlan_priority_tci_mapping { 147 u32 priority; 148 u16 vlan_qos; 149 struct vlan_priority_tci_mapping *next; 150 }; 151 152 struct proc_dir_entry; 153 struct netpoll; 154 155 /** 156 * struct vlan_dev_priv - VLAN private device data 157 * @nr_ingress_mappings: number of ingress priority mappings 158 * @ingress_priority_map: ingress priority mappings 159 * @nr_egress_mappings: number of egress priority mappings 160 * @egress_priority_map: hash of egress priority mappings 161 * @vlan_proto: VLAN encapsulation protocol 162 * @vlan_id: VLAN identifier 163 * @flags: device flags 164 * @real_dev: underlying netdevice 165 * @real_dev_addr: address of underlying netdevice 166 * @dent: proc dir entry 167 * @vlan_pcpu_stats: ptr to percpu rx stats 168 */ 169 struct vlan_dev_priv { 170 unsigned int nr_ingress_mappings; 171 u32 ingress_priority_map[8]; 172 unsigned int nr_egress_mappings; 173 struct vlan_priority_tci_mapping *egress_priority_map[16]; 174 175 __be16 vlan_proto; 176 u16 vlan_id; 177 u16 flags; 178 179 struct net_device *real_dev; 180 unsigned char real_dev_addr[ETH_ALEN]; 181 182 struct proc_dir_entry *dent; 183 struct vlan_pcpu_stats __percpu *vlan_pcpu_stats; 184 #ifdef CONFIG_NET_POLL_CONTROLLER 185 struct netpoll *netpoll; 186 #endif 187 unsigned int nest_level; 188 }; 189 190 static inline struct vlan_dev_priv *vlan_dev_priv(const struct net_device *dev) 191 { 192 return netdev_priv(dev); 193 } 194 195 static inline u16 196 vlan_dev_get_egress_qos_mask(struct net_device *dev, u32 skprio) 197 { 198 struct vlan_priority_tci_mapping *mp; 199 200 smp_rmb(); /* coupled with smp_wmb() in vlan_dev_set_egress_priority() */ 201 202 mp = vlan_dev_priv(dev)->egress_priority_map[(skprio & 0xF)]; 203 while (mp) { 204 if (mp->priority == skprio) { 205 return mp->vlan_qos; /* This should already be shifted 206 * to mask correctly with the 207 * VLAN's TCI */ 208 } 209 mp = mp->next; 210 } 211 return 0; 212 } 213 214 extern bool vlan_do_receive(struct sk_buff **skb); 215 216 extern int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid); 217 extern void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid); 218 219 extern int vlan_vids_add_by_dev(struct net_device *dev, 220 const struct net_device *by_dev); 221 extern void vlan_vids_del_by_dev(struct net_device *dev, 222 const struct net_device *by_dev); 223 224 extern bool vlan_uses_dev(const struct net_device *dev); 225 226 static inline int vlan_get_encap_level(struct net_device *dev) 227 { 228 BUG_ON(!is_vlan_dev(dev)); 229 return vlan_dev_priv(dev)->nest_level; 230 } 231 #else 232 static inline struct net_device * 233 __vlan_find_dev_deep_rcu(struct net_device *real_dev, 234 __be16 vlan_proto, u16 vlan_id) 235 { 236 return NULL; 237 } 238 239 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev) 240 { 241 BUG(); 242 return NULL; 243 } 244 245 static inline u16 vlan_dev_vlan_id(const struct net_device *dev) 246 { 247 BUG(); 248 return 0; 249 } 250 251 static inline __be16 vlan_dev_vlan_proto(const struct net_device *dev) 252 { 253 BUG(); 254 return 0; 255 } 256 257 static inline u16 vlan_dev_get_egress_qos_mask(struct net_device *dev, 258 u32 skprio) 259 { 260 return 0; 261 } 262 263 static inline bool vlan_do_receive(struct sk_buff **skb) 264 { 265 return false; 266 } 267 268 static inline int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid) 269 { 270 return 0; 271 } 272 273 static inline void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid) 274 { 275 } 276 277 static inline int vlan_vids_add_by_dev(struct net_device *dev, 278 const struct net_device *by_dev) 279 { 280 return 0; 281 } 282 283 static inline void vlan_vids_del_by_dev(struct net_device *dev, 284 const struct net_device *by_dev) 285 { 286 } 287 288 static inline bool vlan_uses_dev(const struct net_device *dev) 289 { 290 return false; 291 } 292 static inline int vlan_get_encap_level(struct net_device *dev) 293 { 294 BUG(); 295 return 0; 296 } 297 #endif 298 299 /** 300 * eth_type_vlan - check for valid vlan ether type. 301 * @ethertype: ether type to check 302 * 303 * Returns true if the ether type is a vlan ether type. 304 */ 305 static inline bool eth_type_vlan(__be16 ethertype) 306 { 307 switch (ethertype) { 308 case htons(ETH_P_8021Q): 309 case htons(ETH_P_8021AD): 310 return true; 311 default: 312 return false; 313 } 314 } 315 316 static inline bool vlan_hw_offload_capable(netdev_features_t features, 317 __be16 proto) 318 { 319 if (proto == htons(ETH_P_8021Q) && features & NETIF_F_HW_VLAN_CTAG_TX) 320 return true; 321 if (proto == htons(ETH_P_8021AD) && features & NETIF_F_HW_VLAN_STAG_TX) 322 return true; 323 return false; 324 } 325 326 /** 327 * __vlan_insert_inner_tag - inner VLAN tag inserting 328 * @skb: skbuff to tag 329 * @vlan_proto: VLAN encapsulation protocol 330 * @vlan_tci: VLAN TCI to insert 331 * @mac_len: MAC header length including outer vlan headers 332 * 333 * Inserts the VLAN tag into @skb as part of the payload at offset mac_len 334 * Returns error if skb_cow_head fails. 335 * 336 * Does not change skb->protocol so this function can be used during receive. 337 */ 338 static inline int __vlan_insert_inner_tag(struct sk_buff *skb, 339 __be16 vlan_proto, u16 vlan_tci, 340 unsigned int mac_len) 341 { 342 struct vlan_ethhdr *veth; 343 344 if (skb_cow_head(skb, VLAN_HLEN) < 0) 345 return -ENOMEM; 346 347 skb_push(skb, VLAN_HLEN); 348 349 /* Move the mac header sans proto to the beginning of the new header. */ 350 if (likely(mac_len > ETH_TLEN)) 351 memmove(skb->data, skb->data + VLAN_HLEN, mac_len - ETH_TLEN); 352 skb->mac_header -= VLAN_HLEN; 353 354 veth = (struct vlan_ethhdr *)(skb->data + mac_len - ETH_HLEN); 355 356 /* first, the ethernet type */ 357 if (likely(mac_len >= ETH_TLEN)) { 358 /* h_vlan_encapsulated_proto should already be populated, and 359 * skb->data has space for h_vlan_proto 360 */ 361 veth->h_vlan_proto = vlan_proto; 362 } else { 363 /* h_vlan_encapsulated_proto should not be populated, and 364 * skb->data has no space for h_vlan_proto 365 */ 366 veth->h_vlan_encapsulated_proto = skb->protocol; 367 } 368 369 /* now, the TCI */ 370 veth->h_vlan_TCI = htons(vlan_tci); 371 372 return 0; 373 } 374 375 /** 376 * __vlan_insert_tag - regular VLAN tag inserting 377 * @skb: skbuff to tag 378 * @vlan_proto: VLAN encapsulation protocol 379 * @vlan_tci: VLAN TCI to insert 380 * 381 * Inserts the VLAN tag into @skb as part of the payload 382 * Returns error if skb_cow_head fails. 383 * 384 * Does not change skb->protocol so this function can be used during receive. 385 */ 386 static inline int __vlan_insert_tag(struct sk_buff *skb, 387 __be16 vlan_proto, u16 vlan_tci) 388 { 389 return __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, ETH_HLEN); 390 } 391 392 /** 393 * vlan_insert_inner_tag - inner VLAN tag inserting 394 * @skb: skbuff to tag 395 * @vlan_proto: VLAN encapsulation protocol 396 * @vlan_tci: VLAN TCI to insert 397 * @mac_len: MAC header length including outer vlan headers 398 * 399 * Inserts the VLAN tag into @skb as part of the payload at offset mac_len 400 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 401 * 402 * Following the skb_unshare() example, in case of error, the calling function 403 * doesn't have to worry about freeing the original skb. 404 * 405 * Does not change skb->protocol so this function can be used during receive. 406 */ 407 static inline struct sk_buff *vlan_insert_inner_tag(struct sk_buff *skb, 408 __be16 vlan_proto, 409 u16 vlan_tci, 410 unsigned int mac_len) 411 { 412 int err; 413 414 err = __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, mac_len); 415 if (err) { 416 dev_kfree_skb_any(skb); 417 return NULL; 418 } 419 return skb; 420 } 421 422 /** 423 * vlan_insert_tag - regular VLAN tag inserting 424 * @skb: skbuff to tag 425 * @vlan_proto: VLAN encapsulation protocol 426 * @vlan_tci: VLAN TCI to insert 427 * 428 * Inserts the VLAN tag into @skb as part of the payload 429 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 430 * 431 * Following the skb_unshare() example, in case of error, the calling function 432 * doesn't have to worry about freeing the original skb. 433 * 434 * Does not change skb->protocol so this function can be used during receive. 435 */ 436 static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, 437 __be16 vlan_proto, u16 vlan_tci) 438 { 439 return vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, ETH_HLEN); 440 } 441 442 /** 443 * vlan_insert_tag_set_proto - regular VLAN tag inserting 444 * @skb: skbuff to tag 445 * @vlan_proto: VLAN encapsulation protocol 446 * @vlan_tci: VLAN TCI to insert 447 * 448 * Inserts the VLAN tag into @skb as part of the payload 449 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 450 * 451 * Following the skb_unshare() example, in case of error, the calling function 452 * doesn't have to worry about freeing the original skb. 453 */ 454 static inline struct sk_buff *vlan_insert_tag_set_proto(struct sk_buff *skb, 455 __be16 vlan_proto, 456 u16 vlan_tci) 457 { 458 skb = vlan_insert_tag(skb, vlan_proto, vlan_tci); 459 if (skb) 460 skb->protocol = vlan_proto; 461 return skb; 462 } 463 464 /* 465 * __vlan_hwaccel_push_inside - pushes vlan tag to the payload 466 * @skb: skbuff to tag 467 * 468 * Pushes the VLAN tag from @skb->vlan_tci inside to the payload. 469 * 470 * Following the skb_unshare() example, in case of error, the calling function 471 * doesn't have to worry about freeing the original skb. 472 */ 473 static inline struct sk_buff *__vlan_hwaccel_push_inside(struct sk_buff *skb) 474 { 475 skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto, 476 skb_vlan_tag_get(skb)); 477 if (likely(skb)) 478 skb->vlan_tci = 0; 479 return skb; 480 } 481 482 /** 483 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting 484 * @skb: skbuff to tag 485 * @vlan_proto: VLAN encapsulation protocol 486 * @vlan_tci: VLAN TCI to insert 487 * 488 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest 489 */ 490 static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb, 491 __be16 vlan_proto, u16 vlan_tci) 492 { 493 skb->vlan_proto = vlan_proto; 494 skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci; 495 } 496 497 /** 498 * __vlan_get_tag - get the VLAN ID that is part of the payload 499 * @skb: skbuff to query 500 * @vlan_tci: buffer to store value 501 * 502 * Returns error if the skb is not of VLAN type 503 */ 504 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 505 { 506 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; 507 508 if (!eth_type_vlan(veth->h_vlan_proto)) 509 return -EINVAL; 510 511 *vlan_tci = ntohs(veth->h_vlan_TCI); 512 return 0; 513 } 514 515 /** 516 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] 517 * @skb: skbuff to query 518 * @vlan_tci: buffer to store value 519 * 520 * Returns error if @skb->vlan_tci is not set correctly 521 */ 522 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, 523 u16 *vlan_tci) 524 { 525 if (skb_vlan_tag_present(skb)) { 526 *vlan_tci = skb_vlan_tag_get(skb); 527 return 0; 528 } else { 529 *vlan_tci = 0; 530 return -EINVAL; 531 } 532 } 533 534 #define HAVE_VLAN_GET_TAG 535 536 /** 537 * vlan_get_tag - get the VLAN ID from the skb 538 * @skb: skbuff to query 539 * @vlan_tci: buffer to store value 540 * 541 * Returns error if the skb is not VLAN tagged 542 */ 543 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 544 { 545 if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) { 546 return __vlan_hwaccel_get_tag(skb, vlan_tci); 547 } else { 548 return __vlan_get_tag(skb, vlan_tci); 549 } 550 } 551 552 /** 553 * vlan_get_protocol - get protocol EtherType. 554 * @skb: skbuff to query 555 * @type: first vlan protocol 556 * @depth: buffer to store length of eth and vlan tags in bytes 557 * 558 * Returns the EtherType of the packet, regardless of whether it is 559 * vlan encapsulated (normal or hardware accelerated) or not. 560 */ 561 static inline __be16 __vlan_get_protocol(struct sk_buff *skb, __be16 type, 562 int *depth) 563 { 564 unsigned int vlan_depth = skb->mac_len; 565 566 /* if type is 802.1Q/AD then the header should already be 567 * present at mac_len - VLAN_HLEN (if mac_len > 0), or at 568 * ETH_HLEN otherwise 569 */ 570 if (eth_type_vlan(type)) { 571 if (vlan_depth) { 572 if (WARN_ON(vlan_depth < VLAN_HLEN)) 573 return 0; 574 vlan_depth -= VLAN_HLEN; 575 } else { 576 vlan_depth = ETH_HLEN; 577 } 578 do { 579 struct vlan_hdr *vh; 580 581 if (unlikely(!pskb_may_pull(skb, 582 vlan_depth + VLAN_HLEN))) 583 return 0; 584 585 vh = (struct vlan_hdr *)(skb->data + vlan_depth); 586 type = vh->h_vlan_encapsulated_proto; 587 vlan_depth += VLAN_HLEN; 588 } while (eth_type_vlan(type)); 589 } 590 591 if (depth) 592 *depth = vlan_depth; 593 594 return type; 595 } 596 597 /** 598 * vlan_get_protocol - get protocol EtherType. 599 * @skb: skbuff to query 600 * 601 * Returns the EtherType of the packet, regardless of whether it is 602 * vlan encapsulated (normal or hardware accelerated) or not. 603 */ 604 static inline __be16 vlan_get_protocol(struct sk_buff *skb) 605 { 606 return __vlan_get_protocol(skb, skb->protocol, NULL); 607 } 608 609 static inline void vlan_set_encap_proto(struct sk_buff *skb, 610 struct vlan_hdr *vhdr) 611 { 612 __be16 proto; 613 unsigned short *rawp; 614 615 /* 616 * Was a VLAN packet, grab the encapsulated protocol, which the layer 617 * three protocols care about. 618 */ 619 620 proto = vhdr->h_vlan_encapsulated_proto; 621 if (eth_proto_is_802_3(proto)) { 622 skb->protocol = proto; 623 return; 624 } 625 626 rawp = (unsigned short *)(vhdr + 1); 627 if (*rawp == 0xFFFF) 628 /* 629 * This is a magic hack to spot IPX packets. Older Novell 630 * breaks the protocol design and runs IPX over 802.3 without 631 * an 802.2 LLC layer. We look for FFFF which isn't a used 632 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 633 * but does for the rest. 634 */ 635 skb->protocol = htons(ETH_P_802_3); 636 else 637 /* 638 * Real 802.2 LLC 639 */ 640 skb->protocol = htons(ETH_P_802_2); 641 } 642 643 /** 644 * skb_vlan_tagged - check if skb is vlan tagged. 645 * @skb: skbuff to query 646 * 647 * Returns true if the skb is tagged, regardless of whether it is hardware 648 * accelerated or not. 649 */ 650 static inline bool skb_vlan_tagged(const struct sk_buff *skb) 651 { 652 if (!skb_vlan_tag_present(skb) && 653 likely(!eth_type_vlan(skb->protocol))) 654 return false; 655 656 return true; 657 } 658 659 /** 660 * skb_vlan_tagged_multi - check if skb is vlan tagged with multiple headers. 661 * @skb: skbuff to query 662 * 663 * Returns true if the skb is tagged with multiple vlan headers, regardless 664 * of whether it is hardware accelerated or not. 665 */ 666 static inline bool skb_vlan_tagged_multi(struct sk_buff *skb) 667 { 668 __be16 protocol = skb->protocol; 669 670 if (!skb_vlan_tag_present(skb)) { 671 struct vlan_ethhdr *veh; 672 673 if (likely(!eth_type_vlan(protocol))) 674 return false; 675 676 if (unlikely(!pskb_may_pull(skb, VLAN_ETH_HLEN))) 677 return false; 678 679 veh = (struct vlan_ethhdr *)skb->data; 680 protocol = veh->h_vlan_encapsulated_proto; 681 } 682 683 if (!eth_type_vlan(protocol)) 684 return false; 685 686 return true; 687 } 688 689 /** 690 * vlan_features_check - drop unsafe features for skb with multiple tags. 691 * @skb: skbuff to query 692 * @features: features to be checked 693 * 694 * Returns features without unsafe ones if the skb has multiple tags. 695 */ 696 static inline netdev_features_t vlan_features_check(struct sk_buff *skb, 697 netdev_features_t features) 698 { 699 if (skb_vlan_tagged_multi(skb)) { 700 /* In the case of multi-tagged packets, use a direct mask 701 * instead of using netdev_interesect_features(), to make 702 * sure that only devices supporting NETIF_F_HW_CSUM will 703 * have checksum offloading support. 704 */ 705 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | 706 NETIF_F_FRAGLIST | NETIF_F_HW_VLAN_CTAG_TX | 707 NETIF_F_HW_VLAN_STAG_TX; 708 } 709 710 return features; 711 } 712 713 /** 714 * compare_vlan_header - Compare two vlan headers 715 * @h1: Pointer to vlan header 716 * @h2: Pointer to vlan header 717 * 718 * Compare two vlan headers, returns 0 if equal. 719 * 720 * Please note that alignment of h1 & h2 are only guaranteed to be 16 bits. 721 */ 722 static inline unsigned long compare_vlan_header(const struct vlan_hdr *h1, 723 const struct vlan_hdr *h2) 724 { 725 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) 726 return *(u32 *)h1 ^ *(u32 *)h2; 727 #else 728 return ((__force u32)h1->h_vlan_TCI ^ (__force u32)h2->h_vlan_TCI) | 729 ((__force u32)h1->h_vlan_encapsulated_proto ^ 730 (__force u32)h2->h_vlan_encapsulated_proto); 731 #endif 732 } 733 #endif /* !(_LINUX_IF_VLAN_H_) */ 734