Patrick McHardy | 7750f40 | 2008-07-08 03:23:36 -0700 | [diff] [blame] | 1 | #include <linux/skbuff.h> |
| 2 | #include <linux/netdevice.h> |
| 3 | #include <linux/if_vlan.h> |
Herbert Xu | 4ead443 | 2009-03-01 00:11:52 -0800 | [diff] [blame] | 4 | #include <linux/netpoll.h> |
Paul Gortmaker | bc3b2d7 | 2011-07-15 11:47:34 -0400 | [diff] [blame] | 5 | #include <linux/export.h> |
Patrick McHardy | 7750f40 | 2008-07-08 03:23:36 -0700 | [diff] [blame] | 6 | #include "vlan.h" |
| 7 | |
Florian Zumbiehl | 48cc32d3 | 2012-10-07 15:51:58 +0000 | [diff] [blame] | 8 | bool vlan_do_receive(struct sk_buff **skbp) |
Patrick McHardy | 7750f40 | 2008-07-08 03:23:36 -0700 | [diff] [blame] | 9 | { |
Jesse Gross | 3701e51 | 2010-10-20 13:56:06 +0000 | [diff] [blame] | 10 | struct sk_buff *skb = *skbp; |
| 11 | u16 vlan_id = skb->vlan_tci & VLAN_VID_MASK; |
Pedro Garcia | ad1afb0 | 2010-07-18 15:38:44 -0700 | [diff] [blame] | 12 | struct net_device *vlan_dev; |
Eric Dumazet | 4af429d | 2010-11-10 23:42:00 +0000 | [diff] [blame] | 13 | struct vlan_pcpu_stats *rx_stats; |
Pedro Garcia | ad1afb0 | 2010-07-18 15:38:44 -0700 | [diff] [blame] | 14 | |
Patrick McHardy | 1fd9b1f | 2013-04-19 02:04:29 +0000 | [diff] [blame^] | 15 | vlan_dev = vlan_find_dev(skb->dev, htons(ETH_P_8021Q), vlan_id); |
Florian Zumbiehl | 48cc32d3 | 2012-10-07 15:51:58 +0000 | [diff] [blame] | 16 | if (!vlan_dev) |
Jesse Gross | 3701e51 | 2010-10-20 13:56:06 +0000 | [diff] [blame] | 17 | return false; |
Patrick McHardy | 9b22ea5 | 2008-11-04 14:49:57 -0800 | [diff] [blame] | 18 | |
Jesse Gross | 3701e51 | 2010-10-20 13:56:06 +0000 | [diff] [blame] | 19 | skb = *skbp = skb_share_check(skb, GFP_ATOMIC); |
| 20 | if (unlikely(!skb)) |
| 21 | return false; |
Herbert Xu | e1c096e | 2009-01-06 10:50:09 -0800 | [diff] [blame] | 22 | |
Jesse Gross | 3701e51 | 2010-10-20 13:56:06 +0000 | [diff] [blame] | 23 | skb->dev = vlan_dev; |
Jiri Pirko | 0b5c9db | 2011-06-10 06:56:58 +0000 | [diff] [blame] | 24 | if (skb->pkt_type == PACKET_OTHERHOST) { |
| 25 | /* Our lower layer thinks this is not local, let's make sure. |
| 26 | * This allows the VLAN to have a different MAC than the |
| 27 | * underlying device, and still route correctly. */ |
Joe Perches | 53a2b3a | 2012-05-08 18:56:47 +0000 | [diff] [blame] | 28 | if (ether_addr_equal(eth_hdr(skb)->h_dest, vlan_dev->dev_addr)) |
Jiri Pirko | 0b5c9db | 2011-06-10 06:56:58 +0000 | [diff] [blame] | 29 | skb->pkt_type = PACKET_HOST; |
| 30 | } |
| 31 | |
Jiri Pirko | 7da82c0 | 2011-12-08 04:11:15 +0000 | [diff] [blame] | 32 | if (!(vlan_dev_priv(vlan_dev)->flags & VLAN_FLAG_REORDER_HDR)) { |
Jiri Pirko | 0b5c9db | 2011-06-10 06:56:58 +0000 | [diff] [blame] | 33 | unsigned int offset = skb->data - skb_mac_header(skb); |
| 34 | |
| 35 | /* |
| 36 | * vlan_insert_tag expect skb->data pointing to mac header. |
| 37 | * So change skb->data before calling it and change back to |
| 38 | * original position later |
| 39 | */ |
| 40 | skb_push(skb, offset); |
| 41 | skb = *skbp = vlan_insert_tag(skb, skb->vlan_tci); |
| 42 | if (!skb) |
| 43 | return false; |
| 44 | skb_pull(skb, offset + VLAN_HLEN); |
| 45 | skb_reset_mac_len(skb); |
| 46 | } |
| 47 | |
Jesse Gross | 3701e51 | 2010-10-20 13:56:06 +0000 | [diff] [blame] | 48 | skb->priority = vlan_get_ingress_priority(vlan_dev, skb->vlan_tci); |
Patrick McHardy | bc1d041 | 2008-07-14 22:49:30 -0700 | [diff] [blame] | 49 | skb->vlan_tci = 0; |
Patrick McHardy | 7750f40 | 2008-07-08 03:23:36 -0700 | [diff] [blame] | 50 | |
Jiri Pirko | 7da82c0 | 2011-12-08 04:11:15 +0000 | [diff] [blame] | 51 | rx_stats = this_cpu_ptr(vlan_dev_priv(vlan_dev)->vlan_pcpu_stats); |
Eric Dumazet | 9793241 | 2009-11-17 04:53:09 +0000 | [diff] [blame] | 52 | |
Eric Dumazet | 9618e2f | 2010-06-24 00:55:06 +0000 | [diff] [blame] | 53 | u64_stats_update_begin(&rx_stats->syncp); |
Eric Dumazet | 9793241 | 2009-11-17 04:53:09 +0000 | [diff] [blame] | 54 | rx_stats->rx_packets++; |
| 55 | rx_stats->rx_bytes += skb->len; |
Jiri Pirko | 0b5c9db | 2011-06-10 06:56:58 +0000 | [diff] [blame] | 56 | if (skb->pkt_type == PACKET_MULTICAST) |
Eric Dumazet | 9618e2f | 2010-06-24 00:55:06 +0000 | [diff] [blame] | 57 | rx_stats->rx_multicast++; |
Eric Dumazet | 9618e2f | 2010-06-24 00:55:06 +0000 | [diff] [blame] | 58 | u64_stats_update_end(&rx_stats->syncp); |
Jesse Gross | 3701e51 | 2010-10-20 13:56:06 +0000 | [diff] [blame] | 59 | |
| 60 | return true; |
Patrick McHardy | 7750f40 | 2008-07-08 03:23:36 -0700 | [diff] [blame] | 61 | } |
Patrick McHardy | 22d1ba7 | 2008-07-08 03:23:57 -0700 | [diff] [blame] | 62 | |
Jiri Pirko | 1cdfd72 | 2013-01-03 22:48:59 +0000 | [diff] [blame] | 63 | /* Must be invoked with rcu_read_lock. */ |
| 64 | struct net_device *__vlan_find_dev_deep(struct net_device *dev, |
Patrick McHardy | 1fd9b1f | 2013-04-19 02:04:29 +0000 | [diff] [blame^] | 65 | __be16 vlan_proto, u16 vlan_id) |
Jiri Pirko | cec9c13 | 2011-07-20 04:54:05 +0000 | [diff] [blame] | 66 | { |
Jiri Pirko | 1cdfd72 | 2013-01-03 22:48:59 +0000 | [diff] [blame] | 67 | struct vlan_info *vlan_info = rcu_dereference(dev->vlan_info); |
Jiri Pirko | cec9c13 | 2011-07-20 04:54:05 +0000 | [diff] [blame] | 68 | |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 69 | if (vlan_info) { |
Patrick McHardy | 1fd9b1f | 2013-04-19 02:04:29 +0000 | [diff] [blame^] | 70 | return vlan_group_get_device(&vlan_info->grp, |
| 71 | vlan_proto, vlan_id); |
Jiri Pirko | cec9c13 | 2011-07-20 04:54:05 +0000 | [diff] [blame] | 72 | } else { |
| 73 | /* |
Jiri Pirko | 1cdfd72 | 2013-01-03 22:48:59 +0000 | [diff] [blame] | 74 | * Lower devices of master uppers (bonding, team) do not have |
| 75 | * grp assigned to themselves. Grp is assigned to upper device |
| 76 | * instead. |
Jiri Pirko | cec9c13 | 2011-07-20 04:54:05 +0000 | [diff] [blame] | 77 | */ |
Jiri Pirko | 1cdfd72 | 2013-01-03 22:48:59 +0000 | [diff] [blame] | 78 | struct net_device *upper_dev; |
| 79 | |
| 80 | upper_dev = netdev_master_upper_dev_get_rcu(dev); |
| 81 | if (upper_dev) |
Patrick McHardy | 1fd9b1f | 2013-04-19 02:04:29 +0000 | [diff] [blame^] | 82 | return __vlan_find_dev_deep(upper_dev, |
| 83 | vlan_proto, vlan_id); |
Jiri Pirko | cec9c13 | 2011-07-20 04:54:05 +0000 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | return NULL; |
| 87 | } |
| 88 | EXPORT_SYMBOL(__vlan_find_dev_deep); |
| 89 | |
Patrick McHardy | 22d1ba7 | 2008-07-08 03:23:57 -0700 | [diff] [blame] | 90 | struct net_device *vlan_dev_real_dev(const struct net_device *dev) |
| 91 | { |
Jiri Pirko | 7da82c0 | 2011-12-08 04:11:15 +0000 | [diff] [blame] | 92 | return vlan_dev_priv(dev)->real_dev; |
Patrick McHardy | 22d1ba7 | 2008-07-08 03:23:57 -0700 | [diff] [blame] | 93 | } |
Ben Greear | 116cb42 | 2009-01-26 12:37:53 -0800 | [diff] [blame] | 94 | EXPORT_SYMBOL(vlan_dev_real_dev); |
Patrick McHardy | 22d1ba7 | 2008-07-08 03:23:57 -0700 | [diff] [blame] | 95 | |
| 96 | u16 vlan_dev_vlan_id(const struct net_device *dev) |
| 97 | { |
Jiri Pirko | 7da82c0 | 2011-12-08 04:11:15 +0000 | [diff] [blame] | 98 | return vlan_dev_priv(dev)->vlan_id; |
Patrick McHardy | 22d1ba7 | 2008-07-08 03:23:57 -0700 | [diff] [blame] | 99 | } |
Ben Greear | 116cb42 | 2009-01-26 12:37:53 -0800 | [diff] [blame] | 100 | EXPORT_SYMBOL(vlan_dev_vlan_id); |
Herbert Xu | e1c096e | 2009-01-06 10:50:09 -0800 | [diff] [blame] | 101 | |
Jiri Pirko | 0b5c9db | 2011-06-10 06:56:58 +0000 | [diff] [blame] | 102 | static struct sk_buff *vlan_reorder_header(struct sk_buff *skb) |
Jiri Pirko | bcc6d47 | 2011-04-07 19:48:33 +0000 | [diff] [blame] | 103 | { |
Jiri Pirko | 0b5c9db | 2011-06-10 06:56:58 +0000 | [diff] [blame] | 104 | if (skb_cow(skb, skb_headroom(skb)) < 0) |
| 105 | return NULL; |
| 106 | memmove(skb->data - ETH_HLEN, skb->data - VLAN_ETH_HLEN, 2 * ETH_ALEN); |
| 107 | skb->mac_header += VLAN_HLEN; |
Jiri Pirko | bcc6d47 | 2011-04-07 19:48:33 +0000 | [diff] [blame] | 108 | return skb; |
| 109 | } |
| 110 | |
Jiri Pirko | bcc6d47 | 2011-04-07 19:48:33 +0000 | [diff] [blame] | 111 | struct sk_buff *vlan_untag(struct sk_buff *skb) |
| 112 | { |
| 113 | struct vlan_hdr *vhdr; |
| 114 | u16 vlan_tci; |
| 115 | |
| 116 | if (unlikely(vlan_tx_tag_present(skb))) { |
| 117 | /* vlan_tci is already set-up so leave this for another time */ |
| 118 | return skb; |
| 119 | } |
| 120 | |
| 121 | skb = skb_share_check(skb, GFP_ATOMIC); |
| 122 | if (unlikely(!skb)) |
| 123 | goto err_free; |
| 124 | |
| 125 | if (unlikely(!pskb_may_pull(skb, VLAN_HLEN))) |
| 126 | goto err_free; |
| 127 | |
| 128 | vhdr = (struct vlan_hdr *) skb->data; |
| 129 | vlan_tci = ntohs(vhdr->h_vlan_TCI); |
| 130 | __vlan_hwaccel_put_tag(skb, vlan_tci); |
| 131 | |
| 132 | skb_pull_rcsum(skb, VLAN_HLEN); |
| 133 | vlan_set_encap_proto(skb, vhdr); |
| 134 | |
Jiri Pirko | 0b5c9db | 2011-06-10 06:56:58 +0000 | [diff] [blame] | 135 | skb = vlan_reorder_header(skb); |
Jiri Pirko | bcc6d47 | 2011-04-07 19:48:33 +0000 | [diff] [blame] | 136 | if (unlikely(!skb)) |
| 137 | goto err_free; |
| 138 | |
Jiri Pirko | c5114cd | 2011-08-18 21:29:27 -0700 | [diff] [blame] | 139 | skb_reset_network_header(skb); |
| 140 | skb_reset_transport_header(skb); |
Antonio Quartulli | 5316cf9 | 2012-10-02 06:14:17 +0000 | [diff] [blame] | 141 | skb_reset_mac_len(skb); |
| 142 | |
Jiri Pirko | bcc6d47 | 2011-04-07 19:48:33 +0000 | [diff] [blame] | 143 | return skb; |
| 144 | |
| 145 | err_free: |
| 146 | kfree_skb(skb); |
| 147 | return NULL; |
| 148 | } |
Vlad Yasevich | 7885198 | 2013-02-13 12:00:14 +0000 | [diff] [blame] | 149 | EXPORT_SYMBOL(vlan_untag); |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 150 | |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 151 | |
| 152 | /* |
| 153 | * vlan info and vid list |
| 154 | */ |
| 155 | |
| 156 | static void vlan_group_free(struct vlan_group *grp) |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 157 | { |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 158 | int i; |
| 159 | |
| 160 | for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++) |
| 161 | kfree(grp->vlan_devices_arrays[i]); |
| 162 | } |
| 163 | |
| 164 | static void vlan_info_free(struct vlan_info *vlan_info) |
| 165 | { |
| 166 | vlan_group_free(&vlan_info->grp); |
| 167 | kfree(vlan_info); |
| 168 | } |
| 169 | |
| 170 | static void vlan_info_rcu_free(struct rcu_head *rcu) |
| 171 | { |
| 172 | vlan_info_free(container_of(rcu, struct vlan_info, rcu)); |
| 173 | } |
| 174 | |
| 175 | static struct vlan_info *vlan_info_alloc(struct net_device *dev) |
| 176 | { |
| 177 | struct vlan_info *vlan_info; |
| 178 | |
| 179 | vlan_info = kzalloc(sizeof(struct vlan_info), GFP_KERNEL); |
| 180 | if (!vlan_info) |
| 181 | return NULL; |
| 182 | |
| 183 | vlan_info->real_dev = dev; |
| 184 | INIT_LIST_HEAD(&vlan_info->vid_list); |
| 185 | return vlan_info; |
| 186 | } |
| 187 | |
| 188 | struct vlan_vid_info { |
| 189 | struct list_head list; |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 190 | __be16 proto; |
| 191 | u16 vid; |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 192 | int refcount; |
| 193 | }; |
| 194 | |
| 195 | static struct vlan_vid_info *vlan_vid_info_get(struct vlan_info *vlan_info, |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 196 | __be16 proto, u16 vid) |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 197 | { |
| 198 | struct vlan_vid_info *vid_info; |
| 199 | |
| 200 | list_for_each_entry(vid_info, &vlan_info->vid_list, list) { |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 201 | if (vid_info->proto == proto && vid_info->vid == vid) |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 202 | return vid_info; |
| 203 | } |
| 204 | return NULL; |
| 205 | } |
| 206 | |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 207 | static struct vlan_vid_info *vlan_vid_info_alloc(__be16 proto, u16 vid) |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 208 | { |
| 209 | struct vlan_vid_info *vid_info; |
| 210 | |
| 211 | vid_info = kzalloc(sizeof(struct vlan_vid_info), GFP_KERNEL); |
| 212 | if (!vid_info) |
| 213 | return NULL; |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 214 | vid_info->proto = proto; |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 215 | vid_info->vid = vid; |
| 216 | |
| 217 | return vid_info; |
| 218 | } |
| 219 | |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 220 | static int __vlan_vid_add(struct vlan_info *vlan_info, __be16 proto, u16 vid, |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 221 | struct vlan_vid_info **pvid_info) |
| 222 | { |
| 223 | struct net_device *dev = vlan_info->real_dev; |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 224 | const struct net_device_ops *ops = dev->netdev_ops; |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 225 | struct vlan_vid_info *vid_info; |
| 226 | int err; |
| 227 | |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 228 | vid_info = vlan_vid_info_alloc(proto, vid); |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 229 | if (!vid_info) |
| 230 | return -ENOMEM; |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 231 | |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 232 | if (proto == htons(ETH_P_8021Q) && |
| 233 | dev->features & NETIF_F_HW_VLAN_CTAG_FILTER) { |
| 234 | err = ops->ndo_vlan_rx_add_vid(dev, proto, vid); |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 235 | if (err) { |
| 236 | kfree(vid_info); |
| 237 | return err; |
| 238 | } |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 239 | } |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 240 | list_add(&vid_info->list, &vlan_info->vid_list); |
| 241 | vlan_info->nr_vids++; |
| 242 | *pvid_info = vid_info; |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 243 | return 0; |
| 244 | } |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 245 | |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 246 | int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid) |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 247 | { |
| 248 | struct vlan_info *vlan_info; |
| 249 | struct vlan_vid_info *vid_info; |
| 250 | bool vlan_info_created = false; |
| 251 | int err; |
| 252 | |
| 253 | ASSERT_RTNL(); |
| 254 | |
| 255 | vlan_info = rtnl_dereference(dev->vlan_info); |
| 256 | if (!vlan_info) { |
| 257 | vlan_info = vlan_info_alloc(dev); |
| 258 | if (!vlan_info) |
| 259 | return -ENOMEM; |
| 260 | vlan_info_created = true; |
| 261 | } |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 262 | vid_info = vlan_vid_info_get(vlan_info, proto, vid); |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 263 | if (!vid_info) { |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 264 | err = __vlan_vid_add(vlan_info, proto, vid, &vid_info); |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 265 | if (err) |
| 266 | goto out_free_vlan_info; |
| 267 | } |
| 268 | vid_info->refcount++; |
| 269 | |
| 270 | if (vlan_info_created) |
| 271 | rcu_assign_pointer(dev->vlan_info, vlan_info); |
| 272 | |
| 273 | return 0; |
| 274 | |
| 275 | out_free_vlan_info: |
| 276 | if (vlan_info_created) |
| 277 | kfree(vlan_info); |
| 278 | return err; |
| 279 | } |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 280 | EXPORT_SYMBOL(vlan_vid_add); |
| 281 | |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 282 | static void __vlan_vid_del(struct vlan_info *vlan_info, |
| 283 | struct vlan_vid_info *vid_info) |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 284 | { |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 285 | struct net_device *dev = vlan_info->real_dev; |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 286 | const struct net_device_ops *ops = dev->netdev_ops; |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 287 | __be16 proto = vid_info->proto; |
| 288 | u16 vid = vid_info->vid; |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 289 | int err; |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 290 | |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 291 | if (proto == htons(ETH_P_8021Q) && |
| 292 | dev->features & NETIF_F_HW_VLAN_CTAG_FILTER) { |
| 293 | err = ops->ndo_vlan_rx_kill_vid(dev, proto, vid); |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 294 | if (err) { |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 295 | pr_warn("failed to kill vid %04x/%d for device %s\n", |
| 296 | proto, vid, dev->name); |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 297 | } |
| 298 | } |
| 299 | list_del(&vid_info->list); |
| 300 | kfree(vid_info); |
| 301 | vlan_info->nr_vids--; |
| 302 | } |
| 303 | |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 304 | void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid) |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 305 | { |
| 306 | struct vlan_info *vlan_info; |
| 307 | struct vlan_vid_info *vid_info; |
| 308 | |
| 309 | ASSERT_RTNL(); |
| 310 | |
| 311 | vlan_info = rtnl_dereference(dev->vlan_info); |
| 312 | if (!vlan_info) |
| 313 | return; |
| 314 | |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 315 | vid_info = vlan_vid_info_get(vlan_info, proto, vid); |
Jiri Pirko | 5b9ea6e | 2011-12-08 04:11:18 +0000 | [diff] [blame] | 316 | if (!vid_info) |
| 317 | return; |
| 318 | vid_info->refcount--; |
| 319 | if (vid_info->refcount == 0) { |
| 320 | __vlan_vid_del(vlan_info, vid_info); |
| 321 | if (vlan_info->nr_vids == 0) { |
| 322 | RCU_INIT_POINTER(dev->vlan_info, NULL); |
| 323 | call_rcu(&vlan_info->rcu, vlan_info_rcu_free); |
| 324 | } |
Jiri Pirko | 87002b0 | 2011-12-08 04:11:17 +0000 | [diff] [blame] | 325 | } |
| 326 | } |
| 327 | EXPORT_SYMBOL(vlan_vid_del); |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 328 | |
| 329 | int vlan_vids_add_by_dev(struct net_device *dev, |
| 330 | const struct net_device *by_dev) |
| 331 | { |
| 332 | struct vlan_vid_info *vid_info; |
Dan Carpenter | f9586f7 | 2011-12-13 20:29:43 +0000 | [diff] [blame] | 333 | struct vlan_info *vlan_info; |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 334 | int err; |
| 335 | |
| 336 | ASSERT_RTNL(); |
| 337 | |
Dan Carpenter | f9586f7 | 2011-12-13 20:29:43 +0000 | [diff] [blame] | 338 | vlan_info = rtnl_dereference(by_dev->vlan_info); |
| 339 | if (!vlan_info) |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 340 | return 0; |
| 341 | |
Dan Carpenter | f9586f7 | 2011-12-13 20:29:43 +0000 | [diff] [blame] | 342 | list_for_each_entry(vid_info, &vlan_info->vid_list, list) { |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 343 | err = vlan_vid_add(dev, vid_info->proto, vid_info->vid); |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 344 | if (err) |
| 345 | goto unwind; |
| 346 | } |
| 347 | return 0; |
| 348 | |
| 349 | unwind: |
| 350 | list_for_each_entry_continue_reverse(vid_info, |
Dan Carpenter | f9586f7 | 2011-12-13 20:29:43 +0000 | [diff] [blame] | 351 | &vlan_info->vid_list, |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 352 | list) { |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 353 | vlan_vid_del(dev, vid_info->proto, vid_info->vid); |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 354 | } |
| 355 | |
| 356 | return err; |
| 357 | } |
| 358 | EXPORT_SYMBOL(vlan_vids_add_by_dev); |
| 359 | |
| 360 | void vlan_vids_del_by_dev(struct net_device *dev, |
| 361 | const struct net_device *by_dev) |
| 362 | { |
| 363 | struct vlan_vid_info *vid_info; |
Dan Carpenter | f9586f7 | 2011-12-13 20:29:43 +0000 | [diff] [blame] | 364 | struct vlan_info *vlan_info; |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 365 | |
| 366 | ASSERT_RTNL(); |
| 367 | |
Dan Carpenter | f9586f7 | 2011-12-13 20:29:43 +0000 | [diff] [blame] | 368 | vlan_info = rtnl_dereference(by_dev->vlan_info); |
| 369 | if (!vlan_info) |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 370 | return; |
| 371 | |
Dan Carpenter | f9586f7 | 2011-12-13 20:29:43 +0000 | [diff] [blame] | 372 | list_for_each_entry(vid_info, &vlan_info->vid_list, list) |
Patrick McHardy | 80d5c36 | 2013-04-19 02:04:28 +0000 | [diff] [blame] | 373 | vlan_vid_del(dev, vid_info->proto, vid_info->vid); |
Jiri Pirko | 348a144 | 2011-12-08 04:11:19 +0000 | [diff] [blame] | 374 | } |
| 375 | EXPORT_SYMBOL(vlan_vids_del_by_dev); |
Jiri Pirko | 9b361c1 | 2012-08-23 03:26:52 +0000 | [diff] [blame] | 376 | |
| 377 | bool vlan_uses_dev(const struct net_device *dev) |
| 378 | { |
Jiri Pirko | 55462cf | 2012-10-14 04:30:56 +0000 | [diff] [blame] | 379 | struct vlan_info *vlan_info; |
| 380 | |
| 381 | ASSERT_RTNL(); |
| 382 | |
| 383 | vlan_info = rtnl_dereference(dev->vlan_info); |
| 384 | if (!vlan_info) |
| 385 | return false; |
| 386 | return vlan_info->grp.nr_vlan_devs ? true : false; |
Jiri Pirko | 9b361c1 | 2012-08-23 03:26:52 +0000 | [diff] [blame] | 387 | } |
| 388 | EXPORT_SYMBOL(vlan_uses_dev); |