|
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 |
|
13 #ifndef _LINUX_IF_VLAN_H_ |
|
14 #define _LINUX_IF_VLAN_H_ |
|
15 |
|
16 #ifdef __KERNEL__ |
|
17 #include <linux/netdevice.h> |
|
18 #include <linux/etherdevice.h> |
|
19 |
|
20 #define VLAN_HLEN 4 /* The additional bytes (on top of the Ethernet header) |
|
21 * that VLAN requires. |
|
22 */ |
|
23 #define VLAN_ETH_ALEN 6 /* Octets in one ethernet addr */ |
|
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_VID_MASK 0xfff |
|
67 |
|
68 /* found in socket.c */ |
|
69 extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *)); |
|
70 |
|
71 /* if this changes, algorithm will have to be reworked because this |
|
72 * depends on completely exhausting the VLAN identifier space. Thus |
|
73 * it gives constant time look-up, but in many cases it wastes memory. |
|
74 */ |
|
75 #define VLAN_GROUP_ARRAY_LEN 4096 |
|
76 #define VLAN_GROUP_ARRAY_SPLIT_PARTS 8 |
|
77 #define VLAN_GROUP_ARRAY_PART_LEN (VLAN_GROUP_ARRAY_LEN/VLAN_GROUP_ARRAY_SPLIT_PARTS) |
|
78 |
|
79 struct vlan_group { |
|
80 struct net_device *real_dev; /* The ethernet(like) device |
|
81 * the vlan is attached to. |
|
82 */ |
|
83 unsigned int nr_vlans; |
|
84 struct hlist_node hlist; /* linked list */ |
|
85 struct net_device **vlan_devices_arrays[VLAN_GROUP_ARRAY_SPLIT_PARTS]; |
|
86 struct rcu_head rcu; |
|
87 }; |
|
88 |
|
89 static inline struct net_device *vlan_group_get_device(struct vlan_group *vg, |
|
90 u16 vlan_id) |
|
91 { |
|
92 struct net_device **array; |
|
93 array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN]; |
|
94 return array ? array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] : NULL; |
|
95 } |
|
96 |
|
97 static inline void vlan_group_set_device(struct vlan_group *vg, |
|
98 u16 vlan_id, |
|
99 struct net_device *dev) |
|
100 { |
|
101 struct net_device **array; |
|
102 if (!vg) |
|
103 return; |
|
104 array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN]; |
|
105 array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] = dev; |
|
106 } |
|
107 |
|
108 #define vlan_tx_tag_present(__skb) ((__skb)->vlan_tci) |
|
109 #define vlan_tx_tag_get(__skb) ((__skb)->vlan_tci) |
|
110 |
|
111 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) |
|
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 |
|
115 extern int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp, |
|
116 u16 vlan_tci, int polling); |
|
117 extern int vlan_hwaccel_do_receive(struct sk_buff *skb); |
|
118 |
|
119 #else |
|
120 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev) |
|
121 { |
|
122 BUG(); |
|
123 return NULL; |
|
124 } |
|
125 |
|
126 static inline u16 vlan_dev_vlan_id(const struct net_device *dev) |
|
127 { |
|
128 BUG(); |
|
129 return 0; |
|
130 } |
|
131 |
|
132 static inline int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp, |
|
133 u16 vlan_tci, int polling) |
|
134 { |
|
135 BUG(); |
|
136 return NET_XMIT_SUCCESS; |
|
137 } |
|
138 |
|
139 static inline int vlan_hwaccel_do_receive(struct sk_buff *skb) |
|
140 { |
|
141 return 0; |
|
142 } |
|
143 #endif |
|
144 |
|
145 /** |
|
146 * vlan_hwaccel_rx - netif_rx wrapper for VLAN RX acceleration |
|
147 * @skb: buffer |
|
148 * @grp: vlan group |
|
149 * @vlan_tci: VLAN TCI as received from the card |
|
150 */ |
|
151 static inline int vlan_hwaccel_rx(struct sk_buff *skb, |
|
152 struct vlan_group *grp, |
|
153 u16 vlan_tci) |
|
154 { |
|
155 return __vlan_hwaccel_rx(skb, grp, vlan_tci, 0); |
|
156 } |
|
157 |
|
158 /** |
|
159 * vlan_hwaccel_receive_skb - netif_receive_skb wrapper for VLAN RX acceleration |
|
160 * @skb: buffer |
|
161 * @grp: vlan group |
|
162 * @vlan_tci: VLAN TCI as received from the card |
|
163 */ |
|
164 static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb, |
|
165 struct vlan_group *grp, |
|
166 u16 vlan_tci) |
|
167 { |
|
168 return __vlan_hwaccel_rx(skb, grp, vlan_tci, 1); |
|
169 } |
|
170 |
|
171 /** |
|
172 * __vlan_put_tag - regular VLAN tag inserting |
|
173 * @skb: skbuff to tag |
|
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 static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci) |
|
183 { |
|
184 struct vlan_ethhdr *veth; |
|
185 |
|
186 if (skb_cow_head(skb, VLAN_HLEN) < 0) { |
|
187 kfree_skb(skb); |
|
188 return NULL; |
|
189 } |
|
190 veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN); |
|
191 |
|
192 /* Move the mac addresses to the beginning of the new header. */ |
|
193 memmove(skb->data, skb->data + VLAN_HLEN, 2 * VLAN_ETH_ALEN); |
|
194 |
|
195 /* first, the ethernet type */ |
|
196 veth->h_vlan_proto = htons(ETH_P_8021Q); |
|
197 |
|
198 /* now, the TCI */ |
|
199 veth->h_vlan_TCI = htons(vlan_tci); |
|
200 |
|
201 skb->protocol = htons(ETH_P_8021Q); |
|
202 |
|
203 return skb; |
|
204 } |
|
205 |
|
206 /** |
|
207 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting |
|
208 * @skb: skbuff to tag |
|
209 * @vlan_tci: VLAN TCI to insert |
|
210 * |
|
211 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest |
|
212 */ |
|
213 static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb, |
|
214 u16 vlan_tci) |
|
215 { |
|
216 skb->vlan_tci = vlan_tci; |
|
217 return skb; |
|
218 } |
|
219 |
|
220 #define HAVE_VLAN_PUT_TAG |
|
221 |
|
222 /** |
|
223 * vlan_put_tag - inserts VLAN tag according to device features |
|
224 * @skb: skbuff to tag |
|
225 * @vlan_tci: VLAN TCI to insert |
|
226 * |
|
227 * Assumes skb->dev is the target that will xmit this frame. |
|
228 * Returns a VLAN tagged skb. |
|
229 */ |
|
230 static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, u16 vlan_tci) |
|
231 { |
|
232 if (skb->dev->features & NETIF_F_HW_VLAN_TX) { |
|
233 return __vlan_hwaccel_put_tag(skb, vlan_tci); |
|
234 } else { |
|
235 return __vlan_put_tag(skb, vlan_tci); |
|
236 } |
|
237 } |
|
238 |
|
239 /** |
|
240 * __vlan_get_tag - get the VLAN ID that is part of the payload |
|
241 * @skb: skbuff to query |
|
242 * @vlan_tci: buffer to store vlaue |
|
243 * |
|
244 * Returns error if the skb is not of VLAN type |
|
245 */ |
|
246 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) |
|
247 { |
|
248 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; |
|
249 |
|
250 if (veth->h_vlan_proto != htons(ETH_P_8021Q)) { |
|
251 return -EINVAL; |
|
252 } |
|
253 |
|
254 *vlan_tci = ntohs(veth->h_vlan_TCI); |
|
255 return 0; |
|
256 } |
|
257 |
|
258 /** |
|
259 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] |
|
260 * @skb: skbuff to query |
|
261 * @vlan_tci: buffer to store vlaue |
|
262 * |
|
263 * Returns error if @skb->vlan_tci is not set correctly |
|
264 */ |
|
265 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, |
|
266 u16 *vlan_tci) |
|
267 { |
|
268 if (vlan_tx_tag_present(skb)) { |
|
269 *vlan_tci = skb->vlan_tci; |
|
270 return 0; |
|
271 } else { |
|
272 *vlan_tci = 0; |
|
273 return -EINVAL; |
|
274 } |
|
275 } |
|
276 |
|
277 #define HAVE_VLAN_GET_TAG |
|
278 |
|
279 /** |
|
280 * vlan_get_tag - get the VLAN ID from the skb |
|
281 * @skb: skbuff to query |
|
282 * @vlan_tci: buffer to store vlaue |
|
283 * |
|
284 * Returns error if the skb is not VLAN tagged |
|
285 */ |
|
286 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) |
|
287 { |
|
288 if (skb->dev->features & NETIF_F_HW_VLAN_TX) { |
|
289 return __vlan_hwaccel_get_tag(skb, vlan_tci); |
|
290 } else { |
|
291 return __vlan_get_tag(skb, vlan_tci); |
|
292 } |
|
293 } |
|
294 |
|
295 #endif /* __KERNEL__ */ |
|
296 |
|
297 /* VLAN IOCTLs are found in sockios.h */ |
|
298 |
|
299 /* Passed in vlan_ioctl_args structure to determine behaviour. */ |
|
300 enum vlan_ioctl_cmds { |
|
301 ADD_VLAN_CMD, |
|
302 DEL_VLAN_CMD, |
|
303 SET_VLAN_INGRESS_PRIORITY_CMD, |
|
304 SET_VLAN_EGRESS_PRIORITY_CMD, |
|
305 GET_VLAN_INGRESS_PRIORITY_CMD, |
|
306 GET_VLAN_EGRESS_PRIORITY_CMD, |
|
307 SET_VLAN_NAME_TYPE_CMD, |
|
308 SET_VLAN_FLAG_CMD, |
|
309 GET_VLAN_REALDEV_NAME_CMD, /* If this works, you know it's a VLAN device, btw */ |
|
310 GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */ |
|
311 }; |
|
312 |
|
313 enum vlan_flags { |
|
314 VLAN_FLAG_REORDER_HDR = 0x1, |
|
315 VLAN_FLAG_GVRP = 0x2, |
|
316 }; |
|
317 |
|
318 enum vlan_name_types { |
|
319 VLAN_NAME_TYPE_PLUS_VID, /* Name will look like: vlan0005 */ |
|
320 VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like: eth1.0005 */ |
|
321 VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like: vlan5 */ |
|
322 VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like: eth0.5 */ |
|
323 VLAN_NAME_TYPE_HIGHEST |
|
324 }; |
|
325 |
|
326 struct vlan_ioctl_args { |
|
327 int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */ |
|
328 char device1[24]; |
|
329 |
|
330 union { |
|
331 char device2[24]; |
|
332 int VID; |
|
333 unsigned int skb_priority; |
|
334 unsigned int name_type; |
|
335 unsigned int bind_type; |
|
336 unsigned int flag; /* Matches vlan_dev_info flags */ |
|
337 } u; |
|
338 |
|
339 short vlan_qos; |
|
340 }; |
|
341 |
|
342 #endif /* !(_LINUX_IF_VLAN_H_) */ |