[VLAN]: Kill useless VLAN_NAME define
[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         int real_dev_ifindex; /* The ifindex of the ethernet(like) device the vlan is attached to. */
85         struct hlist_node       hlist;  /* linked list */
86         struct net_device **vlan_devices_arrays[VLAN_GROUP_ARRAY_SPLIT_PARTS];
87         struct rcu_head         rcu;
88 };
89
90 static inline struct net_device *vlan_group_get_device(struct vlan_group *vg,
91                                                        unsigned int vlan_id)
92 {
93         struct net_device **array;
94         array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
95         return array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN];
96 }
97
98 static inline void vlan_group_set_device(struct vlan_group *vg,
99                                          unsigned int vlan_id,
100                                          struct net_device *dev)
101 {
102         struct net_device **array;
103         if (!vg)
104                 return;
105         array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
106         array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] = dev;
107 }
108
109 struct vlan_priority_tci_mapping {
110         u32 priority;
111         unsigned short vlan_qos; /* This should be shifted when first set, so we only do it
112                                   * at provisioning time.
113                                   * ((skb->priority << 13) & 0xE000)
114                                   */
115         struct vlan_priority_tci_mapping *next;
116 };
117
118 /* Holds information that makes sense if this device is a VLAN device. */
119 struct vlan_dev_info {
120         /** This will be the mapping that correlates skb->priority to
121          * 3 bits of VLAN QOS tags...
122          */
123         unsigned int nr_ingress_mappings;
124         u32 ingress_priority_map[8];
125
126         unsigned int nr_egress_mappings;
127         struct vlan_priority_tci_mapping *egress_priority_map[16]; /* hash table */
128
129         unsigned short vlan_id;        /*  The VLAN Identifier for this interface. */
130         unsigned short flags;          /* (1 << 0) re_order_header   This option will cause the
131                                         *   VLAN code to move around the ethernet header on
132                                         *   ingress to make the skb look **exactly** like it
133                                         *   came in from an ethernet port.  This destroys some of
134                                         *   the VLAN information in the skb, but it fixes programs
135                                         *   like DHCP that use packet-filtering and don't understand
136                                         *   802.1Q
137                                         */
138         struct net_device *real_dev;    /* the underlying device/interface */
139         unsigned char real_dev_addr[ETH_ALEN];
140         struct proc_dir_entry *dent;    /* Holds the proc data */
141         unsigned long cnt_inc_headroom_on_tx; /* How many times did we have to grow the skb on TX. */
142         unsigned long cnt_encap_on_xmit;      /* How many times did we have to encapsulate the skb on TX. */
143         struct net_device_stats dev_stats; /* Device stats (rx-bytes, tx-pkts, etc...) */
144 };
145
146 #define VLAN_DEV_INFO(x) ((struct vlan_dev_info *)(x->priv))
147
148 /* inline functions */
149
150 static inline struct net_device_stats *vlan_dev_get_stats(struct net_device *dev)
151 {
152         return &(VLAN_DEV_INFO(dev)->dev_stats);
153 }
154
155 static inline __u32 vlan_get_ingress_priority(struct net_device *dev,
156                                               unsigned short vlan_tag)
157 {
158         struct vlan_dev_info *vip = VLAN_DEV_INFO(dev);
159
160         return vip->ingress_priority_map[(vlan_tag >> 13) & 0x7];
161 }
162
163 /* VLAN tx hw acceleration helpers. */
164 struct vlan_skb_tx_cookie {
165         u32     magic;
166         u32     vlan_tag;
167 };
168
169 #define VLAN_TX_COOKIE_MAGIC    0x564c414e      /* "VLAN" in ascii. */
170 #define VLAN_TX_SKB_CB(__skb)   ((struct vlan_skb_tx_cookie *)&((__skb)->cb[0]))
171 #define vlan_tx_tag_present(__skb) \
172         (VLAN_TX_SKB_CB(__skb)->magic == VLAN_TX_COOKIE_MAGIC)
173 #define vlan_tx_tag_get(__skb)  (VLAN_TX_SKB_CB(__skb)->vlan_tag)
174
175 /* VLAN rx hw acceleration helper.  This acts like netif_{rx,receive_skb}(). */
176 static inline int __vlan_hwaccel_rx(struct sk_buff *skb,
177                                     struct vlan_group *grp,
178                                     unsigned short vlan_tag, int polling)
179 {
180         struct net_device_stats *stats;
181
182         if (skb_bond_should_drop(skb)) {
183                 dev_kfree_skb_any(skb);
184                 return NET_RX_DROP;
185         }
186
187         skb->dev = vlan_group_get_device(grp, vlan_tag & VLAN_VID_MASK);
188         if (skb->dev == NULL) {
189                 dev_kfree_skb_any(skb);
190
191                 /* Not NET_RX_DROP, this is not being dropped
192                  * due to congestion.
193                  */
194                 return 0;
195         }
196
197         skb->dev->last_rx = jiffies;
198
199         stats = vlan_dev_get_stats(skb->dev);
200         stats->rx_packets++;
201         stats->rx_bytes += skb->len;
202
203         skb->priority = vlan_get_ingress_priority(skb->dev, vlan_tag);
204         switch (skb->pkt_type) {
205         case PACKET_BROADCAST:
206                 break;
207
208         case PACKET_MULTICAST:
209                 stats->multicast++;
210                 break;
211
212         case PACKET_OTHERHOST:
213                 /* Our lower layer thinks this is not local, let's make sure.
214                  * This allows the VLAN to have a different MAC than the underlying
215                  * device, and still route correctly.
216                  */
217                 if (!compare_ether_addr(eth_hdr(skb)->h_dest,
218                                         skb->dev->dev_addr))
219                         skb->pkt_type = PACKET_HOST;
220                 break;
221         };
222
223         return (polling ? netif_receive_skb(skb) : netif_rx(skb));
224 }
225
226 static inline int vlan_hwaccel_rx(struct sk_buff *skb,
227                                   struct vlan_group *grp,
228                                   unsigned short vlan_tag)
229 {
230         return __vlan_hwaccel_rx(skb, grp, vlan_tag, 0);
231 }
232
233 static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb,
234                                            struct vlan_group *grp,
235                                            unsigned short vlan_tag)
236 {
237         return __vlan_hwaccel_rx(skb, grp, vlan_tag, 1);
238 }
239
240 /**
241  * __vlan_put_tag - regular VLAN tag inserting
242  * @skb: skbuff to tag
243  * @tag: VLAN tag to insert
244  *
245  * Inserts the VLAN tag into @skb as part of the payload
246  * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
247  * 
248  * Following the skb_unshare() example, in case of error, the calling function
249  * doesn't have to worry about freeing the original skb.
250  */
251 static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, unsigned short tag)
252 {
253         struct vlan_ethhdr *veth;
254
255         if (skb_headroom(skb) < VLAN_HLEN) {
256                 struct sk_buff *sk_tmp = skb;
257                 skb = skb_realloc_headroom(sk_tmp, VLAN_HLEN);
258                 kfree_skb(sk_tmp);
259                 if (!skb) {
260                         printk(KERN_ERR "vlan: failed to realloc headroom\n");
261                         return NULL;
262                 }
263         } else {
264                 skb = skb_unshare(skb, GFP_ATOMIC);
265                 if (!skb) {
266                         printk(KERN_ERR "vlan: failed to unshare skbuff\n");
267                         return NULL;
268                 }
269         }
270
271         veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
272
273         /* Move the mac addresses to the beginning of the new header. */
274         memmove(skb->data, skb->data + VLAN_HLEN, 2 * VLAN_ETH_ALEN);
275
276         /* first, the ethernet type */
277         veth->h_vlan_proto = __constant_htons(ETH_P_8021Q);
278
279         /* now, the tag */
280         veth->h_vlan_TCI = htons(tag);
281
282         skb->protocol = __constant_htons(ETH_P_8021Q);
283         skb->mac_header -= VLAN_HLEN;
284         skb->network_header -= VLAN_HLEN;
285
286         return skb;
287 }
288
289 /**
290  * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
291  * @skb: skbuff to tag
292  * @tag: VLAN tag to insert
293  *
294  * Puts the VLAN tag in @skb->cb[] and lets the device do the rest
295  */
296 static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb, unsigned short tag)
297 {
298         struct vlan_skb_tx_cookie *cookie;
299
300         cookie = VLAN_TX_SKB_CB(skb);
301         cookie->magic = VLAN_TX_COOKIE_MAGIC;
302         cookie->vlan_tag = tag;
303
304         return skb;
305 }
306
307 #define HAVE_VLAN_PUT_TAG
308
309 /**
310  * vlan_put_tag - inserts VLAN tag according to device features
311  * @skb: skbuff to tag
312  * @tag: VLAN tag to insert
313  *
314  * Assumes skb->dev is the target that will xmit this frame.
315  * Returns a VLAN tagged skb.
316  */
317 static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, unsigned short tag)
318 {
319         if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
320                 return __vlan_hwaccel_put_tag(skb, tag);
321         } else {
322                 return __vlan_put_tag(skb, tag);
323         }
324 }
325
326 /**
327  * __vlan_get_tag - get the VLAN ID that is part of the payload
328  * @skb: skbuff to query
329  * @tag: buffer to store vlaue
330  * 
331  * Returns error if the skb is not of VLAN type
332  */
333 static inline int __vlan_get_tag(struct sk_buff *skb, unsigned short *tag)
334 {
335         struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
336
337         if (veth->h_vlan_proto != __constant_htons(ETH_P_8021Q)) {
338                 return -EINVAL;
339         }
340
341         *tag = ntohs(veth->h_vlan_TCI);
342
343         return 0;
344 }
345
346 /**
347  * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
348  * @skb: skbuff to query
349  * @tag: buffer to store vlaue
350  * 
351  * Returns error if @skb->cb[] is not set correctly
352  */
353 static inline int __vlan_hwaccel_get_tag(struct sk_buff *skb, unsigned short *tag)
354 {
355         struct vlan_skb_tx_cookie *cookie;
356
357         cookie = VLAN_TX_SKB_CB(skb);
358         if (cookie->magic == VLAN_TX_COOKIE_MAGIC) {
359                 *tag = cookie->vlan_tag;
360                 return 0;
361         } else {
362                 *tag = 0;
363                 return -EINVAL;
364         }
365 }
366
367 #define HAVE_VLAN_GET_TAG
368
369 /**
370  * vlan_get_tag - get the VLAN ID from the skb
371  * @skb: skbuff to query
372  * @tag: buffer to store vlaue
373  * 
374  * Returns error if the skb is not VLAN tagged
375  */
376 static inline int vlan_get_tag(struct sk_buff *skb, unsigned short *tag)
377 {
378         if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
379                 return __vlan_hwaccel_get_tag(skb, tag);
380         } else {
381                 return __vlan_get_tag(skb, tag);
382         }
383 }
384
385 #endif /* __KERNEL__ */
386
387 /* VLAN IOCTLs are found in sockios.h */
388
389 /* Passed in vlan_ioctl_args structure to determine behaviour. */
390 enum vlan_ioctl_cmds {
391         ADD_VLAN_CMD,
392         DEL_VLAN_CMD,
393         SET_VLAN_INGRESS_PRIORITY_CMD,
394         SET_VLAN_EGRESS_PRIORITY_CMD,
395         GET_VLAN_INGRESS_PRIORITY_CMD,
396         GET_VLAN_EGRESS_PRIORITY_CMD,
397         SET_VLAN_NAME_TYPE_CMD,
398         SET_VLAN_FLAG_CMD,
399         GET_VLAN_REALDEV_NAME_CMD, /* If this works, you know it's a VLAN device, btw */
400         GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */
401 };
402
403 enum vlan_flags {
404         VLAN_FLAG_REORDER_HDR   = 0x1,
405 };
406
407 enum vlan_name_types {
408         VLAN_NAME_TYPE_PLUS_VID, /* Name will look like:  vlan0005 */
409         VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like:  eth1.0005 */
410         VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like:  vlan5 */
411         VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like:  eth0.5 */
412         VLAN_NAME_TYPE_HIGHEST
413 };
414
415 struct vlan_ioctl_args {
416         int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */
417         char device1[24];
418
419         union {
420                 char device2[24];
421                 int VID;
422                 unsigned int skb_priority;
423                 unsigned int name_type;
424                 unsigned int bind_type;
425                 unsigned int flag; /* Matches vlan_dev_info flags */
426         } u;
427
428         short vlan_qos;   
429 };
430
431 #endif /* !(_LINUX_IF_VLAN_H_) */