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