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 /** 87 * struct vlan_pcpu_stats - VLAN percpu rx/tx stats 88 * @rx_packets: number of received packets 89 * @rx_bytes: number of received bytes 90 * @rx_multicast: number of received multicast packets 91 * @tx_packets: number of transmitted packets 92 * @tx_bytes: number of transmitted bytes 93 * @syncp: synchronization point for 64bit counters 94 * @rx_errors: number of rx errors 95 * @tx_dropped: number of tx drops 96 */ 97 struct vlan_pcpu_stats { 98 u64 rx_packets; 99 u64 rx_bytes; 100 u64 rx_multicast; 101 u64 tx_packets; 102 u64 tx_bytes; 103 struct u64_stats_sync syncp; 104 u32 rx_errors; 105 u32 tx_dropped; 106 }; 107 108 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) 109 110 extern struct net_device *__vlan_find_dev_deep_rcu(struct net_device *real_dev, 111 __be16 vlan_proto, u16 vlan_id); 112 extern struct net_device *vlan_dev_real_dev(const struct net_device *dev); 113 extern u16 vlan_dev_vlan_id(const struct net_device *dev); 114 extern __be16 vlan_dev_vlan_proto(const struct net_device *dev); 115 116 /** 117 * struct vlan_priority_tci_mapping - vlan egress priority mappings 118 * @priority: skb priority 119 * @vlan_qos: vlan priority: (skb->priority << 13) & 0xE000 120 * @next: pointer to next struct 121 */ 122 struct vlan_priority_tci_mapping { 123 u32 priority; 124 u16 vlan_qos; 125 struct vlan_priority_tci_mapping *next; 126 }; 127 128 struct proc_dir_entry; 129 struct netpoll; 130 131 /** 132 * struct vlan_dev_priv - VLAN private device data 133 * @nr_ingress_mappings: number of ingress priority mappings 134 * @ingress_priority_map: ingress priority mappings 135 * @nr_egress_mappings: number of egress priority mappings 136 * @egress_priority_map: hash of egress priority mappings 137 * @vlan_proto: VLAN encapsulation protocol 138 * @vlan_id: VLAN identifier 139 * @flags: device flags 140 * @real_dev: underlying netdevice 141 * @real_dev_addr: address of underlying netdevice 142 * @dent: proc dir entry 143 * @vlan_pcpu_stats: ptr to percpu rx stats 144 */ 145 struct vlan_dev_priv { 146 unsigned int nr_ingress_mappings; 147 u32 ingress_priority_map[8]; 148 unsigned int nr_egress_mappings; 149 struct vlan_priority_tci_mapping *egress_priority_map[16]; 150 151 __be16 vlan_proto; 152 u16 vlan_id; 153 u16 flags; 154 155 struct net_device *real_dev; 156 unsigned char real_dev_addr[ETH_ALEN]; 157 158 struct proc_dir_entry *dent; 159 struct vlan_pcpu_stats __percpu *vlan_pcpu_stats; 160 #ifdef CONFIG_NET_POLL_CONTROLLER 161 struct netpoll *netpoll; 162 #endif 163 unsigned int nest_level; 164 }; 165 166 static inline struct vlan_dev_priv *vlan_dev_priv(const struct net_device *dev) 167 { 168 return netdev_priv(dev); 169 } 170 171 static inline u16 172 vlan_dev_get_egress_qos_mask(struct net_device *dev, u32 skprio) 173 { 174 struct vlan_priority_tci_mapping *mp; 175 176 smp_rmb(); /* coupled with smp_wmb() in vlan_dev_set_egress_priority() */ 177 178 mp = vlan_dev_priv(dev)->egress_priority_map[(skprio & 0xF)]; 179 while (mp) { 180 if (mp->priority == skprio) { 181 return mp->vlan_qos; /* This should already be shifted 182 * to mask correctly with the 183 * VLAN's TCI */ 184 } 185 mp = mp->next; 186 } 187 return 0; 188 } 189 190 extern bool vlan_do_receive(struct sk_buff **skb); 191 192 extern int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid); 193 extern void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid); 194 195 extern int vlan_vids_add_by_dev(struct net_device *dev, 196 const struct net_device *by_dev); 197 extern void vlan_vids_del_by_dev(struct net_device *dev, 198 const struct net_device *by_dev); 199 200 extern bool vlan_uses_dev(const struct net_device *dev); 201 202 static inline int vlan_get_encap_level(struct net_device *dev) 203 { 204 BUG_ON(!is_vlan_dev(dev)); 205 return vlan_dev_priv(dev)->nest_level; 206 } 207 #else 208 static inline struct net_device * 209 __vlan_find_dev_deep_rcu(struct net_device *real_dev, 210 __be16 vlan_proto, u16 vlan_id) 211 { 212 return NULL; 213 } 214 215 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev) 216 { 217 BUG(); 218 return NULL; 219 } 220 221 static inline u16 vlan_dev_vlan_id(const struct net_device *dev) 222 { 223 BUG(); 224 return 0; 225 } 226 227 static inline __be16 vlan_dev_vlan_proto(const struct net_device *dev) 228 { 229 BUG(); 230 return 0; 231 } 232 233 static inline u16 vlan_dev_get_egress_qos_mask(struct net_device *dev, 234 u32 skprio) 235 { 236 return 0; 237 } 238 239 static inline bool vlan_do_receive(struct sk_buff **skb) 240 { 241 return false; 242 } 243 244 static inline int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid) 245 { 246 return 0; 247 } 248 249 static inline void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid) 250 { 251 } 252 253 static inline int vlan_vids_add_by_dev(struct net_device *dev, 254 const struct net_device *by_dev) 255 { 256 return 0; 257 } 258 259 static inline void vlan_vids_del_by_dev(struct net_device *dev, 260 const struct net_device *by_dev) 261 { 262 } 263 264 static inline bool vlan_uses_dev(const struct net_device *dev) 265 { 266 return false; 267 } 268 static inline int vlan_get_encap_level(struct net_device *dev) 269 { 270 BUG(); 271 return 0; 272 } 273 #endif 274 275 /** 276 * eth_type_vlan - check for valid vlan ether type. 277 * @ethertype: ether type to check 278 * 279 * Returns true if the ether type is a vlan ether type. 280 */ 281 static inline bool eth_type_vlan(__be16 ethertype) 282 { 283 switch (ethertype) { 284 case htons(ETH_P_8021Q): 285 case htons(ETH_P_8021AD): 286 return true; 287 default: 288 return false; 289 } 290 } 291 292 static inline bool vlan_hw_offload_capable(netdev_features_t features, 293 __be16 proto) 294 { 295 if (proto == htons(ETH_P_8021Q) && features & NETIF_F_HW_VLAN_CTAG_TX) 296 return true; 297 if (proto == htons(ETH_P_8021AD) && features & NETIF_F_HW_VLAN_STAG_TX) 298 return true; 299 return false; 300 } 301 302 /** 303 * __vlan_insert_tag - regular VLAN tag inserting 304 * @skb: skbuff to tag 305 * @vlan_proto: VLAN encapsulation protocol 306 * @vlan_tci: VLAN TCI to insert 307 * 308 * Inserts the VLAN tag into @skb as part of the payload 309 * Returns error if skb_cow_head failes. 310 * 311 * Does not change skb->protocol so this function can be used during receive. 312 */ 313 static inline int __vlan_insert_tag(struct sk_buff *skb, 314 __be16 vlan_proto, u16 vlan_tci) 315 { 316 struct vlan_ethhdr *veth; 317 318 if (skb_cow_head(skb, VLAN_HLEN) < 0) 319 return -ENOMEM; 320 321 veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN); 322 323 /* Move the mac addresses to the beginning of the new header. */ 324 memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN); 325 skb->mac_header -= VLAN_HLEN; 326 327 /* first, the ethernet type */ 328 veth->h_vlan_proto = vlan_proto; 329 330 /* now, the TCI */ 331 veth->h_vlan_TCI = htons(vlan_tci); 332 333 return 0; 334 } 335 336 /** 337 * vlan_insert_tag - regular VLAN tag inserting 338 * @skb: skbuff to tag 339 * @vlan_proto: VLAN encapsulation protocol 340 * @vlan_tci: VLAN TCI to insert 341 * 342 * Inserts the VLAN tag into @skb as part of the payload 343 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 344 * 345 * Following the skb_unshare() example, in case of error, the calling function 346 * doesn't have to worry about freeing the original skb. 347 * 348 * Does not change skb->protocol so this function can be used during receive. 349 */ 350 static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, 351 __be16 vlan_proto, u16 vlan_tci) 352 { 353 int err; 354 355 err = __vlan_insert_tag(skb, vlan_proto, vlan_tci); 356 if (err) { 357 dev_kfree_skb_any(skb); 358 return NULL; 359 } 360 return skb; 361 } 362 363 /** 364 * vlan_insert_tag_set_proto - regular VLAN tag inserting 365 * @skb: skbuff to tag 366 * @vlan_proto: VLAN encapsulation protocol 367 * @vlan_tci: VLAN TCI to insert 368 * 369 * Inserts the VLAN tag into @skb as part of the payload 370 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 371 * 372 * Following the skb_unshare() example, in case of error, the calling function 373 * doesn't have to worry about freeing the original skb. 374 */ 375 static inline struct sk_buff *vlan_insert_tag_set_proto(struct sk_buff *skb, 376 __be16 vlan_proto, 377 u16 vlan_tci) 378 { 379 skb = vlan_insert_tag(skb, vlan_proto, vlan_tci); 380 if (skb) 381 skb->protocol = vlan_proto; 382 return skb; 383 } 384 385 /* 386 * __vlan_hwaccel_push_inside - pushes vlan tag to the payload 387 * @skb: skbuff to tag 388 * 389 * Pushes the VLAN tag from @skb->vlan_tci inside to the payload. 390 * 391 * Following the skb_unshare() example, in case of error, the calling function 392 * doesn't have to worry about freeing the original skb. 393 */ 394 static inline struct sk_buff *__vlan_hwaccel_push_inside(struct sk_buff *skb) 395 { 396 skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto, 397 skb_vlan_tag_get(skb)); 398 if (likely(skb)) 399 skb->vlan_tci = 0; 400 return skb; 401 } 402 /* 403 * vlan_hwaccel_push_inside - pushes vlan tag to the payload 404 * @skb: skbuff to tag 405 * 406 * Checks is tag is present in @skb->vlan_tci and if it is, it pushes the 407 * VLAN tag from @skb->vlan_tci inside to the payload. 408 * 409 * Following the skb_unshare() example, in case of error, the calling function 410 * doesn't have to worry about freeing the original skb. 411 */ 412 static inline struct sk_buff *vlan_hwaccel_push_inside(struct sk_buff *skb) 413 { 414 if (skb_vlan_tag_present(skb)) 415 skb = __vlan_hwaccel_push_inside(skb); 416 return skb; 417 } 418 419 /** 420 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting 421 * @skb: skbuff to tag 422 * @vlan_proto: VLAN encapsulation protocol 423 * @vlan_tci: VLAN TCI to insert 424 * 425 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest 426 */ 427 static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb, 428 __be16 vlan_proto, u16 vlan_tci) 429 { 430 skb->vlan_proto = vlan_proto; 431 skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci; 432 } 433 434 /** 435 * __vlan_get_tag - get the VLAN ID that is part of the payload 436 * @skb: skbuff to query 437 * @vlan_tci: buffer to store value 438 * 439 * Returns error if the skb is not of VLAN type 440 */ 441 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 442 { 443 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; 444 445 if (!eth_type_vlan(veth->h_vlan_proto)) 446 return -EINVAL; 447 448 *vlan_tci = ntohs(veth->h_vlan_TCI); 449 return 0; 450 } 451 452 /** 453 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] 454 * @skb: skbuff to query 455 * @vlan_tci: buffer to store value 456 * 457 * Returns error if @skb->vlan_tci is not set correctly 458 */ 459 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, 460 u16 *vlan_tci) 461 { 462 if (skb_vlan_tag_present(skb)) { 463 *vlan_tci = skb_vlan_tag_get(skb); 464 return 0; 465 } else { 466 *vlan_tci = 0; 467 return -EINVAL; 468 } 469 } 470 471 #define HAVE_VLAN_GET_TAG 472 473 /** 474 * vlan_get_tag - get the VLAN ID from the skb 475 * @skb: skbuff to query 476 * @vlan_tci: buffer to store value 477 * 478 * Returns error if the skb is not VLAN tagged 479 */ 480 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 481 { 482 if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) { 483 return __vlan_hwaccel_get_tag(skb, vlan_tci); 484 } else { 485 return __vlan_get_tag(skb, vlan_tci); 486 } 487 } 488 489 /** 490 * vlan_get_protocol - get protocol EtherType. 491 * @skb: skbuff to query 492 * @type: first vlan protocol 493 * @depth: buffer to store length of eth and vlan tags in bytes 494 * 495 * Returns the EtherType of the packet, regardless of whether it is 496 * vlan encapsulated (normal or hardware accelerated) or not. 497 */ 498 static inline __be16 __vlan_get_protocol(struct sk_buff *skb, __be16 type, 499 int *depth) 500 { 501 unsigned int vlan_depth = skb->mac_len; 502 503 /* if type is 802.1Q/AD then the header should already be 504 * present at mac_len - VLAN_HLEN (if mac_len > 0), or at 505 * ETH_HLEN otherwise 506 */ 507 if (eth_type_vlan(type)) { 508 if (vlan_depth) { 509 if (WARN_ON(vlan_depth < VLAN_HLEN)) 510 return 0; 511 vlan_depth -= VLAN_HLEN; 512 } else { 513 vlan_depth = ETH_HLEN; 514 } 515 do { 516 struct vlan_hdr *vh; 517 518 if (unlikely(!pskb_may_pull(skb, 519 vlan_depth + VLAN_HLEN))) 520 return 0; 521 522 vh = (struct vlan_hdr *)(skb->data + vlan_depth); 523 type = vh->h_vlan_encapsulated_proto; 524 vlan_depth += VLAN_HLEN; 525 } while (eth_type_vlan(type)); 526 } 527 528 if (depth) 529 *depth = vlan_depth; 530 531 return type; 532 } 533 534 /** 535 * vlan_get_protocol - get protocol EtherType. 536 * @skb: skbuff to query 537 * 538 * Returns the EtherType of the packet, regardless of whether it is 539 * vlan encapsulated (normal or hardware accelerated) or not. 540 */ 541 static inline __be16 vlan_get_protocol(struct sk_buff *skb) 542 { 543 return __vlan_get_protocol(skb, skb->protocol, NULL); 544 } 545 546 static inline void vlan_set_encap_proto(struct sk_buff *skb, 547 struct vlan_hdr *vhdr) 548 { 549 __be16 proto; 550 unsigned short *rawp; 551 552 /* 553 * Was a VLAN packet, grab the encapsulated protocol, which the layer 554 * three protocols care about. 555 */ 556 557 proto = vhdr->h_vlan_encapsulated_proto; 558 if (eth_proto_is_802_3(proto)) { 559 skb->protocol = proto; 560 return; 561 } 562 563 rawp = (unsigned short *)(vhdr + 1); 564 if (*rawp == 0xFFFF) 565 /* 566 * This is a magic hack to spot IPX packets. Older Novell 567 * breaks the protocol design and runs IPX over 802.3 without 568 * an 802.2 LLC layer. We look for FFFF which isn't a used 569 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 570 * but does for the rest. 571 */ 572 skb->protocol = htons(ETH_P_802_3); 573 else 574 /* 575 * Real 802.2 LLC 576 */ 577 skb->protocol = htons(ETH_P_802_2); 578 } 579 580 /** 581 * skb_vlan_tagged - check if skb is vlan tagged. 582 * @skb: skbuff to query 583 * 584 * Returns true if the skb is tagged, regardless of whether it is hardware 585 * accelerated or not. 586 */ 587 static inline bool skb_vlan_tagged(const struct sk_buff *skb) 588 { 589 if (!skb_vlan_tag_present(skb) && 590 likely(!eth_type_vlan(skb->protocol))) 591 return false; 592 593 return true; 594 } 595 596 /** 597 * skb_vlan_tagged_multi - check if skb is vlan tagged with multiple headers. 598 * @skb: skbuff to query 599 * 600 * Returns true if the skb is tagged with multiple vlan headers, regardless 601 * of whether it is hardware accelerated or not. 602 */ 603 static inline bool skb_vlan_tagged_multi(const struct sk_buff *skb) 604 { 605 __be16 protocol = skb->protocol; 606 607 if (!skb_vlan_tag_present(skb)) { 608 struct vlan_ethhdr *veh; 609 610 if (likely(!eth_type_vlan(protocol))) 611 return false; 612 613 veh = (struct vlan_ethhdr *)skb->data; 614 protocol = veh->h_vlan_encapsulated_proto; 615 } 616 617 if (!eth_type_vlan(protocol)) 618 return false; 619 620 return true; 621 } 622 623 /** 624 * vlan_features_check - drop unsafe features for skb with multiple tags. 625 * @skb: skbuff to query 626 * @features: features to be checked 627 * 628 * Returns features without unsafe ones if the skb has multiple tags. 629 */ 630 static inline netdev_features_t vlan_features_check(const struct sk_buff *skb, 631 netdev_features_t features) 632 { 633 if (skb_vlan_tagged_multi(skb)) 634 features = netdev_intersect_features(features, 635 NETIF_F_SG | 636 NETIF_F_HIGHDMA | 637 NETIF_F_FRAGLIST | 638 NETIF_F_HW_CSUM | 639 NETIF_F_HW_VLAN_CTAG_TX | 640 NETIF_F_HW_VLAN_STAG_TX); 641 642 return features; 643 } 644 645 /** 646 * compare_vlan_header - Compare two vlan headers 647 * @h1: Pointer to vlan header 648 * @h2: Pointer to vlan header 649 * 650 * Compare two vlan headers, returns 0 if equal. 651 * 652 * Please note that alignment of h1 & h2 are only guaranteed to be 16 bits. 653 */ 654 static inline unsigned long compare_vlan_header(const struct vlan_hdr *h1, 655 const struct vlan_hdr *h2) 656 { 657 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) 658 return *(u32 *)h1 ^ *(u32 *)h2; 659 #else 660 return ((__force u32)h1->h_vlan_TCI ^ (__force u32)h2->h_vlan_TCI) | 661 ((__force u32)h1->h_vlan_encapsulated_proto ^ 662 (__force u32)h2->h_vlan_encapsulated_proto); 663 #endif 664 } 665 #endif /* !(_LINUX_IF_VLAN_H_) */ 666