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