1*2874c5fdSThomas Gleixner /* SPDX-License-Identifier: GPL-2.0-or-later */ 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * VLAN An implementation of 802.1Q VLAN tagging. 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Authors: Ben Greear <greearb@candelatech.com> 61da177e4SLinus Torvalds */ 71da177e4SLinus Torvalds #ifndef _LINUX_IF_VLAN_H_ 81da177e4SLinus Torvalds #define _LINUX_IF_VLAN_H_ 91da177e4SLinus Torvalds 101da177e4SLinus Torvalds #include <linux/netdevice.h> 110610d11bSStephen Hemminger #include <linux/etherdevice.h> 1265ac6a5fSJesse Gross #include <linux/rtnetlink.h> 13187f1882SPaul Gortmaker #include <linux/bug.h> 14607ca46eSDavid Howells #include <uapi/linux/if_vlan.h> 151da177e4SLinus Torvalds 16a3f671b3SJoe Perches #define VLAN_HLEN 4 /* The additional bytes required by VLAN 17a3f671b3SJoe Perches * (in addition to the Ethernet header) 181da177e4SLinus Torvalds */ 191da177e4SLinus Torvalds #define VLAN_ETH_HLEN 18 /* Total octets in header. */ 201da177e4SLinus Torvalds #define VLAN_ETH_ZLEN 64 /* Min. octets in frame sans FCS */ 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds /* 231da177e4SLinus Torvalds * According to 802.3ac, the packet can be 4 bytes longer. --Klika Jan 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds #define VLAN_ETH_DATA_LEN 1500 /* Max. octets in payload */ 261da177e4SLinus Torvalds #define VLAN_ETH_FRAME_LEN 1518 /* Max. octets in frame sans FCS */ 271da177e4SLinus Torvalds 28740c15d0SPatrick McHardy /* 29740c15d0SPatrick McHardy * struct vlan_hdr - vlan header 30740c15d0SPatrick McHardy * @h_vlan_TCI: priority and VLAN ID 31740c15d0SPatrick McHardy * @h_vlan_encapsulated_proto: packet type ID or len 32740c15d0SPatrick McHardy */ 33740c15d0SPatrick McHardy struct vlan_hdr { 34740c15d0SPatrick McHardy __be16 h_vlan_TCI; 35740c15d0SPatrick McHardy __be16 h_vlan_encapsulated_proto; 36740c15d0SPatrick McHardy }; 37740c15d0SPatrick McHardy 38740c15d0SPatrick McHardy /** 39740c15d0SPatrick McHardy * struct vlan_ethhdr - vlan ethernet header (ethhdr + vlan_hdr) 40740c15d0SPatrick McHardy * @h_dest: destination ethernet address 41740c15d0SPatrick McHardy * @h_source: source ethernet address 42a7bf5804SOlaf Hering * @h_vlan_proto: ethernet protocol 43740c15d0SPatrick McHardy * @h_vlan_TCI: priority and VLAN ID 44740c15d0SPatrick McHardy * @h_vlan_encapsulated_proto: packet type ID or len 45740c15d0SPatrick McHardy */ 461da177e4SLinus Torvalds struct vlan_ethhdr { 47740c15d0SPatrick McHardy unsigned char h_dest[ETH_ALEN]; 48740c15d0SPatrick McHardy unsigned char h_source[ETH_ALEN]; 49740c15d0SPatrick McHardy __be16 h_vlan_proto; 50740c15d0SPatrick McHardy __be16 h_vlan_TCI; 51740c15d0SPatrick McHardy __be16 h_vlan_encapsulated_proto; 521da177e4SLinus Torvalds }; 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds #include <linux/skbuff.h> 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb) 571da177e4SLinus Torvalds { 5898e399f8SArnaldo Carvalho de Melo return (struct vlan_ethhdr *)skb_mac_header(skb); 591da177e4SLinus Torvalds } 601da177e4SLinus Torvalds 6105423b24SEric Dumazet #define VLAN_PRIO_MASK 0xe000 /* Priority Code Point */ 6205423b24SEric Dumazet #define VLAN_PRIO_SHIFT 13 63a2e768b8SMichał Mirosław #define VLAN_CFI_MASK 0x1000 /* Canonical Format Indicator / Drop Eligible Indicator */ 6405423b24SEric Dumazet #define VLAN_VID_MASK 0x0fff /* VLAN Identifier */ 65b738127dSJesse Gross #define VLAN_N_VID 4096 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds /* found in socket.c */ 68881d966bSEric W. Biederman extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *)); 691da177e4SLinus Torvalds 70b618aaa9SJiri Pirko static inline bool is_vlan_dev(const struct net_device *dev) 716dcbbe25SNeil Horman { 726dcbbe25SNeil Horman return dev->priv_flags & IFF_802_1Q_VLAN; 736dcbbe25SNeil Horman } 746dcbbe25SNeil Horman 750c4b2d37SMichał Mirosław #define skb_vlan_tag_present(__skb) ((__skb)->vlan_present) 760c4b2d37SMichał Mirosław #define skb_vlan_tag_get(__skb) ((__skb)->vlan_tci) 77df8a39deSJiri Pirko #define skb_vlan_tag_get_id(__skb) ((__skb)->vlan_tci & VLAN_VID_MASK) 78a2e768b8SMichał Mirosław #define skb_vlan_tag_get_cfi(__skb) (!!((__skb)->vlan_tci & VLAN_CFI_MASK)) 799b319148SMichał Mirosław #define skb_vlan_tag_get_prio(__skb) (((__skb)->vlan_tci & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT) 801da177e4SLinus Torvalds 819daae9bdSGal Pressman static inline int vlan_get_rx_ctag_filter_info(struct net_device *dev) 829daae9bdSGal Pressman { 839daae9bdSGal Pressman ASSERT_RTNL(); 849daae9bdSGal Pressman return notifier_to_errno(call_netdevice_notifiers(NETDEV_CVLAN_FILTER_PUSH_INFO, dev)); 859daae9bdSGal Pressman } 869daae9bdSGal Pressman 879daae9bdSGal Pressman static inline void vlan_drop_rx_ctag_filter_info(struct net_device *dev) 889daae9bdSGal Pressman { 899daae9bdSGal Pressman ASSERT_RTNL(); 909daae9bdSGal Pressman call_netdevice_notifiers(NETDEV_CVLAN_FILTER_DROP_INFO, dev); 919daae9bdSGal Pressman } 929daae9bdSGal Pressman 939daae9bdSGal Pressman static inline int vlan_get_rx_stag_filter_info(struct net_device *dev) 949daae9bdSGal Pressman { 959daae9bdSGal Pressman ASSERT_RTNL(); 969daae9bdSGal Pressman return notifier_to_errno(call_netdevice_notifiers(NETDEV_SVLAN_FILTER_PUSH_INFO, dev)); 979daae9bdSGal Pressman } 989daae9bdSGal Pressman 999daae9bdSGal Pressman static inline void vlan_drop_rx_stag_filter_info(struct net_device *dev) 1009daae9bdSGal Pressman { 1019daae9bdSGal Pressman ASSERT_RTNL(); 1029daae9bdSGal Pressman call_netdevice_notifiers(NETDEV_SVLAN_FILTER_DROP_INFO, dev); 1039daae9bdSGal Pressman } 1049daae9bdSGal Pressman 105e267cb96SDavid S. Miller /** 106e267cb96SDavid S. Miller * struct vlan_pcpu_stats - VLAN percpu rx/tx stats 107e267cb96SDavid S. Miller * @rx_packets: number of received packets 108e267cb96SDavid S. Miller * @rx_bytes: number of received bytes 109e267cb96SDavid S. Miller * @rx_multicast: number of received multicast packets 110e267cb96SDavid S. Miller * @tx_packets: number of transmitted packets 111e267cb96SDavid S. Miller * @tx_bytes: number of transmitted bytes 112e267cb96SDavid S. Miller * @syncp: synchronization point for 64bit counters 113e267cb96SDavid S. Miller * @rx_errors: number of rx errors 114e267cb96SDavid S. Miller * @tx_dropped: number of tx drops 115e267cb96SDavid S. Miller */ 116e267cb96SDavid S. Miller struct vlan_pcpu_stats { 117e267cb96SDavid S. Miller u64 rx_packets; 118e267cb96SDavid S. Miller u64 rx_bytes; 119e267cb96SDavid S. Miller u64 rx_multicast; 120e267cb96SDavid S. Miller u64 tx_packets; 121e267cb96SDavid S. Miller u64 tx_bytes; 122e267cb96SDavid S. Miller struct u64_stats_sync syncp; 123e267cb96SDavid S. Miller u32 rx_errors; 124e267cb96SDavid S. Miller u32 tx_dropped; 125e267cb96SDavid S. Miller }; 126e267cb96SDavid S. Miller 1271e85c9b6SHannes Frederic Sowa #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) 1281e85c9b6SHannes Frederic Sowa 129f06c7f9fSdingtianhong extern struct net_device *__vlan_find_dev_deep_rcu(struct net_device *real_dev, 1301e85c9b6SHannes Frederic Sowa __be16 vlan_proto, u16 vlan_id); 131960abf68SIvan Khoronzhuk extern int vlan_for_each(struct net_device *dev, 132960abf68SIvan Khoronzhuk int (*action)(struct net_device *dev, int vid, 133960abf68SIvan Khoronzhuk void *arg), void *arg); 1341e85c9b6SHannes Frederic Sowa extern struct net_device *vlan_dev_real_dev(const struct net_device *dev); 1351e85c9b6SHannes Frederic Sowa extern u16 vlan_dev_vlan_id(const struct net_device *dev); 13671e415e4Sdingtianhong extern __be16 vlan_dev_vlan_proto(const struct net_device *dev); 1371e85c9b6SHannes Frederic Sowa 1381e85c9b6SHannes Frederic Sowa /** 1391e85c9b6SHannes Frederic Sowa * struct vlan_priority_tci_mapping - vlan egress priority mappings 1401e85c9b6SHannes Frederic Sowa * @priority: skb priority 1411e85c9b6SHannes Frederic Sowa * @vlan_qos: vlan priority: (skb->priority << 13) & 0xE000 1421e85c9b6SHannes Frederic Sowa * @next: pointer to next struct 1431e85c9b6SHannes Frederic Sowa */ 1441e85c9b6SHannes Frederic Sowa struct vlan_priority_tci_mapping { 1451e85c9b6SHannes Frederic Sowa u32 priority; 1461e85c9b6SHannes Frederic Sowa u16 vlan_qos; 1471e85c9b6SHannes Frederic Sowa struct vlan_priority_tci_mapping *next; 1481e85c9b6SHannes Frederic Sowa }; 1491e85c9b6SHannes Frederic Sowa 150e267cb96SDavid S. Miller struct proc_dir_entry; 151e267cb96SDavid S. Miller struct netpoll; 152e267cb96SDavid S. Miller 153e267cb96SDavid S. Miller /** 154e267cb96SDavid S. Miller * struct vlan_dev_priv - VLAN private device data 155e267cb96SDavid S. Miller * @nr_ingress_mappings: number of ingress priority mappings 156e267cb96SDavid S. Miller * @ingress_priority_map: ingress priority mappings 157e267cb96SDavid S. Miller * @nr_egress_mappings: number of egress priority mappings 158e267cb96SDavid S. Miller * @egress_priority_map: hash of egress priority mappings 159e267cb96SDavid S. Miller * @vlan_proto: VLAN encapsulation protocol 160e267cb96SDavid S. Miller * @vlan_id: VLAN identifier 161e267cb96SDavid S. Miller * @flags: device flags 162e267cb96SDavid S. Miller * @real_dev: underlying netdevice 163e267cb96SDavid S. Miller * @real_dev_addr: address of underlying netdevice 164e267cb96SDavid S. Miller * @dent: proc dir entry 165e267cb96SDavid S. Miller * @vlan_pcpu_stats: ptr to percpu rx stats 166e267cb96SDavid S. Miller */ 167e267cb96SDavid S. Miller struct vlan_dev_priv { 168e267cb96SDavid S. Miller unsigned int nr_ingress_mappings; 169e267cb96SDavid S. Miller u32 ingress_priority_map[8]; 170e267cb96SDavid S. Miller unsigned int nr_egress_mappings; 171e267cb96SDavid S. Miller struct vlan_priority_tci_mapping *egress_priority_map[16]; 172e267cb96SDavid S. Miller 173e267cb96SDavid S. Miller __be16 vlan_proto; 174e267cb96SDavid S. Miller u16 vlan_id; 175e267cb96SDavid S. Miller u16 flags; 176e267cb96SDavid S. Miller 177e267cb96SDavid S. Miller struct net_device *real_dev; 178e267cb96SDavid S. Miller unsigned char real_dev_addr[ETH_ALEN]; 179e267cb96SDavid S. Miller 180e267cb96SDavid S. Miller struct proc_dir_entry *dent; 181e267cb96SDavid S. Miller struct vlan_pcpu_stats __percpu *vlan_pcpu_stats; 182e267cb96SDavid S. Miller #ifdef CONFIG_NET_POLL_CONTROLLER 183e267cb96SDavid S. Miller struct netpoll *netpoll; 184e267cb96SDavid S. Miller #endif 185d38569abSVlad Yasevich unsigned int nest_level; 186e267cb96SDavid S. Miller }; 187e267cb96SDavid S. Miller 188e267cb96SDavid S. Miller static inline struct vlan_dev_priv *vlan_dev_priv(const struct net_device *dev) 189e267cb96SDavid S. Miller { 190e267cb96SDavid S. Miller return netdev_priv(dev); 191e267cb96SDavid S. Miller } 192e267cb96SDavid S. Miller 193e267cb96SDavid S. Miller static inline u16 194e267cb96SDavid S. Miller vlan_dev_get_egress_qos_mask(struct net_device *dev, u32 skprio) 195e267cb96SDavid S. Miller { 196e267cb96SDavid S. Miller struct vlan_priority_tci_mapping *mp; 197e267cb96SDavid S. Miller 198e267cb96SDavid S. Miller smp_rmb(); /* coupled with smp_wmb() in vlan_dev_set_egress_priority() */ 199e267cb96SDavid S. Miller 200e267cb96SDavid S. Miller mp = vlan_dev_priv(dev)->egress_priority_map[(skprio & 0xF)]; 201e267cb96SDavid S. Miller while (mp) { 202e267cb96SDavid S. Miller if (mp->priority == skprio) { 203e267cb96SDavid S. Miller return mp->vlan_qos; /* This should already be shifted 204e267cb96SDavid S. Miller * to mask correctly with the 205e267cb96SDavid S. Miller * VLAN's TCI */ 206e267cb96SDavid S. Miller } 207e267cb96SDavid S. Miller mp = mp->next; 208e267cb96SDavid S. Miller } 209e267cb96SDavid S. Miller return 0; 210e267cb96SDavid S. Miller } 211e267cb96SDavid S. Miller 21248cc32d3SFlorian Zumbiehl extern bool vlan_do_receive(struct sk_buff **skb); 2139b22ea56SPatrick McHardy 21480d5c368SPatrick McHardy extern int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid); 21580d5c368SPatrick McHardy extern void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid); 21687002b03SJiri Pirko 217348a1443SJiri Pirko extern int vlan_vids_add_by_dev(struct net_device *dev, 218348a1443SJiri Pirko const struct net_device *by_dev); 219348a1443SJiri Pirko extern void vlan_vids_del_by_dev(struct net_device *dev, 220348a1443SJiri Pirko const struct net_device *by_dev); 2219b361c13SJiri Pirko 2229b361c13SJiri Pirko extern bool vlan_uses_dev(const struct net_device *dev); 223e1618d46SVlad Yasevich 224e1618d46SVlad Yasevich static inline int vlan_get_encap_level(struct net_device *dev) 225e1618d46SVlad Yasevich { 226e1618d46SVlad Yasevich BUG_ON(!is_vlan_dev(dev)); 227e1618d46SVlad Yasevich return vlan_dev_priv(dev)->nest_level; 228e1618d46SVlad Yasevich } 2297750f403SPatrick McHardy #else 230cec9c133SJiri Pirko static inline struct net_device * 231f06c7f9fSdingtianhong __vlan_find_dev_deep_rcu(struct net_device *real_dev, 2329fae27b3SPatrick McHardy __be16 vlan_proto, u16 vlan_id) 233cec9c133SJiri Pirko { 234cec9c133SJiri Pirko return NULL; 235cec9c133SJiri Pirko } 236cec9c133SJiri Pirko 237960abf68SIvan Khoronzhuk static inline int 238960abf68SIvan Khoronzhuk vlan_for_each(struct net_device *dev, 239960abf68SIvan Khoronzhuk int (*action)(struct net_device *dev, int vid, void *arg), 240960abf68SIvan Khoronzhuk void *arg) 241960abf68SIvan Khoronzhuk { 242960abf68SIvan Khoronzhuk return 0; 243960abf68SIvan Khoronzhuk } 244960abf68SIvan Khoronzhuk 24522d1ba74SPatrick McHardy static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev) 24622d1ba74SPatrick McHardy { 24722d1ba74SPatrick McHardy BUG(); 24822d1ba74SPatrick McHardy return NULL; 24922d1ba74SPatrick McHardy } 25022d1ba74SPatrick McHardy 25122d1ba74SPatrick McHardy static inline u16 vlan_dev_vlan_id(const struct net_device *dev) 25222d1ba74SPatrick McHardy { 25322d1ba74SPatrick McHardy BUG(); 25422d1ba74SPatrick McHardy return 0; 25522d1ba74SPatrick McHardy } 25622d1ba74SPatrick McHardy 25771e415e4Sdingtianhong static inline __be16 vlan_dev_vlan_proto(const struct net_device *dev) 25871e415e4Sdingtianhong { 25971e415e4Sdingtianhong BUG(); 26071e415e4Sdingtianhong return 0; 26171e415e4Sdingtianhong } 26271e415e4Sdingtianhong 263d3243539SEyal Perry static inline u16 vlan_dev_get_egress_qos_mask(struct net_device *dev, 264d3243539SEyal Perry u32 skprio) 265d3243539SEyal Perry { 266d3243539SEyal Perry return 0; 267d3243539SEyal Perry } 268d3243539SEyal Perry 26948cc32d3SFlorian Zumbiehl static inline bool vlan_do_receive(struct sk_buff **skb) 2709b22ea56SPatrick McHardy { 2713701e513SJesse Gross return false; 2729b22ea56SPatrick McHardy } 273e1c096e2SHerbert Xu 2749fae27b3SPatrick McHardy static inline int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid) 27587002b03SJiri Pirko { 27687002b03SJiri Pirko return 0; 27787002b03SJiri Pirko } 27887002b03SJiri Pirko 2799fae27b3SPatrick McHardy static inline void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid) 28087002b03SJiri Pirko { 28187002b03SJiri Pirko } 282348a1443SJiri Pirko 283348a1443SJiri Pirko static inline int vlan_vids_add_by_dev(struct net_device *dev, 284348a1443SJiri Pirko const struct net_device *by_dev) 285348a1443SJiri Pirko { 286348a1443SJiri Pirko return 0; 287348a1443SJiri Pirko } 288348a1443SJiri Pirko 289348a1443SJiri Pirko static inline void vlan_vids_del_by_dev(struct net_device *dev, 290348a1443SJiri Pirko const struct net_device *by_dev) 291348a1443SJiri Pirko { 292348a1443SJiri Pirko } 2939b361c13SJiri Pirko 2949b361c13SJiri Pirko static inline bool vlan_uses_dev(const struct net_device *dev) 2959b361c13SJiri Pirko { 2969b361c13SJiri Pirko return false; 2979b361c13SJiri Pirko } 298e1618d46SVlad Yasevich static inline int vlan_get_encap_level(struct net_device *dev) 299e1618d46SVlad Yasevich { 300e1618d46SVlad Yasevich BUG(); 301e1618d46SVlad Yasevich return 0; 302e1618d46SVlad Yasevich } 3037750f403SPatrick McHardy #endif 3041da177e4SLinus Torvalds 305fe19c4f9SEric Garver /** 306fe19c4f9SEric Garver * eth_type_vlan - check for valid vlan ether type. 307fe19c4f9SEric Garver * @ethertype: ether type to check 308fe19c4f9SEric Garver * 309fe19c4f9SEric Garver * Returns true if the ether type is a vlan ether type. 310fe19c4f9SEric Garver */ 311fe19c4f9SEric Garver static inline bool eth_type_vlan(__be16 ethertype) 312fe19c4f9SEric Garver { 313fe19c4f9SEric Garver switch (ethertype) { 314fe19c4f9SEric Garver case htons(ETH_P_8021Q): 315fe19c4f9SEric Garver case htons(ETH_P_8021AD): 316fe19c4f9SEric Garver return true; 317fe19c4f9SEric Garver default: 318fe19c4f9SEric Garver return false; 319fe19c4f9SEric Garver } 320fe19c4f9SEric Garver } 321fe19c4f9SEric Garver 32286a9bad3SPatrick McHardy static inline bool vlan_hw_offload_capable(netdev_features_t features, 32386a9bad3SPatrick McHardy __be16 proto) 32486a9bad3SPatrick McHardy { 32586a9bad3SPatrick McHardy if (proto == htons(ETH_P_8021Q) && features & NETIF_F_HW_VLAN_CTAG_TX) 32686a9bad3SPatrick McHardy return true; 3278ad227ffSPatrick McHardy if (proto == htons(ETH_P_8021AD) && features & NETIF_F_HW_VLAN_STAG_TX) 3288ad227ffSPatrick McHardy return true; 32986a9bad3SPatrick McHardy return false; 33086a9bad3SPatrick McHardy } 33186a9bad3SPatrick McHardy 3329bb8582eSPatrick McHardy /** 333cbe7128cSToshiaki Makita * __vlan_insert_inner_tag - inner VLAN tag inserting 334cbe7128cSToshiaki Makita * @skb: skbuff to tag 335cbe7128cSToshiaki Makita * @vlan_proto: VLAN encapsulation protocol 336cbe7128cSToshiaki Makita * @vlan_tci: VLAN TCI to insert 337cbe7128cSToshiaki Makita * @mac_len: MAC header length including outer vlan headers 338cbe7128cSToshiaki Makita * 339cbe7128cSToshiaki Makita * Inserts the VLAN tag into @skb as part of the payload at offset mac_len 3408051ac76SThadeu Lima de Souza Cascardo * Returns error if skb_cow_head fails. 341cbe7128cSToshiaki Makita * 342cbe7128cSToshiaki Makita * Does not change skb->protocol so this function can be used during receive. 343cbe7128cSToshiaki Makita */ 344cbe7128cSToshiaki Makita static inline int __vlan_insert_inner_tag(struct sk_buff *skb, 345cbe7128cSToshiaki Makita __be16 vlan_proto, u16 vlan_tci, 346cbe7128cSToshiaki Makita unsigned int mac_len) 347cbe7128cSToshiaki Makita { 348cbe7128cSToshiaki Makita struct vlan_ethhdr *veth; 349cbe7128cSToshiaki Makita 350cbe7128cSToshiaki Makita if (skb_cow_head(skb, VLAN_HLEN) < 0) 351cbe7128cSToshiaki Makita return -ENOMEM; 352cbe7128cSToshiaki Makita 353cbe7128cSToshiaki Makita skb_push(skb, VLAN_HLEN); 354cbe7128cSToshiaki Makita 355cbe7128cSToshiaki Makita /* Move the mac header sans proto to the beginning of the new header. */ 356c769accdSToshiaki Makita if (likely(mac_len > ETH_TLEN)) 357cbe7128cSToshiaki Makita memmove(skb->data, skb->data + VLAN_HLEN, mac_len - ETH_TLEN); 358cbe7128cSToshiaki Makita skb->mac_header -= VLAN_HLEN; 359cbe7128cSToshiaki Makita 360cbe7128cSToshiaki Makita veth = (struct vlan_ethhdr *)(skb->data + mac_len - ETH_HLEN); 361cbe7128cSToshiaki Makita 362cbe7128cSToshiaki Makita /* first, the ethernet type */ 363c769accdSToshiaki Makita if (likely(mac_len >= ETH_TLEN)) { 364c769accdSToshiaki Makita /* h_vlan_encapsulated_proto should already be populated, and 365c769accdSToshiaki Makita * skb->data has space for h_vlan_proto 366c769accdSToshiaki Makita */ 367cbe7128cSToshiaki Makita veth->h_vlan_proto = vlan_proto; 368c769accdSToshiaki Makita } else { 369c769accdSToshiaki Makita /* h_vlan_encapsulated_proto should not be populated, and 370c769accdSToshiaki Makita * skb->data has no space for h_vlan_proto 371c769accdSToshiaki Makita */ 372c769accdSToshiaki Makita veth->h_vlan_encapsulated_proto = skb->protocol; 373c769accdSToshiaki Makita } 374cbe7128cSToshiaki Makita 375cbe7128cSToshiaki Makita /* now, the TCI */ 376cbe7128cSToshiaki Makita veth->h_vlan_TCI = htons(vlan_tci); 377cbe7128cSToshiaki Makita 378cbe7128cSToshiaki Makita return 0; 379cbe7128cSToshiaki Makita } 380cbe7128cSToshiaki Makita 381cbe7128cSToshiaki Makita /** 38215255a43SJiri Pirko * __vlan_insert_tag - regular VLAN tag inserting 38315255a43SJiri Pirko * @skb: skbuff to tag 38415255a43SJiri Pirko * @vlan_proto: VLAN encapsulation protocol 38515255a43SJiri Pirko * @vlan_tci: VLAN TCI to insert 38615255a43SJiri Pirko * 38715255a43SJiri Pirko * Inserts the VLAN tag into @skb as part of the payload 3888051ac76SThadeu Lima de Souza Cascardo * Returns error if skb_cow_head fails. 38915255a43SJiri Pirko * 39015255a43SJiri Pirko * Does not change skb->protocol so this function can be used during receive. 39115255a43SJiri Pirko */ 39215255a43SJiri Pirko static inline int __vlan_insert_tag(struct sk_buff *skb, 39315255a43SJiri Pirko __be16 vlan_proto, u16 vlan_tci) 39415255a43SJiri Pirko { 395cbe7128cSToshiaki Makita return __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, ETH_HLEN); 396cbe7128cSToshiaki Makita } 39715255a43SJiri Pirko 398cbe7128cSToshiaki Makita /** 399cbe7128cSToshiaki Makita * vlan_insert_inner_tag - inner VLAN tag inserting 400cbe7128cSToshiaki Makita * @skb: skbuff to tag 401cbe7128cSToshiaki Makita * @vlan_proto: VLAN encapsulation protocol 402cbe7128cSToshiaki Makita * @vlan_tci: VLAN TCI to insert 403cbe7128cSToshiaki Makita * @mac_len: MAC header length including outer vlan headers 404cbe7128cSToshiaki Makita * 405cbe7128cSToshiaki Makita * Inserts the VLAN tag into @skb as part of the payload at offset mac_len 406cbe7128cSToshiaki Makita * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 407cbe7128cSToshiaki Makita * 408cbe7128cSToshiaki Makita * Following the skb_unshare() example, in case of error, the calling function 409cbe7128cSToshiaki Makita * doesn't have to worry about freeing the original skb. 410cbe7128cSToshiaki Makita * 411cbe7128cSToshiaki Makita * Does not change skb->protocol so this function can be used during receive. 412cbe7128cSToshiaki Makita */ 413cbe7128cSToshiaki Makita static inline struct sk_buff *vlan_insert_inner_tag(struct sk_buff *skb, 414cbe7128cSToshiaki Makita __be16 vlan_proto, 415cbe7128cSToshiaki Makita u16 vlan_tci, 416cbe7128cSToshiaki Makita unsigned int mac_len) 417cbe7128cSToshiaki Makita { 418cbe7128cSToshiaki Makita int err; 41915255a43SJiri Pirko 420cbe7128cSToshiaki Makita err = __vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, mac_len); 421cbe7128cSToshiaki Makita if (err) { 422cbe7128cSToshiaki Makita dev_kfree_skb_any(skb); 423cbe7128cSToshiaki Makita return NULL; 424cbe7128cSToshiaki Makita } 425cbe7128cSToshiaki Makita return skb; 42615255a43SJiri Pirko } 42715255a43SJiri Pirko 42815255a43SJiri Pirko /** 4290b5c9db1SJiri Pirko * vlan_insert_tag - regular VLAN tag inserting 4301da177e4SLinus Torvalds * @skb: skbuff to tag 43186a9bad3SPatrick McHardy * @vlan_proto: VLAN encapsulation protocol 4329bb8582eSPatrick McHardy * @vlan_tci: VLAN TCI to insert 4331da177e4SLinus Torvalds * 4341da177e4SLinus Torvalds * Inserts the VLAN tag into @skb as part of the payload 4351da177e4SLinus Torvalds * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 4361da177e4SLinus Torvalds * 4371da177e4SLinus Torvalds * Following the skb_unshare() example, in case of error, the calling function 4381da177e4SLinus Torvalds * doesn't have to worry about freeing the original skb. 4390b5c9db1SJiri Pirko * 4400b5c9db1SJiri Pirko * Does not change skb->protocol so this function can be used during receive. 4411da177e4SLinus Torvalds */ 44286a9bad3SPatrick McHardy static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, 44386a9bad3SPatrick McHardy __be16 vlan_proto, u16 vlan_tci) 4441da177e4SLinus Torvalds { 445cbe7128cSToshiaki Makita return vlan_insert_inner_tag(skb, vlan_proto, vlan_tci, ETH_HLEN); 4460b5c9db1SJiri Pirko } 4471da177e4SLinus Torvalds 4480b5c9db1SJiri Pirko /** 44962749e2cSJiri Pirko * vlan_insert_tag_set_proto - regular VLAN tag inserting 4500b5c9db1SJiri Pirko * @skb: skbuff to tag 45162749e2cSJiri Pirko * @vlan_proto: VLAN encapsulation protocol 4520b5c9db1SJiri Pirko * @vlan_tci: VLAN TCI to insert 4530b5c9db1SJiri Pirko * 4540b5c9db1SJiri Pirko * Inserts the VLAN tag into @skb as part of the payload 4550b5c9db1SJiri Pirko * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 4560b5c9db1SJiri Pirko * 4570b5c9db1SJiri Pirko * Following the skb_unshare() example, in case of error, the calling function 4580b5c9db1SJiri Pirko * doesn't have to worry about freeing the original skb. 4590b5c9db1SJiri Pirko */ 46062749e2cSJiri Pirko static inline struct sk_buff *vlan_insert_tag_set_proto(struct sk_buff *skb, 46162749e2cSJiri Pirko __be16 vlan_proto, 46262749e2cSJiri Pirko u16 vlan_tci) 4630b5c9db1SJiri Pirko { 46486a9bad3SPatrick McHardy skb = vlan_insert_tag(skb, vlan_proto, vlan_tci); 4650b5c9db1SJiri Pirko if (skb) 46686a9bad3SPatrick McHardy skb->protocol = vlan_proto; 4671da177e4SLinus Torvalds return skb; 4681da177e4SLinus Torvalds } 4691da177e4SLinus Torvalds 470c8accd5aSMichał Mirosław /** 471c8accd5aSMichał Mirosław * __vlan_hwaccel_clear_tag - clear hardware accelerated VLAN info 472c8accd5aSMichał Mirosław * @skb: skbuff to clear 473c8accd5aSMichał Mirosław * 474c8accd5aSMichał Mirosław * Clears the VLAN information from @skb 475c8accd5aSMichał Mirosław */ 476c8accd5aSMichał Mirosław static inline void __vlan_hwaccel_clear_tag(struct sk_buff *skb) 477c8accd5aSMichał Mirosław { 4780c4b2d37SMichał Mirosław skb->vlan_present = 0; 479c8accd5aSMichał Mirosław } 480c8accd5aSMichał Mirosław 481e0a6b809SMichał Mirosław /** 482e0a6b809SMichał Mirosław * __vlan_hwaccel_copy_tag - copy hardware accelerated VLAN info from another skb 483e0a6b809SMichał Mirosław * @dst: skbuff to copy to 484e0a6b809SMichał Mirosław * @src: skbuff to copy from 485e0a6b809SMichał Mirosław * 486e0a6b809SMichał Mirosław * Copies VLAN information from @src to @dst (for branchless code) 487e0a6b809SMichał Mirosław */ 488e0a6b809SMichał Mirosław static inline void __vlan_hwaccel_copy_tag(struct sk_buff *dst, const struct sk_buff *src) 489e0a6b809SMichał Mirosław { 4900c4b2d37SMichał Mirosław dst->vlan_present = src->vlan_present; 491e0a6b809SMichał Mirosław dst->vlan_proto = src->vlan_proto; 492e0a6b809SMichał Mirosław dst->vlan_tci = src->vlan_tci; 493e0a6b809SMichał Mirosław } 494e0a6b809SMichał Mirosław 4955968250cSJiri Pirko /* 4965968250cSJiri Pirko * __vlan_hwaccel_push_inside - pushes vlan tag to the payload 4975968250cSJiri Pirko * @skb: skbuff to tag 4985968250cSJiri Pirko * 4995968250cSJiri Pirko * Pushes the VLAN tag from @skb->vlan_tci inside to the payload. 5005968250cSJiri Pirko * 5015968250cSJiri Pirko * Following the skb_unshare() example, in case of error, the calling function 5025968250cSJiri Pirko * doesn't have to worry about freeing the original skb. 5035968250cSJiri Pirko */ 5045968250cSJiri Pirko static inline struct sk_buff *__vlan_hwaccel_push_inside(struct sk_buff *skb) 5055968250cSJiri Pirko { 5065968250cSJiri Pirko skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto, 507df8a39deSJiri Pirko skb_vlan_tag_get(skb)); 5085968250cSJiri Pirko if (likely(skb)) 509c8accd5aSMichał Mirosław __vlan_hwaccel_clear_tag(skb); 5105968250cSJiri Pirko return skb; 5115968250cSJiri Pirko } 5125968250cSJiri Pirko 5131da177e4SLinus Torvalds /** 5141da177e4SLinus Torvalds * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting 5151da177e4SLinus Torvalds * @skb: skbuff to tag 51686a9bad3SPatrick McHardy * @vlan_proto: VLAN encapsulation protocol 5179bb8582eSPatrick McHardy * @vlan_tci: VLAN TCI to insert 5181da177e4SLinus Torvalds * 5196aa895b0SPatrick McHardy * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest 5201da177e4SLinus Torvalds */ 521b960a0acSJiri Pirko static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb, 522b960a0acSJiri Pirko __be16 vlan_proto, u16 vlan_tci) 5231da177e4SLinus Torvalds { 52486a9bad3SPatrick McHardy skb->vlan_proto = vlan_proto; 5250c4b2d37SMichał Mirosław skb->vlan_tci = vlan_tci; 5260c4b2d37SMichał Mirosław skb->vlan_present = 1; 5271da177e4SLinus Torvalds } 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds /** 5301da177e4SLinus Torvalds * __vlan_get_tag - get the VLAN ID that is part of the payload 5311da177e4SLinus Torvalds * @skb: skbuff to query 532f4fb874cSVivien Didelot * @vlan_tci: buffer to store value 5331da177e4SLinus Torvalds * 5341da177e4SLinus Torvalds * Returns error if the skb is not of VLAN type 5351da177e4SLinus Torvalds */ 5369bb8582eSPatrick McHardy static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 5371da177e4SLinus Torvalds { 5381da177e4SLinus Torvalds struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; 5391da177e4SLinus Torvalds 540fe19c4f9SEric Garver if (!eth_type_vlan(veth->h_vlan_proto)) 5411da177e4SLinus Torvalds return -EINVAL; 5421da177e4SLinus Torvalds 5439bb8582eSPatrick McHardy *vlan_tci = ntohs(veth->h_vlan_TCI); 5441da177e4SLinus Torvalds return 0; 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds /** 5481da177e4SLinus Torvalds * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] 5491da177e4SLinus Torvalds * @skb: skbuff to query 550f4fb874cSVivien Didelot * @vlan_tci: buffer to store value 5511da177e4SLinus Torvalds * 5526aa895b0SPatrick McHardy * Returns error if @skb->vlan_tci is not set correctly 5531da177e4SLinus Torvalds */ 55418149935SPatrick McHardy static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, 5559bb8582eSPatrick McHardy u16 *vlan_tci) 5561da177e4SLinus Torvalds { 557df8a39deSJiri Pirko if (skb_vlan_tag_present(skb)) { 558df8a39deSJiri Pirko *vlan_tci = skb_vlan_tag_get(skb); 5591da177e4SLinus Torvalds return 0; 5601da177e4SLinus Torvalds } else { 5619bb8582eSPatrick McHardy *vlan_tci = 0; 5621da177e4SLinus Torvalds return -EINVAL; 5631da177e4SLinus Torvalds } 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds /** 5671da177e4SLinus Torvalds * vlan_get_tag - get the VLAN ID from the skb 5681da177e4SLinus Torvalds * @skb: skbuff to query 569f4fb874cSVivien Didelot * @vlan_tci: buffer to store value 5701da177e4SLinus Torvalds * 5711da177e4SLinus Torvalds * Returns error if the skb is not VLAN tagged 5721da177e4SLinus Torvalds */ 5739bb8582eSPatrick McHardy static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 5741da177e4SLinus Torvalds { 575f646968fSPatrick McHardy if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) { 5769bb8582eSPatrick McHardy return __vlan_hwaccel_get_tag(skb, vlan_tci); 5771da177e4SLinus Torvalds } else { 5789bb8582eSPatrick McHardy return __vlan_get_tag(skb, vlan_tci); 5791da177e4SLinus Torvalds } 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5820a85df00SHao Zheng /** 5830a85df00SHao Zheng * vlan_get_protocol - get protocol EtherType. 5840a85df00SHao Zheng * @skb: skbuff to query 585d4bcef3fSToshiaki Makita * @type: first vlan protocol 586d4bcef3fSToshiaki Makita * @depth: buffer to store length of eth and vlan tags in bytes 5870a85df00SHao Zheng * 5880a85df00SHao Zheng * Returns the EtherType of the packet, regardless of whether it is 5890a85df00SHao Zheng * vlan encapsulated (normal or hardware accelerated) or not. 5900a85df00SHao Zheng */ 591d4bcef3fSToshiaki Makita static inline __be16 __vlan_get_protocol(struct sk_buff *skb, __be16 type, 592d4bcef3fSToshiaki Makita int *depth) 5930a85df00SHao Zheng { 594d4bcef3fSToshiaki Makita unsigned int vlan_depth = skb->mac_len; 5950a85df00SHao Zheng 596d4bcef3fSToshiaki Makita /* if type is 802.1Q/AD then the header should already be 597d4bcef3fSToshiaki Makita * present at mac_len - VLAN_HLEN (if mac_len > 0), or at 598d4bcef3fSToshiaki Makita * ETH_HLEN otherwise 599d4bcef3fSToshiaki Makita */ 600fe19c4f9SEric Garver if (eth_type_vlan(type)) { 601d4bcef3fSToshiaki Makita if (vlan_depth) { 602d4bcef3fSToshiaki Makita if (WARN_ON(vlan_depth < VLAN_HLEN)) 603d4bcef3fSToshiaki Makita return 0; 604d4bcef3fSToshiaki Makita vlan_depth -= VLAN_HLEN; 605d4bcef3fSToshiaki Makita } else { 606d4bcef3fSToshiaki Makita vlan_depth = ETH_HLEN; 607d4bcef3fSToshiaki Makita } 608d4bcef3fSToshiaki Makita do { 609d4bcef3fSToshiaki Makita struct vlan_hdr *vh; 610d4bcef3fSToshiaki Makita 611d4bcef3fSToshiaki Makita if (unlikely(!pskb_may_pull(skb, 612d4bcef3fSToshiaki Makita vlan_depth + VLAN_HLEN))) 613d4bcef3fSToshiaki Makita return 0; 614d4bcef3fSToshiaki Makita 615d4bcef3fSToshiaki Makita vh = (struct vlan_hdr *)(skb->data + vlan_depth); 616d4bcef3fSToshiaki Makita type = vh->h_vlan_encapsulated_proto; 617d4bcef3fSToshiaki Makita vlan_depth += VLAN_HLEN; 618fe19c4f9SEric Garver } while (eth_type_vlan(type)); 6190a85df00SHao Zheng } 6200a85df00SHao Zheng 621d4bcef3fSToshiaki Makita if (depth) 622d4bcef3fSToshiaki Makita *depth = vlan_depth; 623d4bcef3fSToshiaki Makita 624d4bcef3fSToshiaki Makita return type; 625d4bcef3fSToshiaki Makita } 626d4bcef3fSToshiaki Makita 627d4bcef3fSToshiaki Makita /** 628d4bcef3fSToshiaki Makita * vlan_get_protocol - get protocol EtherType. 629d4bcef3fSToshiaki Makita * @skb: skbuff to query 630d4bcef3fSToshiaki Makita * 631d4bcef3fSToshiaki Makita * Returns the EtherType of the packet, regardless of whether it is 632d4bcef3fSToshiaki Makita * vlan encapsulated (normal or hardware accelerated) or not. 633d4bcef3fSToshiaki Makita */ 634d4bcef3fSToshiaki Makita static inline __be16 vlan_get_protocol(struct sk_buff *skb) 635d4bcef3fSToshiaki Makita { 636d4bcef3fSToshiaki Makita return __vlan_get_protocol(skb, skb->protocol, NULL); 6370a85df00SHao Zheng } 638396cf943SPravin B Shelar 639396cf943SPravin B Shelar static inline void vlan_set_encap_proto(struct sk_buff *skb, 640396cf943SPravin B Shelar struct vlan_hdr *vhdr) 641396cf943SPravin B Shelar { 642396cf943SPravin B Shelar __be16 proto; 643da8c8724SCong Wang unsigned short *rawp; 644396cf943SPravin B Shelar 645396cf943SPravin B Shelar /* 646396cf943SPravin B Shelar * Was a VLAN packet, grab the encapsulated protocol, which the layer 647396cf943SPravin B Shelar * three protocols care about. 648396cf943SPravin B Shelar */ 649396cf943SPravin B Shelar 650396cf943SPravin B Shelar proto = vhdr->h_vlan_encapsulated_proto; 6519545b22dSAlexander Duyck if (eth_proto_is_802_3(proto)) { 652396cf943SPravin B Shelar skb->protocol = proto; 653396cf943SPravin B Shelar return; 654396cf943SPravin B Shelar } 655396cf943SPravin B Shelar 656da8c8724SCong Wang rawp = (unsigned short *)(vhdr + 1); 657da8c8724SCong Wang if (*rawp == 0xFFFF) 658396cf943SPravin B Shelar /* 659396cf943SPravin B Shelar * This is a magic hack to spot IPX packets. Older Novell 660396cf943SPravin B Shelar * breaks the protocol design and runs IPX over 802.3 without 661396cf943SPravin B Shelar * an 802.2 LLC layer. We look for FFFF which isn't a used 662396cf943SPravin B Shelar * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 663396cf943SPravin B Shelar * but does for the rest. 664396cf943SPravin B Shelar */ 665396cf943SPravin B Shelar skb->protocol = htons(ETH_P_802_3); 666396cf943SPravin B Shelar else 667396cf943SPravin B Shelar /* 668396cf943SPravin B Shelar * Real 802.2 LLC 669396cf943SPravin B Shelar */ 670396cf943SPravin B Shelar skb->protocol = htons(ETH_P_802_2); 671396cf943SPravin B Shelar } 67244a40855SVlad Yasevich 673f5a7fb88SToshiaki Makita /** 674f5a7fb88SToshiaki Makita * skb_vlan_tagged - check if skb is vlan tagged. 675f5a7fb88SToshiaki Makita * @skb: skbuff to query 676f5a7fb88SToshiaki Makita * 677f5a7fb88SToshiaki Makita * Returns true if the skb is tagged, regardless of whether it is hardware 678f5a7fb88SToshiaki Makita * accelerated or not. 679f5a7fb88SToshiaki Makita */ 680f5a7fb88SToshiaki Makita static inline bool skb_vlan_tagged(const struct sk_buff *skb) 681f5a7fb88SToshiaki Makita { 682f5a7fb88SToshiaki Makita if (!skb_vlan_tag_present(skb) && 683fe19c4f9SEric Garver likely(!eth_type_vlan(skb->protocol))) 684f5a7fb88SToshiaki Makita return false; 685f5a7fb88SToshiaki Makita 686f5a7fb88SToshiaki Makita return true; 687f5a7fb88SToshiaki Makita } 688f5a7fb88SToshiaki Makita 689f5a7fb88SToshiaki Makita /** 690f5a7fb88SToshiaki Makita * skb_vlan_tagged_multi - check if skb is vlan tagged with multiple headers. 691f5a7fb88SToshiaki Makita * @skb: skbuff to query 692f5a7fb88SToshiaki Makita * 693f5a7fb88SToshiaki Makita * Returns true if the skb is tagged with multiple vlan headers, regardless 694f5a7fb88SToshiaki Makita * of whether it is hardware accelerated or not. 695f5a7fb88SToshiaki Makita */ 6967ce23672SToshiaki Makita static inline bool skb_vlan_tagged_multi(struct sk_buff *skb) 697f5a7fb88SToshiaki Makita { 698f5a7fb88SToshiaki Makita __be16 protocol = skb->protocol; 699f5a7fb88SToshiaki Makita 700f5a7fb88SToshiaki Makita if (!skb_vlan_tag_present(skb)) { 701f5a7fb88SToshiaki Makita struct vlan_ethhdr *veh; 702f5a7fb88SToshiaki Makita 703fe19c4f9SEric Garver if (likely(!eth_type_vlan(protocol))) 704f5a7fb88SToshiaki Makita return false; 705f5a7fb88SToshiaki Makita 7067ce23672SToshiaki Makita if (unlikely(!pskb_may_pull(skb, VLAN_ETH_HLEN))) 7077ce23672SToshiaki Makita return false; 7087ce23672SToshiaki Makita 709f5a7fb88SToshiaki Makita veh = (struct vlan_ethhdr *)skb->data; 710f5a7fb88SToshiaki Makita protocol = veh->h_vlan_encapsulated_proto; 711f5a7fb88SToshiaki Makita } 712f5a7fb88SToshiaki Makita 713fe19c4f9SEric Garver if (!eth_type_vlan(protocol)) 714f5a7fb88SToshiaki Makita return false; 715f5a7fb88SToshiaki Makita 716f5a7fb88SToshiaki Makita return true; 717f5a7fb88SToshiaki Makita } 718f5a7fb88SToshiaki Makita 7198cb65d00SToshiaki Makita /** 7208cb65d00SToshiaki Makita * vlan_features_check - drop unsafe features for skb with multiple tags. 7218cb65d00SToshiaki Makita * @skb: skbuff to query 7228cb65d00SToshiaki Makita * @features: features to be checked 7238cb65d00SToshiaki Makita * 7248cb65d00SToshiaki Makita * Returns features without unsafe ones if the skb has multiple tags. 7258cb65d00SToshiaki Makita */ 7267ce23672SToshiaki Makita static inline netdev_features_t vlan_features_check(struct sk_buff *skb, 7278cb65d00SToshiaki Makita netdev_features_t features) 7288cb65d00SToshiaki Makita { 72935d2f80bSVlad Yasevich if (skb_vlan_tagged_multi(skb)) { 73035d2f80bSVlad Yasevich /* In the case of multi-tagged packets, use a direct mask 73135d2f80bSVlad Yasevich * instead of using netdev_interesect_features(), to make 73235d2f80bSVlad Yasevich * sure that only devices supporting NETIF_F_HW_CSUM will 73335d2f80bSVlad Yasevich * have checksum offloading support. 73435d2f80bSVlad Yasevich */ 73535d2f80bSVlad Yasevich features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | 73635d2f80bSVlad Yasevich NETIF_F_FRAGLIST | NETIF_F_HW_VLAN_CTAG_TX | 73735d2f80bSVlad Yasevich NETIF_F_HW_VLAN_STAG_TX; 73835d2f80bSVlad Yasevich } 7398cb65d00SToshiaki Makita 7408cb65d00SToshiaki Makita return features; 7418cb65d00SToshiaki Makita } 7428cb65d00SToshiaki Makita 74366e5133fSToshiaki Makita /** 74466e5133fSToshiaki Makita * compare_vlan_header - Compare two vlan headers 74566e5133fSToshiaki Makita * @h1: Pointer to vlan header 74666e5133fSToshiaki Makita * @h2: Pointer to vlan header 74766e5133fSToshiaki Makita * 74866e5133fSToshiaki Makita * Compare two vlan headers, returns 0 if equal. 74966e5133fSToshiaki Makita * 75066e5133fSToshiaki Makita * Please note that alignment of h1 & h2 are only guaranteed to be 16 bits. 75166e5133fSToshiaki Makita */ 75266e5133fSToshiaki Makita static inline unsigned long compare_vlan_header(const struct vlan_hdr *h1, 75366e5133fSToshiaki Makita const struct vlan_hdr *h2) 75466e5133fSToshiaki Makita { 75566e5133fSToshiaki Makita #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) 75666e5133fSToshiaki Makita return *(u32 *)h1 ^ *(u32 *)h2; 75766e5133fSToshiaki Makita #else 75866e5133fSToshiaki Makita return ((__force u32)h1->h_vlan_TCI ^ (__force u32)h2->h_vlan_TCI) | 75966e5133fSToshiaki Makita ((__force u32)h1->h_vlan_encapsulated_proto ^ 76066e5133fSToshiaki Makita (__force u32)h2->h_vlan_encapsulated_proto); 76166e5133fSToshiaki Makita #endif 76266e5133fSToshiaki Makita } 7631da177e4SLinus Torvalds #endif /* !(_LINUX_IF_VLAN_H_) */ 764