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 = 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 /** 404 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting 405 * @skb: skbuff to tag 406 * @vlan_proto: VLAN encapsulation protocol 407 * @vlan_tci: VLAN TCI to insert 408 * 409 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest 410 */ 411 static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb, 412 __be16 vlan_proto, u16 vlan_tci) 413 { 414 skb->vlan_proto = vlan_proto; 415 skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci; 416 } 417 418 /** 419 * __vlan_get_tag - get the VLAN ID that is part of the payload 420 * @skb: skbuff to query 421 * @vlan_tci: buffer to store value 422 * 423 * Returns error if the skb is not of VLAN type 424 */ 425 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 426 { 427 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; 428 429 if (!eth_type_vlan(veth->h_vlan_proto)) 430 return -EINVAL; 431 432 *vlan_tci = ntohs(veth->h_vlan_TCI); 433 return 0; 434 } 435 436 /** 437 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] 438 * @skb: skbuff to query 439 * @vlan_tci: buffer to store value 440 * 441 * Returns error if @skb->vlan_tci is not set correctly 442 */ 443 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, 444 u16 *vlan_tci) 445 { 446 if (skb_vlan_tag_present(skb)) { 447 *vlan_tci = skb_vlan_tag_get(skb); 448 return 0; 449 } else { 450 *vlan_tci = 0; 451 return -EINVAL; 452 } 453 } 454 455 #define HAVE_VLAN_GET_TAG 456 457 /** 458 * vlan_get_tag - get the VLAN ID from the skb 459 * @skb: skbuff to query 460 * @vlan_tci: buffer to store value 461 * 462 * Returns error if the skb is not VLAN tagged 463 */ 464 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 465 { 466 if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) { 467 return __vlan_hwaccel_get_tag(skb, vlan_tci); 468 } else { 469 return __vlan_get_tag(skb, vlan_tci); 470 } 471 } 472 473 /** 474 * vlan_get_protocol - get protocol EtherType. 475 * @skb: skbuff to query 476 * @type: first vlan protocol 477 * @depth: buffer to store length of eth and vlan tags in bytes 478 * 479 * Returns the EtherType of the packet, regardless of whether it is 480 * vlan encapsulated (normal or hardware accelerated) or not. 481 */ 482 static inline __be16 __vlan_get_protocol(struct sk_buff *skb, __be16 type, 483 int *depth) 484 { 485 unsigned int vlan_depth = skb->mac_len; 486 487 /* if type is 802.1Q/AD then the header should already be 488 * present at mac_len - VLAN_HLEN (if mac_len > 0), or at 489 * ETH_HLEN otherwise 490 */ 491 if (eth_type_vlan(type)) { 492 if (vlan_depth) { 493 if (WARN_ON(vlan_depth < VLAN_HLEN)) 494 return 0; 495 vlan_depth -= VLAN_HLEN; 496 } else { 497 vlan_depth = ETH_HLEN; 498 } 499 do { 500 struct vlan_hdr *vh; 501 502 if (unlikely(!pskb_may_pull(skb, 503 vlan_depth + VLAN_HLEN))) 504 return 0; 505 506 vh = (struct vlan_hdr *)(skb->data + vlan_depth); 507 type = vh->h_vlan_encapsulated_proto; 508 vlan_depth += VLAN_HLEN; 509 } while (eth_type_vlan(type)); 510 } 511 512 if (depth) 513 *depth = vlan_depth; 514 515 return type; 516 } 517 518 /** 519 * vlan_get_protocol - get protocol EtherType. 520 * @skb: skbuff to query 521 * 522 * Returns the EtherType of the packet, regardless of whether it is 523 * vlan encapsulated (normal or hardware accelerated) or not. 524 */ 525 static inline __be16 vlan_get_protocol(struct sk_buff *skb) 526 { 527 return __vlan_get_protocol(skb, skb->protocol, NULL); 528 } 529 530 static inline void vlan_set_encap_proto(struct sk_buff *skb, 531 struct vlan_hdr *vhdr) 532 { 533 __be16 proto; 534 unsigned short *rawp; 535 536 /* 537 * Was a VLAN packet, grab the encapsulated protocol, which the layer 538 * three protocols care about. 539 */ 540 541 proto = vhdr->h_vlan_encapsulated_proto; 542 if (eth_proto_is_802_3(proto)) { 543 skb->protocol = proto; 544 return; 545 } 546 547 rawp = (unsigned short *)(vhdr + 1); 548 if (*rawp == 0xFFFF) 549 /* 550 * This is a magic hack to spot IPX packets. Older Novell 551 * breaks the protocol design and runs IPX over 802.3 without 552 * an 802.2 LLC layer. We look for FFFF which isn't a used 553 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 554 * but does for the rest. 555 */ 556 skb->protocol = htons(ETH_P_802_3); 557 else 558 /* 559 * Real 802.2 LLC 560 */ 561 skb->protocol = htons(ETH_P_802_2); 562 } 563 564 /** 565 * skb_vlan_tagged - check if skb is vlan tagged. 566 * @skb: skbuff to query 567 * 568 * Returns true if the skb is tagged, regardless of whether it is hardware 569 * accelerated or not. 570 */ 571 static inline bool skb_vlan_tagged(const struct sk_buff *skb) 572 { 573 if (!skb_vlan_tag_present(skb) && 574 likely(!eth_type_vlan(skb->protocol))) 575 return false; 576 577 return true; 578 } 579 580 /** 581 * skb_vlan_tagged_multi - check if skb is vlan tagged with multiple headers. 582 * @skb: skbuff to query 583 * 584 * Returns true if the skb is tagged with multiple vlan headers, regardless 585 * of whether it is hardware accelerated or not. 586 */ 587 static inline bool skb_vlan_tagged_multi(const struct sk_buff *skb) 588 { 589 __be16 protocol = skb->protocol; 590 591 if (!skb_vlan_tag_present(skb)) { 592 struct vlan_ethhdr *veh; 593 594 if (likely(!eth_type_vlan(protocol))) 595 return false; 596 597 veh = (struct vlan_ethhdr *)skb->data; 598 protocol = veh->h_vlan_encapsulated_proto; 599 } 600 601 if (!eth_type_vlan(protocol)) 602 return false; 603 604 return true; 605 } 606 607 /** 608 * vlan_features_check - drop unsafe features for skb with multiple tags. 609 * @skb: skbuff to query 610 * @features: features to be checked 611 * 612 * Returns features without unsafe ones if the skb has multiple tags. 613 */ 614 static inline netdev_features_t vlan_features_check(const struct sk_buff *skb, 615 netdev_features_t features) 616 { 617 if (skb_vlan_tagged_multi(skb)) { 618 /* In the case of multi-tagged packets, use a direct mask 619 * instead of using netdev_interesect_features(), to make 620 * sure that only devices supporting NETIF_F_HW_CSUM will 621 * have checksum offloading support. 622 */ 623 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | 624 NETIF_F_FRAGLIST | NETIF_F_HW_VLAN_CTAG_TX | 625 NETIF_F_HW_VLAN_STAG_TX; 626 } 627 628 return features; 629 } 630 631 /** 632 * compare_vlan_header - Compare two vlan headers 633 * @h1: Pointer to vlan header 634 * @h2: Pointer to vlan header 635 * 636 * Compare two vlan headers, returns 0 if equal. 637 * 638 * Please note that alignment of h1 & h2 are only guaranteed to be 16 bits. 639 */ 640 static inline unsigned long compare_vlan_header(const struct vlan_hdr *h1, 641 const struct vlan_hdr *h2) 642 { 643 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) 644 return *(u32 *)h1 ^ *(u32 *)h2; 645 #else 646 return ((__force u32)h1->h_vlan_TCI ^ (__force u32)h2->h_vlan_TCI) | 647 ((__force u32)h1->h_vlan_encapsulated_proto ^ 648 (__force u32)h2->h_vlan_encapsulated_proto); 649 #endif 650 } 651 #endif /* !(_LINUX_IF_VLAN_H_) */ 652