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#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 */
  39struct 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 */
  52struct 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
  62static 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 */
  75extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *));
  76
  77/* if this changes, algorithm will have to be reworked because this
  78 * depends on completely exhausting the VLAN identifier space.  Thus
  79 * it gives constant time look-up, but in many cases it wastes memory.
  80 */
  81#define VLAN_GROUP_ARRAY_SPLIT_PARTS  8
  82#define VLAN_GROUP_ARRAY_PART_LEN     (VLAN_N_VID/VLAN_GROUP_ARRAY_SPLIT_PARTS)
  83
  84struct vlan_group {
  85        struct net_device       *real_dev; /* The ethernet(like) device
  86                                            * the vlan is attached to.
  87                                            */
  88        unsigned int            nr_vlans;
  89        struct hlist_node       hlist;  /* linked list */
  90        struct net_device **vlan_devices_arrays[VLAN_GROUP_ARRAY_SPLIT_PARTS];
  91        struct rcu_head         rcu;
  92};
  93
  94static inline struct net_device *vlan_group_get_device(struct vlan_group *vg,
  95                                                       u16 vlan_id)
  96{
  97        struct net_device **array;
  98        array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
  99        return array ? array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] : NULL;
 100}
 101
 102static inline void vlan_group_set_device(struct vlan_group *vg,
 103                                         u16 vlan_id,
 104                                         struct net_device *dev)
 105{
 106        struct net_device **array;
 107        if (!vg)
 108                return;
 109        array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
 110        array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] = dev;
 111}
 112
 113static inline int is_vlan_dev(struct net_device *dev)
 114{
 115        return dev->priv_flags & IFF_802_1Q_VLAN;
 116}
 117
 118#define vlan_tx_tag_present(__skb)      ((__skb)->vlan_tci & VLAN_TAG_PRESENT)
 119#define vlan_tx_tag_get(__skb)          ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT)
 120
 121#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
 122/* Must be invoked with rcu_read_lock or with RTNL. */
 123static inline struct net_device *vlan_find_dev(struct net_device *real_dev,
 124                                               u16 vlan_id)
 125{
 126        struct vlan_group *grp = rcu_dereference_rtnl(real_dev->vlgrp);
 127
 128        if (grp)
 129                return vlan_group_get_device(grp, vlan_id);
 130
 131        return NULL;
 132}
 133
 134extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
 135extern u16 vlan_dev_vlan_id(const struct net_device *dev);
 136
 137extern int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
 138                             u16 vlan_tci, int polling);
 139extern bool vlan_do_receive(struct sk_buff **skb);
 140extern struct sk_buff *vlan_untag(struct sk_buff *skb);
 141extern gro_result_t
 142vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
 143                 unsigned int vlan_tci, struct sk_buff *skb);
 144extern gro_result_t
 145vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
 146               unsigned int vlan_tci);
 147
 148#else
 149static inline struct net_device *vlan_find_dev(struct net_device *real_dev,
 150                                               u16 vlan_id)
 151{
 152        return NULL;
 153}
 154
 155static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev)
 156{
 157        BUG();
 158        return NULL;
 159}
 160
 161static inline u16 vlan_dev_vlan_id(const struct net_device *dev)
 162{
 163        BUG();
 164        return 0;
 165}
 166
 167static inline int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
 168                                    u16 vlan_tci, int polling)
 169{
 170        BUG();
 171        return NET_XMIT_SUCCESS;
 172}
 173
 174static inline bool vlan_do_receive(struct sk_buff **skb)
 175{
 176        if ((*skb)->vlan_tci & VLAN_VID_MASK)
 177                (*skb)->pkt_type = PACKET_OTHERHOST;
 178        return false;
 179}
 180
 181static inline struct sk_buff *vlan_untag(struct sk_buff *skb)
 182{
 183        return skb;
 184}
 185
 186static inline gro_result_t
 187vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
 188                 unsigned int vlan_tci, struct sk_buff *skb)
 189{
 190        return GRO_DROP;
 191}
 192
 193static inline gro_result_t
 194vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
 195               unsigned int vlan_tci)
 196{
 197        return GRO_DROP;
 198}
 199#endif
 200
 201/**
 202 * vlan_hwaccel_rx - netif_rx wrapper for VLAN RX acceleration
 203 * @skb: buffer
 204 * @grp: vlan group
 205 * @vlan_tci: VLAN TCI as received from the card
 206 */
 207static inline int vlan_hwaccel_rx(struct sk_buff *skb,
 208                                  struct vlan_group *grp,
 209                                  u16 vlan_tci)
 210{
 211        return __vlan_hwaccel_rx(skb, grp, vlan_tci, 0);
 212}
 213
 214/**
 215 * vlan_hwaccel_receive_skb - netif_receive_skb wrapper for VLAN RX acceleration
 216 * @skb: buffer
 217 * @grp: vlan group
 218 * @vlan_tci: VLAN TCI as received from the card
 219 */
 220static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb,
 221                                           struct vlan_group *grp,
 222                                           u16 vlan_tci)
 223{
 224        return __vlan_hwaccel_rx(skb, grp, vlan_tci, 1);
 225}
 226
 227/**
 228 * vlan_insert_tag - regular VLAN tag inserting
 229 * @skb: skbuff to tag
 230 * @vlan_tci: VLAN TCI to insert
 231 *
 232 * Inserts the VLAN tag into @skb as part of the payload
 233 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
 234 *
 235 * Following the skb_unshare() example, in case of error, the calling function
 236 * doesn't have to worry about freeing the original skb.
 237 *
 238 * Does not change skb->protocol so this function can be used during receive.
 239 */
 240static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, u16 vlan_tci)
 241{
 242        struct vlan_ethhdr *veth;
 243
 244        if (skb_cow_head(skb, VLAN_HLEN) < 0) {
 245                kfree_skb(skb);
 246                return NULL;
 247        }
 248        veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
 249
 250        /* Move the mac addresses to the beginning of the new header. */
 251        memmove(skb->data, skb->data + VLAN_HLEN, 2 * VLAN_ETH_ALEN);
 252        skb->mac_header -= VLAN_HLEN;
 253
 254        /* first, the ethernet type */
 255        veth->h_vlan_proto = htons(ETH_P_8021Q);
 256
 257        /* now, the TCI */
 258        veth->h_vlan_TCI = htons(vlan_tci);
 259
 260        return skb;
 261}
 262
 263/**
 264 * __vlan_put_tag - regular VLAN tag inserting
 265 * @skb: skbuff to tag
 266 * @vlan_tci: VLAN TCI to insert
 267 *
 268 * Inserts the VLAN tag into @skb as part of the payload
 269 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
 270 *
 271 * Following the skb_unshare() example, in case of error, the calling function
 272 * doesn't have to worry about freeing the original skb.
 273 */
 274static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
 275{
 276        skb = vlan_insert_tag(skb, vlan_tci);
 277        if (skb)
 278                skb->protocol = htons(ETH_P_8021Q);
 279        return skb;
 280}
 281
 282/**
 283 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
 284 * @skb: skbuff to tag
 285 * @vlan_tci: VLAN TCI to insert
 286 *
 287 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest
 288 */
 289static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb,
 290                                                     u16 vlan_tci)
 291{
 292        skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci;
 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 * @vlan_tci: VLAN TCI to insert
 302 *
 303 * Assumes skb->dev is the target that will xmit this frame.
 304 * Returns a VLAN tagged skb.
 305 */
 306static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
 307{
 308        if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
 309                return __vlan_hwaccel_put_tag(skb, vlan_tci);
 310        } else {
 311                return __vlan_put_tag(skb, vlan_tci);
 312        }
 313}
 314
 315/**
 316 * __vlan_get_tag - get the VLAN ID that is part of the payload
 317 * @skb: skbuff to query
 318 * @vlan_tci: buffer to store vlaue
 319 *
 320 * Returns error if the skb is not of VLAN type
 321 */
 322static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
 323{
 324        struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
 325
 326        if (veth->h_vlan_proto != htons(ETH_P_8021Q)) {
 327                return -EINVAL;
 328        }
 329
 330        *vlan_tci = ntohs(veth->h_vlan_TCI);
 331        return 0;
 332}
 333
 334/**
 335 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
 336 * @skb: skbuff to query
 337 * @vlan_tci: buffer to store vlaue
 338 *
 339 * Returns error if @skb->vlan_tci is not set correctly
 340 */
 341static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
 342                                         u16 *vlan_tci)
 343{
 344        if (vlan_tx_tag_present(skb)) {
 345                *vlan_tci = vlan_tx_tag_get(skb);
 346                return 0;
 347        } else {
 348                *vlan_tci = 0;
 349                return -EINVAL;
 350        }
 351}
 352
 353#define HAVE_VLAN_GET_TAG
 354
 355/**
 356 * vlan_get_tag - get the VLAN ID from the skb
 357 * @skb: skbuff to query
 358 * @vlan_tci: buffer to store vlaue
 359 *
 360 * Returns error if the skb is not VLAN tagged
 361 */
 362static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
 363{
 364        if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
 365                return __vlan_hwaccel_get_tag(skb, vlan_tci);
 366        } else {
 367                return __vlan_get_tag(skb, vlan_tci);
 368        }
 369}
 370
 371/**
 372 * vlan_get_protocol - get protocol EtherType.
 373 * @skb: skbuff to query
 374 *
 375 * Returns the EtherType of the packet, regardless of whether it is
 376 * vlan encapsulated (normal or hardware accelerated) or not.
 377 */
 378static inline __be16 vlan_get_protocol(const struct sk_buff *skb)
 379{
 380        __be16 protocol = 0;
 381
 382        if (vlan_tx_tag_present(skb) ||
 383             skb->protocol != cpu_to_be16(ETH_P_8021Q))
 384                protocol = skb->protocol;
 385        else {
 386                __be16 proto, *protop;
 387                protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr,
 388                                                h_vlan_encapsulated_proto),
 389                                                sizeof(proto), &proto);
 390                if (likely(protop))
 391                        protocol = *protop;
 392        }
 393
 394        return protocol;
 395}
 396#endif /* __KERNEL__ */
 397
 398/* VLAN IOCTLs are found in sockios.h */
 399
 400/* Passed in vlan_ioctl_args structure to determine behaviour. */
 401enum vlan_ioctl_cmds {
 402        ADD_VLAN_CMD,
 403        DEL_VLAN_CMD,
 404        SET_VLAN_INGRESS_PRIORITY_CMD,
 405        SET_VLAN_EGRESS_PRIORITY_CMD,
 406        GET_VLAN_INGRESS_PRIORITY_CMD,
 407        GET_VLAN_EGRESS_PRIORITY_CMD,
 408        SET_VLAN_NAME_TYPE_CMD,
 409        SET_VLAN_FLAG_CMD,
 410        GET_VLAN_REALDEV_NAME_CMD, /* If this works, you know it's a VLAN device, btw */
 411        GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */
 412};
 413
 414enum vlan_flags {
 415        VLAN_FLAG_REORDER_HDR   = 0x1,
 416        VLAN_FLAG_GVRP          = 0x2,
 417        VLAN_FLAG_LOOSE_BINDING = 0x4,
 418};
 419
 420enum vlan_name_types {
 421        VLAN_NAME_TYPE_PLUS_VID, /* Name will look like:  vlan0005 */
 422        VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like:  eth1.0005 */
 423        VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like:  vlan5 */
 424        VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like:  eth0.5 */
 425        VLAN_NAME_TYPE_HIGHEST
 426};
 427
 428struct vlan_ioctl_args {
 429        int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */
 430        char device1[24];
 431
 432        union {
 433                char device2[24];
 434                int VID;
 435                unsigned int skb_priority;
 436                unsigned int name_type;
 437                unsigned int bind_type;
 438                unsigned int flag; /* Matches vlan_dev_info flags */
 439        } u;
 440
 441        short vlan_qos;   
 442};
 443
 444#endif /* !(_LINUX_IF_VLAN_H_) */
 445