vlan: introduce vid list with reference counting
[linux-2.6.git] / include / linux / if_vlan.h
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 #include <linux/rtnetlink.h>
20
21 #define VLAN_HLEN       4               /* The additional bytes (on top of the Ethernet header)
22                                          * that VLAN requires.
23                                          */
24 #define VLAN_ETH_ALEN   6               /* Octets in one ethernet addr   */
25 #define VLAN_ETH_HLEN   18              /* Total octets in header.       */
26 #define VLAN_ETH_ZLEN   64              /* Min. octets in frame sans FCS */
27
28 /*
29  * According to 802.3ac, the packet can be 4 bytes longer. --Klika Jan
30  */
31 #define VLAN_ETH_DATA_LEN       1500    /* Max. octets in payload        */
32 #define VLAN_ETH_FRAME_LEN      1518    /* Max. octets in frame sans FCS */
33
34 /*
35  *      struct vlan_hdr - vlan header
36  *      @h_vlan_TCI: priority and VLAN ID
37  *      @h_vlan_encapsulated_proto: packet type ID or len
38  */
39 struct vlan_hdr {
40         __be16  h_vlan_TCI;
41         __be16  h_vlan_encapsulated_proto;
42 };
43
44 /**
45  *      struct vlan_ethhdr - vlan ethernet header (ethhdr + vlan_hdr)
46  *      @h_dest: destination ethernet address
47  *      @h_source: source ethernet address
48  *      @h_vlan_proto: ethernet protocol (always 0x8100)
49  *      @h_vlan_TCI: priority and VLAN ID
50  *      @h_vlan_encapsulated_proto: packet type ID or len
51  */
52 struct vlan_ethhdr {
53         unsigned char   h_dest[ETH_ALEN];
54         unsigned char   h_source[ETH_ALEN];
55         __be16          h_vlan_proto;
56         __be16          h_vlan_TCI;
57         __be16          h_vlan_encapsulated_proto;
58 };
59
60 #include <linux/skbuff.h>
61
62 static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
63 {
64         return (struct vlan_ethhdr *)skb_mac_header(skb);
65 }
66
67 #define VLAN_PRIO_MASK          0xe000 /* Priority Code Point */
68 #define VLAN_PRIO_SHIFT         13
69 #define VLAN_CFI_MASK           0x1000 /* Canonical Format Indicator */
70 #define VLAN_TAG_PRESENT        VLAN_CFI_MASK
71 #define VLAN_VID_MASK           0x0fff /* VLAN Identifier */
72 #define VLAN_N_VID              4096
73
74 /* found in socket.c */
75 extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *));
76
77 struct vlan_info;
78
79 static inline int is_vlan_dev(struct net_device *dev)
80 {
81         return dev->priv_flags & IFF_802_1Q_VLAN;
82 }
83
84 #define vlan_tx_tag_present(__skb)      ((__skb)->vlan_tci & VLAN_TAG_PRESENT)
85 #define vlan_tx_tag_get(__skb)          ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT)
86
87 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
88
89 extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev,
90                                                u16 vlan_id);
91 extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
92 extern u16 vlan_dev_vlan_id(const struct net_device *dev);
93
94 extern bool vlan_do_receive(struct sk_buff **skb, bool last_handler);
95 extern struct sk_buff *vlan_untag(struct sk_buff *skb);
96
97 extern int vlan_vid_add(struct net_device *dev, unsigned short vid);
98 extern void vlan_vid_del(struct net_device *dev, unsigned short vid);
99
100 #else
101 static inline struct net_device *
102 __vlan_find_dev_deep(struct net_device *real_dev, u16 vlan_id)
103 {
104         return NULL;
105 }
106
107 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev)
108 {
109         BUG();
110         return NULL;
111 }
112
113 static inline u16 vlan_dev_vlan_id(const struct net_device *dev)
114 {
115         BUG();
116         return 0;
117 }
118
119 static inline bool vlan_do_receive(struct sk_buff **skb, bool last_handler)
120 {
121         if (((*skb)->vlan_tci & VLAN_VID_MASK) && last_handler)
122                 (*skb)->pkt_type = PACKET_OTHERHOST;
123         return false;
124 }
125
126 static inline struct sk_buff *vlan_untag(struct sk_buff *skb)
127 {
128         return skb;
129 }
130
131 static inline int vlan_vid_add(struct net_device *dev, unsigned short vid)
132 {
133         return 0;
134 }
135
136 static inline void vlan_vid_del(struct net_device *dev, unsigned short vid)
137 {
138 }
139 #endif
140
141 /**
142  * vlan_insert_tag - regular VLAN tag inserting
143  * @skb: skbuff to tag
144  * @vlan_tci: VLAN TCI to insert
145  *
146  * Inserts the VLAN tag into @skb as part of the payload
147  * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
148  *
149  * Following the skb_unshare() example, in case of error, the calling function
150  * doesn't have to worry about freeing the original skb.
151  *
152  * Does not change skb->protocol so this function can be used during receive.
153  */
154 static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, u16 vlan_tci)
155 {
156         struct vlan_ethhdr *veth;
157
158         if (skb_cow_head(skb, VLAN_HLEN) < 0) {
159                 kfree_skb(skb);
160                 return NULL;
161         }
162         veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
163
164         /* Move the mac addresses to the beginning of the new header. */
165         memmove(skb->data, skb->data + VLAN_HLEN, 2 * VLAN_ETH_ALEN);
166         skb->mac_header -= VLAN_HLEN;
167
168         /* first, the ethernet type */
169         veth->h_vlan_proto = htons(ETH_P_8021Q);
170
171         /* now, the TCI */
172         veth->h_vlan_TCI = htons(vlan_tci);
173
174         return skb;
175 }
176
177 /**
178  * __vlan_put_tag - regular VLAN tag inserting
179  * @skb: skbuff to tag
180  * @vlan_tci: VLAN TCI to insert
181  *
182  * Inserts the VLAN tag into @skb as part of the payload
183  * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
184  *
185  * Following the skb_unshare() example, in case of error, the calling function
186  * doesn't have to worry about freeing the original skb.
187  */
188 static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
189 {
190         skb = vlan_insert_tag(skb, vlan_tci);
191         if (skb)
192                 skb->protocol = htons(ETH_P_8021Q);
193         return skb;
194 }
195
196 /**
197  * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
198  * @skb: skbuff to tag
199  * @vlan_tci: VLAN TCI to insert
200  *
201  * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest
202  */
203 static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb,
204                                                      u16 vlan_tci)
205 {
206         skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci;
207         return skb;
208 }
209
210 #define HAVE_VLAN_PUT_TAG
211
212 /**
213  * vlan_put_tag - inserts VLAN tag according to device features
214  * @skb: skbuff to tag
215  * @vlan_tci: VLAN TCI to insert
216  *
217  * Assumes skb->dev is the target that will xmit this frame.
218  * Returns a VLAN tagged skb.
219  */
220 static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
221 {
222         if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
223                 return __vlan_hwaccel_put_tag(skb, vlan_tci);
224         } else {
225                 return __vlan_put_tag(skb, vlan_tci);
226         }
227 }
228
229 /**
230  * __vlan_get_tag - get the VLAN ID that is part of the payload
231  * @skb: skbuff to query
232  * @vlan_tci: buffer to store vlaue
233  *
234  * Returns error if the skb is not of VLAN type
235  */
236 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
237 {
238         struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
239
240         if (veth->h_vlan_proto != htons(ETH_P_8021Q)) {
241                 return -EINVAL;
242         }
243
244         *vlan_tci = ntohs(veth->h_vlan_TCI);
245         return 0;
246 }
247
248 /**
249  * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
250  * @skb: skbuff to query
251  * @vlan_tci: buffer to store vlaue
252  *
253  * Returns error if @skb->vlan_tci is not set correctly
254  */
255 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
256                                          u16 *vlan_tci)
257 {
258         if (vlan_tx_tag_present(skb)) {
259                 *vlan_tci = vlan_tx_tag_get(skb);
260                 return 0;
261         } else {
262                 *vlan_tci = 0;
263                 return -EINVAL;
264         }
265 }
266
267 #define HAVE_VLAN_GET_TAG
268
269 /**
270  * vlan_get_tag - get the VLAN ID from the skb
271  * @skb: skbuff to query
272  * @vlan_tci: buffer to store vlaue
273  *
274  * Returns error if the skb is not VLAN tagged
275  */
276 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
277 {
278         if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
279                 return __vlan_hwaccel_get_tag(skb, vlan_tci);
280         } else {
281                 return __vlan_get_tag(skb, vlan_tci);
282         }
283 }
284
285 /**
286  * vlan_get_protocol - get protocol EtherType.
287  * @skb: skbuff to query
288  *
289  * Returns the EtherType of the packet, regardless of whether it is
290  * vlan encapsulated (normal or hardware accelerated) or not.
291  */
292 static inline __be16 vlan_get_protocol(const struct sk_buff *skb)
293 {
294         __be16 protocol = 0;
295
296         if (vlan_tx_tag_present(skb) ||
297              skb->protocol != cpu_to_be16(ETH_P_8021Q))
298                 protocol = skb->protocol;
299         else {
300                 __be16 proto, *protop;
301                 protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr,
302                                                 h_vlan_encapsulated_proto),
303                                                 sizeof(proto), &proto);
304                 if (likely(protop))
305                         protocol = *protop;
306         }
307
308         return protocol;
309 }
310
311 static inline void vlan_set_encap_proto(struct sk_buff *skb,
312                                         struct vlan_hdr *vhdr)
313 {
314         __be16 proto;
315         unsigned char *rawp;
316
317         /*
318          * Was a VLAN packet, grab the encapsulated protocol, which the layer
319          * three protocols care about.
320          */
321
322         proto = vhdr->h_vlan_encapsulated_proto;
323         if (ntohs(proto) >= 1536) {
324                 skb->protocol = proto;
325                 return;
326         }
327
328         rawp = skb->data;
329         if (*(unsigned short *) rawp == 0xFFFF)
330                 /*
331                  * This is a magic hack to spot IPX packets. Older Novell
332                  * breaks the protocol design and runs IPX over 802.3 without
333                  * an 802.2 LLC layer. We look for FFFF which isn't a used
334                  * 802.2 SSAP/DSAP. This won't work for fault tolerant netware
335                  * but does for the rest.
336                  */
337                 skb->protocol = htons(ETH_P_802_3);
338         else
339                 /*
340                  * Real 802.2 LLC
341                  */
342                 skb->protocol = htons(ETH_P_802_2);
343 }
344 #endif /* __KERNEL__ */
345
346 /* VLAN IOCTLs are found in sockios.h */
347
348 /* Passed in vlan_ioctl_args structure to determine behaviour. */
349 enum vlan_ioctl_cmds {
350         ADD_VLAN_CMD,
351         DEL_VLAN_CMD,
352         SET_VLAN_INGRESS_PRIORITY_CMD,
353         SET_VLAN_EGRESS_PRIORITY_CMD,
354         GET_VLAN_INGRESS_PRIORITY_CMD,
355         GET_VLAN_EGRESS_PRIORITY_CMD,
356         SET_VLAN_NAME_TYPE_CMD,
357         SET_VLAN_FLAG_CMD,
358         GET_VLAN_REALDEV_NAME_CMD, /* If this works, you know it's a VLAN device, btw */
359         GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */
360 };
361
362 enum vlan_flags {
363         VLAN_FLAG_REORDER_HDR   = 0x1,
364         VLAN_FLAG_GVRP          = 0x2,
365         VLAN_FLAG_LOOSE_BINDING = 0x4,
366 };
367
368 enum vlan_name_types {
369         VLAN_NAME_TYPE_PLUS_VID, /* Name will look like:  vlan0005 */
370         VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like:  eth1.0005 */
371         VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like:  vlan5 */
372         VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like:  eth0.5 */
373         VLAN_NAME_TYPE_HIGHEST
374 };
375
376 struct vlan_ioctl_args {
377         int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */
378         char device1[24];
379
380         union {
381                 char device2[24];
382                 int VID;
383                 unsigned int skb_priority;
384                 unsigned int name_type;
385                 unsigned int bind_type;
386                 unsigned int flag; /* Matches vlan_dev_priv flags */
387         } u;
388
389         short vlan_qos;   
390 };
391
392 #endif /* !(_LINUX_IF_VLAN_H_) */