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 (always 0x8100) 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 #define HAVE_VLAN_PUT_TAG 247 248 /** 249 * vlan_put_tag - inserts VLAN tag according to device features 250 * @skb: skbuff to tag 251 * @vlan_tci: VLAN TCI to insert 252 * 253 * Assumes skb->dev is the target that will xmit this frame. 254 * Returns a VLAN tagged skb. 255 */ 256 static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, 257 __be16 vlan_proto, u16 vlan_tci) 258 { 259 if (vlan_hw_offload_capable(skb->dev->features, vlan_proto)) { 260 return __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci); 261 } else { 262 return __vlan_put_tag(skb, vlan_proto, vlan_tci); 263 } 264 } 265 266 /** 267 * __vlan_get_tag - get the VLAN ID that is part of the payload 268 * @skb: skbuff to query 269 * @vlan_tci: buffer to store vlaue 270 * 271 * Returns error if the skb is not of VLAN type 272 */ 273 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 274 { 275 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; 276 277 if (veth->h_vlan_proto != htons(ETH_P_8021Q) && 278 veth->h_vlan_proto != htons(ETH_P_8021AD)) 279 return -EINVAL; 280 281 *vlan_tci = ntohs(veth->h_vlan_TCI); 282 return 0; 283 } 284 285 /** 286 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] 287 * @skb: skbuff to query 288 * @vlan_tci: buffer to store vlaue 289 * 290 * Returns error if @skb->vlan_tci is not set correctly 291 */ 292 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, 293 u16 *vlan_tci) 294 { 295 if (vlan_tx_tag_present(skb)) { 296 *vlan_tci = vlan_tx_tag_get(skb); 297 return 0; 298 } else { 299 *vlan_tci = 0; 300 return -EINVAL; 301 } 302 } 303 304 #define HAVE_VLAN_GET_TAG 305 306 /** 307 * vlan_get_tag - get the VLAN ID from the skb 308 * @skb: skbuff to query 309 * @vlan_tci: buffer to store vlaue 310 * 311 * Returns error if the skb is not VLAN tagged 312 */ 313 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 314 { 315 if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) { 316 return __vlan_hwaccel_get_tag(skb, vlan_tci); 317 } else { 318 return __vlan_get_tag(skb, vlan_tci); 319 } 320 } 321 322 /** 323 * vlan_get_protocol - get protocol EtherType. 324 * @skb: skbuff to query 325 * 326 * Returns the EtherType of the packet, regardless of whether it is 327 * vlan encapsulated (normal or hardware accelerated) or not. 328 */ 329 static inline __be16 vlan_get_protocol(const struct sk_buff *skb) 330 { 331 __be16 protocol = 0; 332 333 if (vlan_tx_tag_present(skb) || 334 skb->protocol != cpu_to_be16(ETH_P_8021Q)) 335 protocol = skb->protocol; 336 else { 337 __be16 proto, *protop; 338 protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr, 339 h_vlan_encapsulated_proto), 340 sizeof(proto), &proto); 341 if (likely(protop)) 342 protocol = *protop; 343 } 344 345 return protocol; 346 } 347 348 static inline void vlan_set_encap_proto(struct sk_buff *skb, 349 struct vlan_hdr *vhdr) 350 { 351 __be16 proto; 352 unsigned short *rawp; 353 354 /* 355 * Was a VLAN packet, grab the encapsulated protocol, which the layer 356 * three protocols care about. 357 */ 358 359 proto = vhdr->h_vlan_encapsulated_proto; 360 if (ntohs(proto) >= ETH_P_802_3_MIN) { 361 skb->protocol = proto; 362 return; 363 } 364 365 rawp = (unsigned short *)(vhdr + 1); 366 if (*rawp == 0xFFFF) 367 /* 368 * This is a magic hack to spot IPX packets. Older Novell 369 * breaks the protocol design and runs IPX over 802.3 without 370 * an 802.2 LLC layer. We look for FFFF which isn't a used 371 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 372 * but does for the rest. 373 */ 374 skb->protocol = htons(ETH_P_802_3); 375 else 376 /* 377 * Real 802.2 LLC 378 */ 379 skb->protocol = htons(ETH_P_802_2); 380 } 381 #endif /* !(_LINUX_IF_VLAN_H_) */ 382