LXR linux/include/linux/if

   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 */
  38struct 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 */
  51struct 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
  61static 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 */
  69extern 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
  79struct 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
  89static 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
  97static 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)
 112extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
 113extern u16 vlan_dev_vlan_id(const struct net_device *dev);
 114
 115extern int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
 116                             u16 vlan_tci, int polling);
 117extern int vlan_hwaccel_do_receive(struct sk_buff *skb);
 118extern int vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
 119                            unsigned int vlan_tci, struct sk_buff *skb);
 120extern int vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
 121                          unsigned int vlan_tci,
 122                          struct napi_gro_fraginfo *info);
 123
 124#else
 125static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev)
 126{
 127        BUG();
 128        return NULL;
 129}
 130
 131static inline u16 vlan_dev_vlan_id(const struct net_device *dev)
 132{
 133        BUG();
 134        return 0;
 135}
 136
 137static inline int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
 138                                    u16 vlan_tci, int polling)
 139{
 140        BUG();
 141        return NET_XMIT_SUCCESS;
 142}
 143
 144static inline int vlan_hwaccel_do_receive(struct sk_buff *skb)
 145{
 146        return 0;
 147}
 148
 149static inline int vlan_gro_receive(struct napi_struct *napi,
 150                                   struct vlan_group *grp,
 151                                   unsigned int vlan_tci, struct sk_buff *skb)
 152{
 153        return NET_RX_DROP;
 154}
 155
 156static inline int vlan_gro_frags(struct napi_struct *napi,
 157                                 struct vlan_group *grp, unsigned int vlan_tci,
 158                                 struct napi_gro_fraginfo *info)
 159{
 160        return NET_RX_DROP;
 161}
 162#endif
 163
 164/**
 165 * vlan_hwaccel_rx - netif_rx wrapper for VLAN RX acceleration
 166 * @skb: buffer
 167 * @grp: vlan group
 168 * @vlan_tci: VLAN TCI as received from the card
 169 */
 170static inline int vlan_hwaccel_rx(struct sk_buff *skb,
 171                                  struct vlan_group *grp,
 172                                  u16 vlan_tci)
 173{
 174        return __vlan_hwaccel_rx(skb, grp, vlan_tci, 0);
 175}
 176
 177/**
 178 * vlan_hwaccel_receive_skb - netif_receive_skb wrapper for VLAN RX acceleration
 179 * @skb: buffer
 180 * @grp: vlan group
 181 * @vlan_tci: VLAN TCI as received from the card
 182 */
 183static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb,
 184                                           struct vlan_group *grp,
 185                                           u16 vlan_tci)
 186{
 187        return __vlan_hwaccel_rx(skb, grp, vlan_tci, 1);
 188}
 189
 190/**
 191 * __vlan_put_tag - regular VLAN tag inserting
 192 * @skb: skbuff to tag
 193 * @vlan_tci: VLAN TCI to insert
 194 *
 195 * Inserts the VLAN tag into @skb as part of the payload
 196 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
 197 *
 198 * Following the skb_unshare() example, in case of error, the calling function
 199 * doesn't have to worry about freeing the original skb.
 200 */
 201static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
 202{
 203        struct vlan_ethhdr *veth;
 204
 205        if (skb_cow_head(skb, VLAN_HLEN) < 0) {
 206                kfree_skb(skb);
 207                return NULL;
 208        }
 209        veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
 210
 211        /* Move the mac addresses to the beginning of the new header. */
 212        memmove(skb->data, skb->data + VLAN_HLEN, 2 * VLAN_ETH_ALEN);
 213        skb->mac_header -= VLAN_HLEN;
 214
 215        /* first, the ethernet type */
 216        veth->h_vlan_proto = htons(ETH_P_8021Q);
 217
 218        /* now, the TCI */
 219        veth->h_vlan_TCI = htons(vlan_tci);
 220
 221        skb->protocol = htons(ETH_P_8021Q);
 222
 223        return skb;
 224}
 225
 226/**
 227 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
 228 * @skb: skbuff to tag
 229 * @vlan_tci: VLAN TCI to insert
 230 *
 231 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest
 232 */
 233static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb,
 234                                                     u16 vlan_tci)
 235{
 236        skb->vlan_tci = vlan_tci;
 237        return skb;
 238}
 239
 240#define HAVE_VLAN_PUT_TAG
 241
 242/**
 243 * vlan_put_tag - inserts VLAN tag according to device features
 244 * @skb: skbuff to tag
 245 * @vlan_tci: VLAN TCI to insert
 246 *
 247 * Assumes skb->dev is the target that will xmit this frame.
 248 * Returns a VLAN tagged skb.
 249 */
 250static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
 251{
 252        if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
 253                return __vlan_hwaccel_put_tag(skb, vlan_tci);
 254        } else {
 255                return __vlan_put_tag(skb, vlan_tci);
 256        }
 257}
 258
 259/**
 260 * __vlan_get_tag - get the VLAN ID that is part of the payload
 261 * @skb: skbuff to query
 262 * @vlan_tci: buffer to store vlaue
 263 *
 264 * Returns error if the skb is not of VLAN type
 265 */
 266static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
 267{
 268        struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
 269
 270        if (veth->h_vlan_proto != htons(ETH_P_8021Q)) {
 271                return -EINVAL;
 272        }
 273
 274        *vlan_tci = ntohs(veth->h_vlan_TCI);
 275        return 0;
 276}
 277
 278/**
 279 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
 280 * @skb: skbuff to query
 281 * @vlan_tci: buffer to store vlaue
 282 *
 283 * Returns error if @skb->vlan_tci is not set correctly
 284 */
 285static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
 286                                         u16 *vlan_tci)
 287{
 288        if (vlan_tx_tag_present(skb)) {
 289                *vlan_tci = skb->vlan_tci;
 290                return 0;
 291        } else {
 292                *vlan_tci = 0;
 293                return -EINVAL;
 294        }
 295}
 296
 297#define HAVE_VLAN_GET_TAG
 298
 299/**
 300 * vlan_get_tag - get the VLAN ID from the skb
 301 * @skb: skbuff to query
 302 * @vlan_tci: buffer to store vlaue
 303 *
 304 * Returns error if the skb is not VLAN tagged
 305 */
 306static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
 307{
 308        if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
 309                return __vlan_hwaccel_get_tag(skb, vlan_tci);
 310        } else {
 311                return __vlan_get_tag(skb, vlan_tci);
 312        }
 313}
 314
 315#endif /* __KERNEL__ */
 316
 317/* VLAN IOCTLs are found in sockios.h */
 318
 319/* Passed in vlan_ioctl_args structure to determine behaviour. */
 320enum vlan_ioctl_cmds {
 321        ADD_VLAN_CMD,
 322        DEL_VLAN_CMD,
 323        SET_VLAN_INGRESS_PRIORITY_CMD,
 324        SET_VLAN_EGRESS_PRIORITY_CMD,
 325        GET_VLAN_INGRESS_PRIORITY_CMD,
 326        GET_VLAN_EGRESS_PRIORITY_CMD,
 327        SET_VLAN_NAME_TYPE_CMD,
 328        SET_VLAN_FLAG_CMD,
 329        GET_VLAN_REALDEV_NAME_CMD, /* If this works, you know it's a VLAN device, btw */
 330        GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */
 331};
 332
 333enum vlan_flags {
 334        VLAN_FLAG_REORDER_HDR   = 0x1,
 335        VLAN_FLAG_GVRP          = 0x2,
 336};
 337
 338enum vlan_name_types {
 339        VLAN_NAME_TYPE_PLUS_VID, /* Name will look like:  vlan0005 */
 340        VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like:  eth1.0005 */
 341        VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like:  vlan5 */
 342        VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like:  eth0.5 */
 343        VLAN_NAME_TYPE_HIGHEST
 344};
 345
 346struct vlan_ioctl_args {
 347        int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */
 348        char device1[24];
 349
 350        union {
 351                char device2[24];
 352                int VID;
 353                unsigned int skb_priority;
 354                unsigned int name_type;
 355                unsigned int bind_type;
 356                unsigned int flag; /* Matches vlan_dev_info flags */
 357        } u;
 358
 359        short vlan_qos;   
 360};
 361
 362#endif /* !(_LINUX_IF_VLAN_H_) */
 363