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