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 int is_vlan_dev(struct net_device *dev) 77 { 78 return dev->priv_flags & IFF_802_1Q_VLAN; 79 } 80 81 #define vlan_tx_tag_present(__skb) ((__skb)->vlan_tci & VLAN_TAG_PRESENT) 82 #define vlan_tx_nonzero_tag_present(__skb) \ 83 (vlan_tx_tag_present(__skb) && ((__skb)->vlan_tci & VLAN_VID_MASK)) 84 #define vlan_tx_tag_get(__skb) ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT) 85 86 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) 87 88 extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev, 89 __be16 vlan_proto, u16 vlan_id); 90 extern struct net_device *vlan_dev_real_dev(const struct net_device *dev); 91 extern u16 vlan_dev_vlan_id(const struct net_device *dev); 92 93 extern bool vlan_do_receive(struct sk_buff **skb); 94 extern struct sk_buff *vlan_untag(struct sk_buff *skb); 95 96 extern int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid); 97 extern void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid); 98 99 extern int vlan_vids_add_by_dev(struct net_device *dev, 100 const struct net_device *by_dev); 101 extern void vlan_vids_del_by_dev(struct net_device *dev, 102 const struct net_device *by_dev); 103 104 extern bool vlan_uses_dev(const struct net_device *dev); 105 #else 106 static inline struct net_device * 107 __vlan_find_dev_deep(struct net_device *real_dev, 108 __be16 vlan_proto, u16 vlan_id) 109 { 110 return NULL; 111 } 112 113 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev) 114 { 115 BUG(); 116 return NULL; 117 } 118 119 static inline u16 vlan_dev_vlan_id(const struct net_device *dev) 120 { 121 BUG(); 122 return 0; 123 } 124 125 static inline bool vlan_do_receive(struct sk_buff **skb) 126 { 127 return false; 128 } 129 130 static inline struct sk_buff *vlan_untag(struct sk_buff *skb) 131 { 132 return skb; 133 } 134 135 static inline int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid) 136 { 137 return 0; 138 } 139 140 static inline void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid) 141 { 142 } 143 144 static inline int vlan_vids_add_by_dev(struct net_device *dev, 145 const struct net_device *by_dev) 146 { 147 return 0; 148 } 149 150 static inline void vlan_vids_del_by_dev(struct net_device *dev, 151 const struct net_device *by_dev) 152 { 153 } 154 155 static inline bool vlan_uses_dev(const struct net_device *dev) 156 { 157 return false; 158 } 159 #endif 160 161 static inline bool vlan_hw_offload_capable(netdev_features_t features, 162 __be16 proto) 163 { 164 if (proto == htons(ETH_P_8021Q) && features & NETIF_F_HW_VLAN_CTAG_TX) 165 return true; 166 if (proto == htons(ETH_P_8021AD) && features & NETIF_F_HW_VLAN_STAG_TX) 167 return true; 168 return false; 169 } 170 171 /** 172 * vlan_insert_tag - regular VLAN tag inserting 173 * @skb: skbuff to tag 174 * @vlan_proto: VLAN encapsulation protocol 175 * @vlan_tci: VLAN TCI to insert 176 * 177 * Inserts the VLAN tag into @skb as part of the payload 178 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 179 * 180 * Following the skb_unshare() example, in case of error, the calling function 181 * doesn't have to worry about freeing the original skb. 182 * 183 * Does not change skb->protocol so this function can be used during receive. 184 */ 185 static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, 186 __be16 vlan_proto, u16 vlan_tci) 187 { 188 struct vlan_ethhdr *veth; 189 190 if (skb_cow_head(skb, VLAN_HLEN) < 0) { 191 kfree_skb(skb); 192 return NULL; 193 } 194 veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN); 195 196 /* Move the mac addresses to the beginning of the new header. */ 197 memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN); 198 skb->mac_header -= VLAN_HLEN; 199 200 /* first, the ethernet type */ 201 veth->h_vlan_proto = vlan_proto; 202 203 /* now, the TCI */ 204 veth->h_vlan_TCI = htons(vlan_tci); 205 206 return skb; 207 } 208 209 /** 210 * __vlan_put_tag - regular VLAN tag inserting 211 * @skb: skbuff to tag 212 * @vlan_tci: VLAN TCI to insert 213 * 214 * Inserts the VLAN tag into @skb as part of the payload 215 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 216 * 217 * Following the skb_unshare() example, in case of error, the calling function 218 * doesn't have to worry about freeing the original skb. 219 */ 220 static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, 221 __be16 vlan_proto, u16 vlan_tci) 222 { 223 skb = vlan_insert_tag(skb, vlan_proto, vlan_tci); 224 if (skb) 225 skb->protocol = vlan_proto; 226 return skb; 227 } 228 229 /** 230 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting 231 * @skb: skbuff to tag 232 * @vlan_proto: VLAN encapsulation protocol 233 * @vlan_tci: VLAN TCI to insert 234 * 235 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest 236 */ 237 static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb, 238 __be16 vlan_proto, 239 u16 vlan_tci) 240 { 241 skb->vlan_proto = vlan_proto; 242 skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci; 243 return skb; 244 } 245 246 /** 247 * vlan_put_tag - inserts VLAN tag according to device features 248 * @skb: skbuff to tag 249 * @vlan_tci: VLAN TCI to insert 250 * 251 * Assumes skb->dev is the target that will xmit this frame. 252 * Returns a VLAN tagged skb. 253 */ 254 static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, 255 __be16 vlan_proto, u16 vlan_tci) 256 { 257 if (vlan_hw_offload_capable(skb->dev->features, vlan_proto)) { 258 return __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci); 259 } else { 260 return __vlan_put_tag(skb, vlan_proto, vlan_tci); 261 } 262 } 263 264 /** 265 * __vlan_get_tag - get the VLAN ID that is part of the payload 266 * @skb: skbuff to query 267 * @vlan_tci: buffer to store vlaue 268 * 269 * Returns error if the skb is not of VLAN type 270 */ 271 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 272 { 273 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; 274 275 if (veth->h_vlan_proto != htons(ETH_P_8021Q) && 276 veth->h_vlan_proto != htons(ETH_P_8021AD)) 277 return -EINVAL; 278 279 *vlan_tci = ntohs(veth->h_vlan_TCI); 280 return 0; 281 } 282 283 /** 284 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] 285 * @skb: skbuff to query 286 * @vlan_tci: buffer to store vlaue 287 * 288 * Returns error if @skb->vlan_tci is not set correctly 289 */ 290 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, 291 u16 *vlan_tci) 292 { 293 if (vlan_tx_tag_present(skb)) { 294 *vlan_tci = vlan_tx_tag_get(skb); 295 return 0; 296 } else { 297 *vlan_tci = 0; 298 return -EINVAL; 299 } 300 } 301 302 #define HAVE_VLAN_GET_TAG 303 304 /** 305 * vlan_get_tag - get the VLAN ID from the skb 306 * @skb: skbuff to query 307 * @vlan_tci: buffer to store vlaue 308 * 309 * Returns error if the skb is not VLAN tagged 310 */ 311 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 312 { 313 if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) { 314 return __vlan_hwaccel_get_tag(skb, vlan_tci); 315 } else { 316 return __vlan_get_tag(skb, vlan_tci); 317 } 318 } 319 320 /** 321 * vlan_get_protocol - get protocol EtherType. 322 * @skb: skbuff to query 323 * 324 * Returns the EtherType of the packet, regardless of whether it is 325 * vlan encapsulated (normal or hardware accelerated) or not. 326 */ 327 static inline __be16 vlan_get_protocol(const struct sk_buff *skb) 328 { 329 __be16 protocol = 0; 330 331 if (vlan_tx_tag_present(skb) || 332 skb->protocol != cpu_to_be16(ETH_P_8021Q)) 333 protocol = skb->protocol; 334 else { 335 __be16 proto, *protop; 336 protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr, 337 h_vlan_encapsulated_proto), 338 sizeof(proto), &proto); 339 if (likely(protop)) 340 protocol = *protop; 341 } 342 343 return protocol; 344 } 345 346 static inline void vlan_set_encap_proto(struct sk_buff *skb, 347 struct vlan_hdr *vhdr) 348 { 349 __be16 proto; 350 unsigned short *rawp; 351 352 /* 353 * Was a VLAN packet, grab the encapsulated protocol, which the layer 354 * three protocols care about. 355 */ 356 357 proto = vhdr->h_vlan_encapsulated_proto; 358 if (ntohs(proto) >= ETH_P_802_3_MIN) { 359 skb->protocol = proto; 360 return; 361 } 362 363 rawp = (unsigned short *)(vhdr + 1); 364 if (*rawp == 0xFFFF) 365 /* 366 * This is a magic hack to spot IPX packets. Older Novell 367 * breaks the protocol design and runs IPX over 802.3 without 368 * an 802.2 LLC layer. We look for FFFF which isn't a used 369 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 370 * but does for the rest. 371 */ 372 skb->protocol = htons(ETH_P_802_3); 373 else 374 /* 375 * Real 802.2 LLC 376 */ 377 skb->protocol = htons(ETH_P_802_2); 378 } 379 #endif /* !(_LINUX_IF_VLAN_H_) */ 380