594cd35b00745ee2a7a448ea91dce5dcfda33366
[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
18 /* externally defined structs */
19 struct hlist_node;
20
21 #include <linux/netdevice.h>
22 #include <linux/etherdevice.h>
23
24 #define VLAN_HLEN       4               /* The additional bytes (on top of the Ethernet header)
25                                          * that VLAN requires.
26                                          */
27 #define VLAN_ETH_ALEN   6               /* Octets in one ethernet addr   */
28 #define VLAN_ETH_HLEN   18              /* Total octets in header.       */
29 #define VLAN_ETH_ZLEN   64              /* Min. octets in frame sans FCS */
30
31 /*
32  * According to 802.3ac, the packet can be 4 bytes longer. --Klika Jan
33  */
34 #define VLAN_ETH_DATA_LEN       1500    /* Max. octets in payload        */
35 #define VLAN_ETH_FRAME_LEN      1518    /* Max. octets in frame sans FCS */
36
37 /*
38  *      struct vlan_hdr - vlan header
39  *      @h_vlan_TCI: priority and VLAN ID
40  *      @h_vlan_encapsulated_proto: packet type ID or len
41  */
42 struct vlan_hdr {
43         __be16  h_vlan_TCI;
44         __be16  h_vlan_encapsulated_proto;
45 };
46
47 /**
48  *      struct vlan_ethhdr - vlan ethernet header (ethhdr + vlan_hdr)
49  *      @h_dest: destination ethernet address
50  *      @h_source: source ethernet address
51  *      @h_vlan_proto: ethernet protocol (always 0x8100)
52  *      @h_vlan_TCI: priority and VLAN ID
53  *      @h_vlan_encapsulated_proto: packet type ID or len
54  */
55 struct vlan_ethhdr {
56         unsigned char   h_dest[ETH_ALEN];
57         unsigned char   h_source[ETH_ALEN];
58         __be16          h_vlan_proto;
59         __be16          h_vlan_TCI;
60         __be16          h_vlan_encapsulated_proto;
61 };
62
63 #include <linux/skbuff.h>
64
65 static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
66 {
67         return (struct vlan_ethhdr *)skb_mac_header(skb);
68 }
69
70 #define VLAN_VID_MASK   0xfff
71
72 /* found in socket.c */
73 extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *));
74
75 /* if this changes, algorithm will have to be reworked because this
76  * depends on completely exhausting the VLAN identifier space.  Thus
77  * it gives constant time look-up, but in many cases it wastes memory.
78  */
79 #define VLAN_GROUP_ARRAY_LEN          4096
80 #define VLAN_GROUP_ARRAY_SPLIT_PARTS  8
81 #define VLAN_GROUP_ARRAY_PART_LEN     (VLAN_GROUP_ARRAY_LEN/VLAN_GROUP_ARRAY_SPLIT_PARTS)
82
83 struct vlan_group {
84         struct net_device       *real_dev; /* The ethernet(like) device
85                                             * the vlan is attached to.
86                                             */
87         unsigned int            nr_vlans;
88         struct hlist_node       hlist;  /* linked list */
89         struct net_device **vlan_devices_arrays[VLAN_GROUP_ARRAY_SPLIT_PARTS];
90         struct rcu_head         rcu;
91 };
92
93 static inline struct net_device *vlan_group_get_device(struct vlan_group *vg,
94                                                        unsigned int vlan_id)
95 {
96         struct net_device **array;
97         array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
98         return array ? array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] : NULL;
99 }
100
101 static inline void vlan_group_set_device(struct vlan_group *vg,
102                                          unsigned int vlan_id,
103                                          struct net_device *dev)
104 {
105         struct net_device **array;
106         if (!vg)
107                 return;
108         array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
109         array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] = dev;
110 }
111
112 struct vlan_priority_tci_mapping {
113         u32 priority;
114         unsigned short vlan_qos; /* This should be shifted when first set, so we only do it
115                                   * at provisioning time.
116                                   * ((skb->priority << 13) & 0xE000)
117                                   */
118         struct vlan_priority_tci_mapping *next;
119 };
120
121 /* Holds information that makes sense if this device is a VLAN device. */
122 struct vlan_dev_info {
123         /** This will be the mapping that correlates skb->priority to
124          * 3 bits of VLAN QOS tags...
125          */
126         unsigned int nr_ingress_mappings;
127         u32 ingress_priority_map[8];
128
129         unsigned int nr_egress_mappings;
130         struct vlan_priority_tci_mapping *egress_priority_map[16]; /* hash table */
131
132         unsigned short vlan_id;        /*  The VLAN Identifier for this interface. */
133         unsigned short flags;          /* (1 << 0) re_order_header   This option will cause the
134                                         *   VLAN code to move around the ethernet header on
135                                         *   ingress to make the skb look **exactly** like it
136                                         *   came in from an ethernet port.  This destroys some of
137                                         *   the VLAN information in the skb, but it fixes programs
138                                         *   like DHCP that use packet-filtering and don't understand
139                                         *   802.1Q
140                                         */
141         struct net_device *real_dev;    /* the underlying device/interface */
142         unsigned char real_dev_addr[ETH_ALEN];
143         struct proc_dir_entry *dent;    /* Holds the proc data */
144         unsigned long cnt_inc_headroom_on_tx; /* How many times did we have to grow the skb on TX. */
145         unsigned long cnt_encap_on_xmit;      /* How many times did we have to encapsulate the skb on TX. */
146 };
147
148 static inline struct vlan_dev_info *vlan_dev_info(const struct net_device *dev)
149 {
150         return netdev_priv(dev);
151 }
152
153 /* VLAN tx hw acceleration helpers. */
154 struct vlan_skb_tx_cookie {
155         u32     magic;
156         u32     vlan_tag;
157 };
158
159 #define VLAN_TX_COOKIE_MAGIC    0x564c414e      /* "VLAN" in ascii. */
160 #define VLAN_TX_SKB_CB(__skb)   ((struct vlan_skb_tx_cookie *)&((__skb)->cb[0]))
161 #define vlan_tx_tag_present(__skb) \
162         (VLAN_TX_SKB_CB(__skb)->magic == VLAN_TX_COOKIE_MAGIC)
163 #define vlan_tx_tag_get(__skb)  (VLAN_TX_SKB_CB(__skb)->vlan_tag)
164
165 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
166 extern int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
167                              unsigned short vlan_tag, int polling);
168 #else
169 static inline int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
170                                     unsigned short vlan_tag, int polling)
171 {
172         BUG();
173         return NET_XMIT_SUCCESS;
174 }
175 #endif
176
177 static inline int vlan_hwaccel_rx(struct sk_buff *skb,
178                                   struct vlan_group *grp,
179                                   unsigned short vlan_tag)
180 {
181         return __vlan_hwaccel_rx(skb, grp, vlan_tag, 0);
182 }
183
184 static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb,
185                                            struct vlan_group *grp,
186                                            unsigned short vlan_tag)
187 {
188         return __vlan_hwaccel_rx(skb, grp, vlan_tag, 1);
189 }
190
191 /**
192  * __vlan_put_tag - regular VLAN tag inserting
193  * @skb: skbuff to tag
194  * @tag: VLAN tag to insert
195  *
196  * Inserts the VLAN tag into @skb as part of the payload
197  * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
198  * 
199  * Following the skb_unshare() example, in case of error, the calling function
200  * doesn't have to worry about freeing the original skb.
201  */
202 static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, unsigned short tag)
203 {
204         struct vlan_ethhdr *veth;
205
206         if (skb_headroom(skb) < VLAN_HLEN) {
207                 struct sk_buff *sk_tmp = skb;
208                 skb = skb_realloc_headroom(sk_tmp, VLAN_HLEN);
209                 kfree_skb(sk_tmp);
210                 if (!skb) {
211                         printk(KERN_ERR "vlan: failed to realloc headroom\n");
212                         return NULL;
213                 }
214         } else {
215                 skb = skb_unshare(skb, GFP_ATOMIC);
216                 if (!skb) {
217                         printk(KERN_ERR "vlan: failed to unshare skbuff\n");
218                         return NULL;
219                 }
220         }
221
222         veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
223
224         /* Move the mac addresses to the beginning of the new header. */
225         memmove(skb->data, skb->data + VLAN_HLEN, 2 * VLAN_ETH_ALEN);
226
227         /* first, the ethernet type */
228         veth->h_vlan_proto = htons(ETH_P_8021Q);
229
230         /* now, the tag */
231         veth->h_vlan_TCI = htons(tag);
232
233         skb->protocol = htons(ETH_P_8021Q);
234
235         return skb;
236 }
237
238 /**
239  * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
240  * @skb: skbuff to tag
241  * @tag: VLAN tag to insert
242  *
243  * Puts the VLAN tag in @skb->cb[] and lets the device do the rest
244  */
245 static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb, unsigned short tag)
246 {
247         struct vlan_skb_tx_cookie *cookie;
248
249         cookie = VLAN_TX_SKB_CB(skb);
250         cookie->magic = VLAN_TX_COOKIE_MAGIC;
251         cookie->vlan_tag = tag;
252
253         return skb;
254 }
255
256 #define HAVE_VLAN_PUT_TAG
257
258 /**
259  * vlan_put_tag - inserts VLAN tag according to device features
260  * @skb: skbuff to tag
261  * @tag: VLAN tag to insert
262  *
263  * Assumes skb->dev is the target that will xmit this frame.
264  * Returns a VLAN tagged skb.
265  */
266 static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, unsigned short tag)
267 {
268         if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
269                 return __vlan_hwaccel_put_tag(skb, tag);
270         } else {
271                 return __vlan_put_tag(skb, tag);
272         }
273 }
274
275 /**
276  * __vlan_get_tag - get the VLAN ID that is part of the payload
277  * @skb: skbuff to query
278  * @tag: buffer to store vlaue
279  * 
280  * Returns error if the skb is not of VLAN type
281  */
282 static inline int __vlan_get_tag(const struct sk_buff *skb, unsigned short *tag)
283 {
284         struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
285
286         if (veth->h_vlan_proto != htons(ETH_P_8021Q)) {
287                 return -EINVAL;
288         }
289
290         *tag = ntohs(veth->h_vlan_TCI);
291
292         return 0;
293 }
294
295 /**
296  * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
297  * @skb: skbuff to query
298  * @tag: buffer to store vlaue
299  * 
300  * Returns error if @skb->cb[] is not set correctly
301  */
302 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
303                                          unsigned short *tag)
304 {
305         struct vlan_skb_tx_cookie *cookie;
306
307         cookie = VLAN_TX_SKB_CB(skb);
308         if (cookie->magic == VLAN_TX_COOKIE_MAGIC) {
309                 *tag = cookie->vlan_tag;
310                 return 0;
311         } else {
312                 *tag = 0;
313                 return -EINVAL;
314         }
315 }
316
317 #define HAVE_VLAN_GET_TAG
318
319 /**
320  * vlan_get_tag - get the VLAN ID from the skb
321  * @skb: skbuff to query
322  * @tag: buffer to store vlaue
323  * 
324  * Returns error if the skb is not VLAN tagged
325  */
326 static inline int vlan_get_tag(const struct sk_buff *skb, unsigned short *tag)
327 {
328         if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
329                 return __vlan_hwaccel_get_tag(skb, tag);
330         } else {
331                 return __vlan_get_tag(skb, tag);
332         }
333 }
334
335 #endif /* __KERNEL__ */
336
337 /* VLAN IOCTLs are found in sockios.h */
338
339 /* Passed in vlan_ioctl_args structure to determine behaviour. */
340 enum vlan_ioctl_cmds {
341         ADD_VLAN_CMD,
342         DEL_VLAN_CMD,
343         SET_VLAN_INGRESS_PRIORITY_CMD,
344         SET_VLAN_EGRESS_PRIORITY_CMD,
345         GET_VLAN_INGRESS_PRIORITY_CMD,
346         GET_VLAN_EGRESS_PRIORITY_CMD,
347         SET_VLAN_NAME_TYPE_CMD,
348         SET_VLAN_FLAG_CMD,
349         GET_VLAN_REALDEV_NAME_CMD, /* If this works, you know it's a VLAN device, btw */
350         GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */
351 };
352
353 enum vlan_flags {
354         VLAN_FLAG_REORDER_HDR   = 0x1,
355         VLAN_FLAG_GVRP          = 0x2,
356 };
357
358 enum vlan_name_types {
359         VLAN_NAME_TYPE_PLUS_VID, /* Name will look like:  vlan0005 */
360         VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like:  eth1.0005 */
361         VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like:  vlan5 */
362         VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like:  eth0.5 */
363         VLAN_NAME_TYPE_HIGHEST
364 };
365
366 struct vlan_ioctl_args {
367         int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */
368         char device1[24];
369
370         union {
371                 char device2[24];
372                 int VID;
373                 unsigned int skb_priority;
374                 unsigned int name_type;
375                 unsigned int bind_type;
376                 unsigned int flag; /* Matches vlan_dev_info flags */
377         } u;
378
379         short vlan_qos;   
380 };
381
382 #endif /* !(_LINUX_IF_VLAN_H_) */