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