xref: /openbmc/linux/net/8021q/vlan.c (revision 5f32c314)
1  /*
2   * INET		802.1Q VLAN
3   *		Ethernet-type device handling.
4   *
5   * Authors:	Ben Greear <greearb@candelatech.com>
6   *              Please send support related email to: netdev@vger.kernel.org
7   *              VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
8   *
9   * Fixes:
10   *              Fix for packet capture - Nick Eggleston <nick@dccinc.com>;
11   *		Add HW acceleration hooks - David S. Miller <davem@redhat.com>;
12   *		Correct all the locking - David S. Miller <davem@redhat.com>;
13   *		Use hash table for VLAN groups - David S. Miller <davem@redhat.com>
14   *
15   *		This program is free software; you can redistribute it and/or
16   *		modify it under the terms of the GNU General Public License
17   *		as published by the Free Software Foundation; either version
18   *		2 of the License, or (at your option) any later version.
19   */
20  
21  #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22  
23  #include <linux/capability.h>
24  #include <linux/module.h>
25  #include <linux/netdevice.h>
26  #include <linux/skbuff.h>
27  #include <linux/slab.h>
28  #include <linux/init.h>
29  #include <linux/rculist.h>
30  #include <net/p8022.h>
31  #include <net/arp.h>
32  #include <linux/rtnetlink.h>
33  #include <linux/notifier.h>
34  #include <net/rtnetlink.h>
35  #include <net/net_namespace.h>
36  #include <net/netns/generic.h>
37  #include <asm/uaccess.h>
38  
39  #include <linux/if_vlan.h>
40  #include "vlan.h"
41  #include "vlanproc.h"
42  
43  #define DRV_VERSION "1.8"
44  
45  /* Global VLAN variables */
46  
47  int vlan_net_id __read_mostly;
48  
49  const char vlan_fullname[] = "802.1Q VLAN Support";
50  const char vlan_version[] = DRV_VERSION;
51  
52  /* End of global variables definitions. */
53  
54  static int vlan_group_prealloc_vid(struct vlan_group *vg,
55  				   __be16 vlan_proto, u16 vlan_id)
56  {
57  	struct net_device **array;
58  	unsigned int pidx, vidx;
59  	unsigned int size;
60  
61  	ASSERT_RTNL();
62  
63  	pidx  = vlan_proto_idx(vlan_proto);
64  	vidx  = vlan_id / VLAN_GROUP_ARRAY_PART_LEN;
65  	array = vg->vlan_devices_arrays[pidx][vidx];
66  	if (array != NULL)
67  		return 0;
68  
69  	size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN;
70  	array = kzalloc(size, GFP_KERNEL);
71  	if (array == NULL)
72  		return -ENOBUFS;
73  
74  	vg->vlan_devices_arrays[pidx][vidx] = array;
75  	return 0;
76  }
77  
78  void unregister_vlan_dev(struct net_device *dev, struct list_head *head)
79  {
80  	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
81  	struct net_device *real_dev = vlan->real_dev;
82  	struct vlan_info *vlan_info;
83  	struct vlan_group *grp;
84  	u16 vlan_id = vlan->vlan_id;
85  
86  	ASSERT_RTNL();
87  
88  	vlan_info = rtnl_dereference(real_dev->vlan_info);
89  	BUG_ON(!vlan_info);
90  
91  	grp = &vlan_info->grp;
92  
93  	grp->nr_vlan_devs--;
94  
95  	if (vlan->flags & VLAN_FLAG_MVRP)
96  		vlan_mvrp_request_leave(dev);
97  	if (vlan->flags & VLAN_FLAG_GVRP)
98  		vlan_gvrp_request_leave(dev);
99  
100  	vlan_group_set_device(grp, vlan->vlan_proto, vlan_id, NULL);
101  
102  	netdev_upper_dev_unlink(real_dev, dev);
103  	/* Because unregister_netdevice_queue() makes sure at least one rcu
104  	 * grace period is respected before device freeing,
105  	 * we dont need to call synchronize_net() here.
106  	 */
107  	unregister_netdevice_queue(dev, head);
108  
109  	if (grp->nr_vlan_devs == 0) {
110  		vlan_mvrp_uninit_applicant(real_dev);
111  		vlan_gvrp_uninit_applicant(real_dev);
112  	}
113  
114  	/* Take it out of our own structures, but be sure to interlock with
115  	 * HW accelerating devices or SW vlan input packet processing if
116  	 * VLAN is not 0 (leave it there for 802.1p).
117  	 */
118  	if (vlan_id)
119  		vlan_vid_del(real_dev, vlan->vlan_proto, vlan_id);
120  
121  	/* Get rid of the vlan's reference to real_dev */
122  	dev_put(real_dev);
123  }
124  
125  int vlan_check_real_dev(struct net_device *real_dev,
126  			__be16 protocol, u16 vlan_id)
127  {
128  	const char *name = real_dev->name;
129  
130  	if (real_dev->features & NETIF_F_VLAN_CHALLENGED) {
131  		pr_info("VLANs not supported on %s\n", name);
132  		return -EOPNOTSUPP;
133  	}
134  
135  	if (vlan_find_dev(real_dev, protocol, vlan_id) != NULL)
136  		return -EEXIST;
137  
138  	return 0;
139  }
140  
141  int register_vlan_dev(struct net_device *dev)
142  {
143  	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
144  	struct net_device *real_dev = vlan->real_dev;
145  	u16 vlan_id = vlan->vlan_id;
146  	struct vlan_info *vlan_info;
147  	struct vlan_group *grp;
148  	int err;
149  
150  	err = vlan_vid_add(real_dev, vlan->vlan_proto, vlan_id);
151  	if (err)
152  		return err;
153  
154  	vlan_info = rtnl_dereference(real_dev->vlan_info);
155  	/* vlan_info should be there now. vlan_vid_add took care of it */
156  	BUG_ON(!vlan_info);
157  
158  	grp = &vlan_info->grp;
159  	if (grp->nr_vlan_devs == 0) {
160  		err = vlan_gvrp_init_applicant(real_dev);
161  		if (err < 0)
162  			goto out_vid_del;
163  		err = vlan_mvrp_init_applicant(real_dev);
164  		if (err < 0)
165  			goto out_uninit_gvrp;
166  	}
167  
168  	err = vlan_group_prealloc_vid(grp, vlan->vlan_proto, vlan_id);
169  	if (err < 0)
170  		goto out_uninit_mvrp;
171  
172  	err = register_netdevice(dev);
173  	if (err < 0)
174  		goto out_uninit_mvrp;
175  
176  	err = netdev_upper_dev_link(real_dev, dev);
177  	if (err)
178  		goto out_unregister_netdev;
179  
180  	/* Account for reference in struct vlan_dev_priv */
181  	dev_hold(real_dev);
182  
183  	netif_stacked_transfer_operstate(real_dev, dev);
184  	linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */
185  
186  	/* So, got the sucker initialized, now lets place
187  	 * it into our local structure.
188  	 */
189  	vlan_group_set_device(grp, vlan->vlan_proto, vlan_id, dev);
190  	grp->nr_vlan_devs++;
191  
192  	return 0;
193  
194  out_unregister_netdev:
195  	unregister_netdevice(dev);
196  out_uninit_mvrp:
197  	if (grp->nr_vlan_devs == 0)
198  		vlan_mvrp_uninit_applicant(real_dev);
199  out_uninit_gvrp:
200  	if (grp->nr_vlan_devs == 0)
201  		vlan_gvrp_uninit_applicant(real_dev);
202  out_vid_del:
203  	vlan_vid_del(real_dev, vlan->vlan_proto, vlan_id);
204  	return err;
205  }
206  
207  /*  Attach a VLAN device to a mac address (ie Ethernet Card).
208   *  Returns 0 if the device was created or a negative error code otherwise.
209   */
210  static int register_vlan_device(struct net_device *real_dev, u16 vlan_id)
211  {
212  	struct net_device *new_dev;
213  	struct vlan_dev_priv *vlan;
214  	struct net *net = dev_net(real_dev);
215  	struct vlan_net *vn = net_generic(net, vlan_net_id);
216  	char name[IFNAMSIZ];
217  	int err;
218  
219  	if (vlan_id >= VLAN_VID_MASK)
220  		return -ERANGE;
221  
222  	err = vlan_check_real_dev(real_dev, htons(ETH_P_8021Q), vlan_id);
223  	if (err < 0)
224  		return err;
225  
226  	/* Gotta set up the fields for the device. */
227  	switch (vn->name_type) {
228  	case VLAN_NAME_TYPE_RAW_PLUS_VID:
229  		/* name will look like:	 eth1.0005 */
230  		snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, vlan_id);
231  		break;
232  	case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:
233  		/* Put our vlan.VID in the name.
234  		 * Name will look like:	 vlan5
235  		 */
236  		snprintf(name, IFNAMSIZ, "vlan%i", vlan_id);
237  		break;
238  	case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:
239  		/* Put our vlan.VID in the name.
240  		 * Name will look like:	 eth0.5
241  		 */
242  		snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, vlan_id);
243  		break;
244  	case VLAN_NAME_TYPE_PLUS_VID:
245  		/* Put our vlan.VID in the name.
246  		 * Name will look like:	 vlan0005
247  		 */
248  	default:
249  		snprintf(name, IFNAMSIZ, "vlan%.4i", vlan_id);
250  	}
251  
252  	new_dev = alloc_netdev(sizeof(struct vlan_dev_priv), name, vlan_setup);
253  
254  	if (new_dev == NULL)
255  		return -ENOBUFS;
256  
257  	dev_net_set(new_dev, net);
258  	/* need 4 bytes for extra VLAN header info,
259  	 * hope the underlying device can handle it.
260  	 */
261  	new_dev->mtu = real_dev->mtu;
262  	new_dev->priv_flags |= (real_dev->priv_flags & IFF_UNICAST_FLT);
263  
264  	vlan = vlan_dev_priv(new_dev);
265  	vlan->vlan_proto = htons(ETH_P_8021Q);
266  	vlan->vlan_id = vlan_id;
267  	vlan->real_dev = real_dev;
268  	vlan->dent = NULL;
269  	vlan->flags = VLAN_FLAG_REORDER_HDR;
270  
271  	new_dev->rtnl_link_ops = &vlan_link_ops;
272  	err = register_vlan_dev(new_dev);
273  	if (err < 0)
274  		goto out_free_newdev;
275  
276  	return 0;
277  
278  out_free_newdev:
279  	free_netdev(new_dev);
280  	return err;
281  }
282  
283  static void vlan_sync_address(struct net_device *dev,
284  			      struct net_device *vlandev)
285  {
286  	struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev);
287  
288  	/* May be called without an actual change */
289  	if (ether_addr_equal(vlan->real_dev_addr, dev->dev_addr))
290  		return;
291  
292  	/* vlan address was different from the old address and is equal to
293  	 * the new address */
294  	if (!ether_addr_equal(vlandev->dev_addr, vlan->real_dev_addr) &&
295  	    ether_addr_equal(vlandev->dev_addr, dev->dev_addr))
296  		dev_uc_del(dev, vlandev->dev_addr);
297  
298  	/* vlan address was equal to the old address and is different from
299  	 * the new address */
300  	if (ether_addr_equal(vlandev->dev_addr, vlan->real_dev_addr) &&
301  	    !ether_addr_equal(vlandev->dev_addr, dev->dev_addr))
302  		dev_uc_add(dev, vlandev->dev_addr);
303  
304  	ether_addr_copy(vlan->real_dev_addr, dev->dev_addr);
305  }
306  
307  static void vlan_transfer_features(struct net_device *dev,
308  				   struct net_device *vlandev)
309  {
310  	vlandev->gso_max_size = dev->gso_max_size;
311  
312  	if (dev->features & NETIF_F_HW_VLAN_CTAG_TX)
313  		vlandev->hard_header_len = dev->hard_header_len;
314  	else
315  		vlandev->hard_header_len = dev->hard_header_len + VLAN_HLEN;
316  
317  #if IS_ENABLED(CONFIG_FCOE)
318  	vlandev->fcoe_ddp_xid = dev->fcoe_ddp_xid;
319  #endif
320  
321  	netdev_update_features(vlandev);
322  }
323  
324  static void __vlan_device_event(struct net_device *dev, unsigned long event)
325  {
326  	switch (event) {
327  	case NETDEV_CHANGENAME:
328  		vlan_proc_rem_dev(dev);
329  		if (vlan_proc_add_dev(dev) < 0)
330  			pr_warn("failed to change proc name for %s\n",
331  				dev->name);
332  		break;
333  	case NETDEV_REGISTER:
334  		if (vlan_proc_add_dev(dev) < 0)
335  			pr_warn("failed to add proc entry for %s\n", dev->name);
336  		break;
337  	case NETDEV_UNREGISTER:
338  		vlan_proc_rem_dev(dev);
339  		break;
340  	}
341  }
342  
343  static int vlan_device_event(struct notifier_block *unused, unsigned long event,
344  			     void *ptr)
345  {
346  	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
347  	struct vlan_group *grp;
348  	struct vlan_info *vlan_info;
349  	int i, flgs;
350  	struct net_device *vlandev;
351  	struct vlan_dev_priv *vlan;
352  	bool last = false;
353  	LIST_HEAD(list);
354  
355  	if (is_vlan_dev(dev))
356  		__vlan_device_event(dev, event);
357  
358  	if ((event == NETDEV_UP) &&
359  	    (dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) {
360  		pr_info("adding VLAN 0 to HW filter on device %s\n",
361  			dev->name);
362  		vlan_vid_add(dev, htons(ETH_P_8021Q), 0);
363  	}
364  
365  	vlan_info = rtnl_dereference(dev->vlan_info);
366  	if (!vlan_info)
367  		goto out;
368  	grp = &vlan_info->grp;
369  
370  	/* It is OK that we do not hold the group lock right now,
371  	 * as we run under the RTNL lock.
372  	 */
373  
374  	switch (event) {
375  	case NETDEV_CHANGE:
376  		/* Propagate real device state to vlan devices */
377  		vlan_group_for_each_dev(grp, i, vlandev)
378  			netif_stacked_transfer_operstate(dev, vlandev);
379  		break;
380  
381  	case NETDEV_CHANGEADDR:
382  		/* Adjust unicast filters on underlying device */
383  		vlan_group_for_each_dev(grp, i, vlandev) {
384  			flgs = vlandev->flags;
385  			if (!(flgs & IFF_UP))
386  				continue;
387  
388  			vlan_sync_address(dev, vlandev);
389  		}
390  		break;
391  
392  	case NETDEV_CHANGEMTU:
393  		vlan_group_for_each_dev(grp, i, vlandev) {
394  			if (vlandev->mtu <= dev->mtu)
395  				continue;
396  
397  			dev_set_mtu(vlandev, dev->mtu);
398  		}
399  		break;
400  
401  	case NETDEV_FEAT_CHANGE:
402  		/* Propagate device features to underlying device */
403  		vlan_group_for_each_dev(grp, i, vlandev)
404  			vlan_transfer_features(dev, vlandev);
405  		break;
406  
407  	case NETDEV_DOWN:
408  		if (dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
409  			vlan_vid_del(dev, htons(ETH_P_8021Q), 0);
410  
411  		/* Put all VLANs for this dev in the down state too.  */
412  		vlan_group_for_each_dev(grp, i, vlandev) {
413  			flgs = vlandev->flags;
414  			if (!(flgs & IFF_UP))
415  				continue;
416  
417  			vlan = vlan_dev_priv(vlandev);
418  			if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
419  				dev_change_flags(vlandev, flgs & ~IFF_UP);
420  			netif_stacked_transfer_operstate(dev, vlandev);
421  		}
422  		break;
423  
424  	case NETDEV_UP:
425  		/* Put all VLANs for this dev in the up state too.  */
426  		vlan_group_for_each_dev(grp, i, vlandev) {
427  			flgs = vlandev->flags;
428  			if (flgs & IFF_UP)
429  				continue;
430  
431  			vlan = vlan_dev_priv(vlandev);
432  			if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
433  				dev_change_flags(vlandev, flgs | IFF_UP);
434  			netif_stacked_transfer_operstate(dev, vlandev);
435  		}
436  		break;
437  
438  	case NETDEV_UNREGISTER:
439  		/* twiddle thumbs on netns device moves */
440  		if (dev->reg_state != NETREG_UNREGISTERING)
441  			break;
442  
443  		vlan_group_for_each_dev(grp, i, vlandev) {
444  			/* removal of last vid destroys vlan_info, abort
445  			 * afterwards */
446  			if (vlan_info->nr_vids == 1)
447  				last = true;
448  
449  			unregister_vlan_dev(vlandev, &list);
450  			if (last)
451  				break;
452  		}
453  		unregister_netdevice_many(&list);
454  		break;
455  
456  	case NETDEV_PRE_TYPE_CHANGE:
457  		/* Forbid underlaying device to change its type. */
458  		if (vlan_uses_dev(dev))
459  			return NOTIFY_BAD;
460  		break;
461  
462  	case NETDEV_NOTIFY_PEERS:
463  	case NETDEV_BONDING_FAILOVER:
464  	case NETDEV_RESEND_IGMP:
465  		/* Propagate to vlan devices */
466  		vlan_group_for_each_dev(grp, i, vlandev)
467  			call_netdevice_notifiers(event, vlandev);
468  		break;
469  	}
470  
471  out:
472  	return NOTIFY_DONE;
473  }
474  
475  static struct notifier_block vlan_notifier_block __read_mostly = {
476  	.notifier_call = vlan_device_event,
477  };
478  
479  /*
480   *	VLAN IOCTL handler.
481   *	o execute requested action or pass command to the device driver
482   *   arg is really a struct vlan_ioctl_args __user *.
483   */
484  static int vlan_ioctl_handler(struct net *net, void __user *arg)
485  {
486  	int err;
487  	struct vlan_ioctl_args args;
488  	struct net_device *dev = NULL;
489  
490  	if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args)))
491  		return -EFAULT;
492  
493  	/* Null terminate this sucker, just in case. */
494  	args.device1[23] = 0;
495  	args.u.device2[23] = 0;
496  
497  	rtnl_lock();
498  
499  	switch (args.cmd) {
500  	case SET_VLAN_INGRESS_PRIORITY_CMD:
501  	case SET_VLAN_EGRESS_PRIORITY_CMD:
502  	case SET_VLAN_FLAG_CMD:
503  	case ADD_VLAN_CMD:
504  	case DEL_VLAN_CMD:
505  	case GET_VLAN_REALDEV_NAME_CMD:
506  	case GET_VLAN_VID_CMD:
507  		err = -ENODEV;
508  		dev = __dev_get_by_name(net, args.device1);
509  		if (!dev)
510  			goto out;
511  
512  		err = -EINVAL;
513  		if (args.cmd != ADD_VLAN_CMD && !is_vlan_dev(dev))
514  			goto out;
515  	}
516  
517  	switch (args.cmd) {
518  	case SET_VLAN_INGRESS_PRIORITY_CMD:
519  		err = -EPERM;
520  		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
521  			break;
522  		vlan_dev_set_ingress_priority(dev,
523  					      args.u.skb_priority,
524  					      args.vlan_qos);
525  		err = 0;
526  		break;
527  
528  	case SET_VLAN_EGRESS_PRIORITY_CMD:
529  		err = -EPERM;
530  		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
531  			break;
532  		err = vlan_dev_set_egress_priority(dev,
533  						   args.u.skb_priority,
534  						   args.vlan_qos);
535  		break;
536  
537  	case SET_VLAN_FLAG_CMD:
538  		err = -EPERM;
539  		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
540  			break;
541  		err = vlan_dev_change_flags(dev,
542  					    args.vlan_qos ? args.u.flag : 0,
543  					    args.u.flag);
544  		break;
545  
546  	case SET_VLAN_NAME_TYPE_CMD:
547  		err = -EPERM;
548  		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
549  			break;
550  		if ((args.u.name_type >= 0) &&
551  		    (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
552  			struct vlan_net *vn;
553  
554  			vn = net_generic(net, vlan_net_id);
555  			vn->name_type = args.u.name_type;
556  			err = 0;
557  		} else {
558  			err = -EINVAL;
559  		}
560  		break;
561  
562  	case ADD_VLAN_CMD:
563  		err = -EPERM;
564  		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
565  			break;
566  		err = register_vlan_device(dev, args.u.VID);
567  		break;
568  
569  	case DEL_VLAN_CMD:
570  		err = -EPERM;
571  		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
572  			break;
573  		unregister_vlan_dev(dev, NULL);
574  		err = 0;
575  		break;
576  
577  	case GET_VLAN_REALDEV_NAME_CMD:
578  		err = 0;
579  		vlan_dev_get_realdev_name(dev, args.u.device2);
580  		if (copy_to_user(arg, &args,
581  				 sizeof(struct vlan_ioctl_args)))
582  			err = -EFAULT;
583  		break;
584  
585  	case GET_VLAN_VID_CMD:
586  		err = 0;
587  		args.u.VID = vlan_dev_vlan_id(dev);
588  		if (copy_to_user(arg, &args,
589  				 sizeof(struct vlan_ioctl_args)))
590  		      err = -EFAULT;
591  		break;
592  
593  	default:
594  		err = -EOPNOTSUPP;
595  		break;
596  	}
597  out:
598  	rtnl_unlock();
599  	return err;
600  }
601  
602  static int __net_init vlan_init_net(struct net *net)
603  {
604  	struct vlan_net *vn = net_generic(net, vlan_net_id);
605  	int err;
606  
607  	vn->name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
608  
609  	err = vlan_proc_init(net);
610  
611  	return err;
612  }
613  
614  static void __net_exit vlan_exit_net(struct net *net)
615  {
616  	vlan_proc_cleanup(net);
617  }
618  
619  static struct pernet_operations vlan_net_ops = {
620  	.init = vlan_init_net,
621  	.exit = vlan_exit_net,
622  	.id   = &vlan_net_id,
623  	.size = sizeof(struct vlan_net),
624  };
625  
626  static int __init vlan_proto_init(void)
627  {
628  	int err;
629  
630  	pr_info("%s v%s\n", vlan_fullname, vlan_version);
631  
632  	err = register_pernet_subsys(&vlan_net_ops);
633  	if (err < 0)
634  		goto err0;
635  
636  	err = register_netdevice_notifier(&vlan_notifier_block);
637  	if (err < 0)
638  		goto err2;
639  
640  	err = vlan_gvrp_init();
641  	if (err < 0)
642  		goto err3;
643  
644  	err = vlan_mvrp_init();
645  	if (err < 0)
646  		goto err4;
647  
648  	err = vlan_netlink_init();
649  	if (err < 0)
650  		goto err5;
651  
652  	vlan_ioctl_set(vlan_ioctl_handler);
653  	return 0;
654  
655  err5:
656  	vlan_mvrp_uninit();
657  err4:
658  	vlan_gvrp_uninit();
659  err3:
660  	unregister_netdevice_notifier(&vlan_notifier_block);
661  err2:
662  	unregister_pernet_subsys(&vlan_net_ops);
663  err0:
664  	return err;
665  }
666  
667  static void __exit vlan_cleanup_module(void)
668  {
669  	vlan_ioctl_set(NULL);
670  	vlan_netlink_fini();
671  
672  	unregister_netdevice_notifier(&vlan_notifier_block);
673  
674  	unregister_pernet_subsys(&vlan_net_ops);
675  	rcu_barrier(); /* Wait for completion of call_rcu()'s */
676  
677  	vlan_mvrp_uninit();
678  	vlan_gvrp_uninit();
679  }
680  
681  module_init(vlan_proto_init);
682  module_exit(vlan_cleanup_module);
683  
684  MODULE_LICENSE("GPL");
685  MODULE_VERSION(DRV_VERSION);
686