xref: /openbmc/linux/net/8021q/vlan.c (revision f42b3800)
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 #include <asm/uaccess.h> /* for copy_from_user */
22 #include <linux/capability.h>
23 #include <linux/module.h>
24 #include <linux/netdevice.h>
25 #include <linux/skbuff.h>
26 #include <net/datalink.h>
27 #include <linux/mm.h>
28 #include <linux/in.h>
29 #include <linux/init.h>
30 #include <net/p8022.h>
31 #include <net/arp.h>
32 #include <linux/rtnetlink.h>
33 #include <linux/notifier.h>
34 #include <net/net_namespace.h>
35 #include <net/netns/generic.h>
36 
37 #include <linux/if_vlan.h>
38 #include "vlan.h"
39 #include "vlanproc.h"
40 
41 #define DRV_VERSION "1.8"
42 
43 /* Global VLAN variables */
44 
45 int vlan_net_id;
46 
47 /* Our listing of VLAN group(s) */
48 static struct hlist_head vlan_group_hash[VLAN_GRP_HASH_SIZE];
49 
50 static char vlan_fullname[] = "802.1Q VLAN Support";
51 static char vlan_version[] = DRV_VERSION;
52 static char vlan_copyright[] = "Ben Greear <greearb@candelatech.com>";
53 static char vlan_buggyright[] = "David S. Miller <davem@redhat.com>";
54 
55 static struct packet_type vlan_packet_type = {
56 	.type = __constant_htons(ETH_P_8021Q),
57 	.func = vlan_skb_recv, /* VLAN receive method */
58 };
59 
60 /* End of global variables definitions. */
61 
62 static inline unsigned int vlan_grp_hashfn(unsigned int idx)
63 {
64 	return ((idx >> VLAN_GRP_HASH_SHIFT) ^ idx) & VLAN_GRP_HASH_MASK;
65 }
66 
67 /* Must be invoked with RCU read lock (no preempt) */
68 static struct vlan_group *__vlan_find_group(struct net_device *real_dev)
69 {
70 	struct vlan_group *grp;
71 	struct hlist_node *n;
72 	int hash = vlan_grp_hashfn(real_dev->ifindex);
73 
74 	hlist_for_each_entry_rcu(grp, n, &vlan_group_hash[hash], hlist) {
75 		if (grp->real_dev == real_dev)
76 			return grp;
77 	}
78 
79 	return NULL;
80 }
81 
82 /*  Find the protocol handler.  Assumes VID < VLAN_VID_MASK.
83  *
84  * Must be invoked with RCU read lock (no preempt)
85  */
86 struct net_device *__find_vlan_dev(struct net_device *real_dev,
87 				   unsigned short VID)
88 {
89 	struct vlan_group *grp = __vlan_find_group(real_dev);
90 
91 	if (grp)
92 		return vlan_group_get_device(grp, VID);
93 
94 	return NULL;
95 }
96 
97 static void vlan_group_free(struct vlan_group *grp)
98 {
99 	int i;
100 
101 	for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
102 		kfree(grp->vlan_devices_arrays[i]);
103 	kfree(grp);
104 }
105 
106 static struct vlan_group *vlan_group_alloc(struct net_device *real_dev)
107 {
108 	struct vlan_group *grp;
109 
110 	grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL);
111 	if (!grp)
112 		return NULL;
113 
114 	grp->real_dev = real_dev;
115 	hlist_add_head_rcu(&grp->hlist,
116 			&vlan_group_hash[vlan_grp_hashfn(real_dev->ifindex)]);
117 	return grp;
118 }
119 
120 static int vlan_group_prealloc_vid(struct vlan_group *vg, int vid)
121 {
122 	struct net_device **array;
123 	unsigned int size;
124 
125 	ASSERT_RTNL();
126 
127 	array = vg->vlan_devices_arrays[vid / VLAN_GROUP_ARRAY_PART_LEN];
128 	if (array != NULL)
129 		return 0;
130 
131 	size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN;
132 	array = kzalloc(size, GFP_KERNEL);
133 	if (array == NULL)
134 		return -ENOBUFS;
135 
136 	vg->vlan_devices_arrays[vid / VLAN_GROUP_ARRAY_PART_LEN] = array;
137 	return 0;
138 }
139 
140 static void vlan_rcu_free(struct rcu_head *rcu)
141 {
142 	vlan_group_free(container_of(rcu, struct vlan_group, rcu));
143 }
144 
145 void unregister_vlan_dev(struct net_device *dev)
146 {
147 	struct vlan_dev_info *vlan = vlan_dev_info(dev);
148 	struct net_device *real_dev = vlan->real_dev;
149 	struct vlan_group *grp;
150 	unsigned short vlan_id = vlan->vlan_id;
151 
152 	ASSERT_RTNL();
153 
154 	grp = __vlan_find_group(real_dev);
155 	BUG_ON(!grp);
156 
157 	/* Take it out of our own structures, but be sure to interlock with
158 	 * HW accelerating devices or SW vlan input packet processing.
159 	 */
160 	if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
161 		real_dev->vlan_rx_kill_vid(real_dev, vlan_id);
162 
163 	vlan_group_set_device(grp, vlan_id, NULL);
164 	grp->nr_vlans--;
165 
166 	synchronize_net();
167 
168 	/* If the group is now empty, kill off the group. */
169 	if (grp->nr_vlans == 0) {
170 		if (real_dev->features & NETIF_F_HW_VLAN_RX)
171 			real_dev->vlan_rx_register(real_dev, NULL);
172 
173 		hlist_del_rcu(&grp->hlist);
174 
175 		/* Free the group, after all cpu's are done. */
176 		call_rcu(&grp->rcu, vlan_rcu_free);
177 	}
178 
179 	/* Get rid of the vlan's reference to real_dev */
180 	dev_put(real_dev);
181 
182 	unregister_netdevice(dev);
183 }
184 
185 static void vlan_transfer_operstate(const struct net_device *dev,
186 				    struct net_device *vlandev)
187 {
188 	/* Have to respect userspace enforced dormant state
189 	 * of real device, also must allow supplicant running
190 	 * on VLAN device
191 	 */
192 	if (dev->operstate == IF_OPER_DORMANT)
193 		netif_dormant_on(vlandev);
194 	else
195 		netif_dormant_off(vlandev);
196 
197 	if (netif_carrier_ok(dev)) {
198 		if (!netif_carrier_ok(vlandev))
199 			netif_carrier_on(vlandev);
200 	} else {
201 		if (netif_carrier_ok(vlandev))
202 			netif_carrier_off(vlandev);
203 	}
204 }
205 
206 int vlan_check_real_dev(struct net_device *real_dev, unsigned short vlan_id)
207 {
208 	char *name = real_dev->name;
209 
210 	if (real_dev->features & NETIF_F_VLAN_CHALLENGED) {
211 		pr_info("8021q: VLANs not supported on %s\n", name);
212 		return -EOPNOTSUPP;
213 	}
214 
215 	if ((real_dev->features & NETIF_F_HW_VLAN_RX) &&
216 	    !real_dev->vlan_rx_register) {
217 		pr_info("8021q: device %s has buggy VLAN hw accel\n", name);
218 		return -EOPNOTSUPP;
219 	}
220 
221 	if ((real_dev->features & NETIF_F_HW_VLAN_FILTER) &&
222 	    (!real_dev->vlan_rx_add_vid || !real_dev->vlan_rx_kill_vid)) {
223 		pr_info("8021q: Device %s has buggy VLAN hw accel\n", name);
224 		return -EOPNOTSUPP;
225 	}
226 
227 	/* The real device must be up and operating in order to
228 	 * assosciate a VLAN device with it.
229 	 */
230 	if (!(real_dev->flags & IFF_UP))
231 		return -ENETDOWN;
232 
233 	if (__find_vlan_dev(real_dev, vlan_id) != NULL)
234 		return -EEXIST;
235 
236 	return 0;
237 }
238 
239 int register_vlan_dev(struct net_device *dev)
240 {
241 	struct vlan_dev_info *vlan = vlan_dev_info(dev);
242 	struct net_device *real_dev = vlan->real_dev;
243 	unsigned short vlan_id = vlan->vlan_id;
244 	struct vlan_group *grp, *ngrp = NULL;
245 	int err;
246 
247 	grp = __vlan_find_group(real_dev);
248 	if (!grp) {
249 		ngrp = grp = vlan_group_alloc(real_dev);
250 		if (!grp)
251 			return -ENOBUFS;
252 	}
253 
254 	err = vlan_group_prealloc_vid(grp, vlan_id);
255 	if (err < 0)
256 		goto out_free_group;
257 
258 	err = register_netdevice(dev);
259 	if (err < 0)
260 		goto out_free_group;
261 
262 	/* Account for reference in struct vlan_dev_info */
263 	dev_hold(real_dev);
264 
265 	vlan_transfer_operstate(real_dev, dev);
266 	linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */
267 
268 	/* So, got the sucker initialized, now lets place
269 	 * it into our local structure.
270 	 */
271 	vlan_group_set_device(grp, vlan_id, dev);
272 	grp->nr_vlans++;
273 
274 	if (ngrp && real_dev->features & NETIF_F_HW_VLAN_RX)
275 		real_dev->vlan_rx_register(real_dev, ngrp);
276 	if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
277 		real_dev->vlan_rx_add_vid(real_dev, vlan_id);
278 
279 	return 0;
280 
281 out_free_group:
282 	if (ngrp)
283 		vlan_group_free(ngrp);
284 	return err;
285 }
286 
287 /*  Attach a VLAN device to a mac address (ie Ethernet Card).
288  *  Returns 0 if the device was created or a negative error code otherwise.
289  */
290 static int register_vlan_device(struct net_device *real_dev,
291 				unsigned short VLAN_ID)
292 {
293 	struct net_device *new_dev;
294 	struct net *net = dev_net(real_dev);
295 	struct vlan_net *vn = net_generic(net, vlan_net_id);
296 	char name[IFNAMSIZ];
297 	int err;
298 
299 	if (VLAN_ID >= VLAN_VID_MASK)
300 		return -ERANGE;
301 
302 	err = vlan_check_real_dev(real_dev, VLAN_ID);
303 	if (err < 0)
304 		return err;
305 
306 	/* Gotta set up the fields for the device. */
307 	switch (vn->name_type) {
308 	case VLAN_NAME_TYPE_RAW_PLUS_VID:
309 		/* name will look like:	 eth1.0005 */
310 		snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, VLAN_ID);
311 		break;
312 	case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:
313 		/* Put our vlan.VID in the name.
314 		 * Name will look like:	 vlan5
315 		 */
316 		snprintf(name, IFNAMSIZ, "vlan%i", VLAN_ID);
317 		break;
318 	case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:
319 		/* Put our vlan.VID in the name.
320 		 * Name will look like:	 eth0.5
321 		 */
322 		snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, VLAN_ID);
323 		break;
324 	case VLAN_NAME_TYPE_PLUS_VID:
325 		/* Put our vlan.VID in the name.
326 		 * Name will look like:	 vlan0005
327 		 */
328 	default:
329 		snprintf(name, IFNAMSIZ, "vlan%.4i", VLAN_ID);
330 	}
331 
332 	new_dev = alloc_netdev(sizeof(struct vlan_dev_info), name,
333 			       vlan_setup);
334 
335 	if (new_dev == NULL)
336 		return -ENOBUFS;
337 
338 	dev_net_set(new_dev, net);
339 	/* need 4 bytes for extra VLAN header info,
340 	 * hope the underlying device can handle it.
341 	 */
342 	new_dev->mtu = real_dev->mtu;
343 
344 	vlan_dev_info(new_dev)->vlan_id = VLAN_ID; /* 1 through VLAN_VID_MASK */
345 	vlan_dev_info(new_dev)->real_dev = real_dev;
346 	vlan_dev_info(new_dev)->dent = NULL;
347 	vlan_dev_info(new_dev)->flags = VLAN_FLAG_REORDER_HDR;
348 
349 	new_dev->rtnl_link_ops = &vlan_link_ops;
350 	err = register_vlan_dev(new_dev);
351 	if (err < 0)
352 		goto out_free_newdev;
353 
354 	return 0;
355 
356 out_free_newdev:
357 	free_netdev(new_dev);
358 	return err;
359 }
360 
361 static void vlan_sync_address(struct net_device *dev,
362 			      struct net_device *vlandev)
363 {
364 	struct vlan_dev_info *vlan = vlan_dev_info(vlandev);
365 
366 	/* May be called without an actual change */
367 	if (!compare_ether_addr(vlan->real_dev_addr, dev->dev_addr))
368 		return;
369 
370 	/* vlan address was different from the old address and is equal to
371 	 * the new address */
372 	if (compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
373 	    !compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
374 		dev_unicast_delete(dev, vlandev->dev_addr, ETH_ALEN);
375 
376 	/* vlan address was equal to the old address and is different from
377 	 * the new address */
378 	if (!compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
379 	    compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
380 		dev_unicast_add(dev, vlandev->dev_addr, ETH_ALEN);
381 
382 	memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN);
383 }
384 
385 static void __vlan_device_event(struct net_device *dev, unsigned long event)
386 {
387 	switch (event) {
388 	case NETDEV_CHANGENAME:
389 		vlan_proc_rem_dev(dev);
390 		if (vlan_proc_add_dev(dev) < 0)
391 			pr_warning("8021q: failed to change proc name for %s\n",
392 					dev->name);
393 		break;
394 	case NETDEV_REGISTER:
395 		if (vlan_proc_add_dev(dev) < 0)
396 			pr_warning("8021q: failed to add proc entry for %s\n",
397 					dev->name);
398 		break;
399 	case NETDEV_UNREGISTER:
400 		vlan_proc_rem_dev(dev);
401 		break;
402 	}
403 }
404 
405 static int vlan_device_event(struct notifier_block *unused, unsigned long event,
406 			     void *ptr)
407 {
408 	struct net_device *dev = ptr;
409 	struct vlan_group *grp;
410 	int i, flgs;
411 	struct net_device *vlandev;
412 
413 	if (is_vlan_dev(dev)) {
414 		__vlan_device_event(dev, event);
415 		goto out;
416 	}
417 
418 	grp = __vlan_find_group(dev);
419 	if (!grp)
420 		goto out;
421 
422 	/* It is OK that we do not hold the group lock right now,
423 	 * as we run under the RTNL lock.
424 	 */
425 
426 	switch (event) {
427 	case NETDEV_CHANGE:
428 		/* Propagate real device state to vlan devices */
429 		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
430 			vlandev = vlan_group_get_device(grp, i);
431 			if (!vlandev)
432 				continue;
433 
434 			vlan_transfer_operstate(dev, vlandev);
435 		}
436 		break;
437 
438 	case NETDEV_CHANGEADDR:
439 		/* Adjust unicast filters on underlying device */
440 		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
441 			vlandev = vlan_group_get_device(grp, i);
442 			if (!vlandev)
443 				continue;
444 
445 			flgs = vlandev->flags;
446 			if (!(flgs & IFF_UP))
447 				continue;
448 
449 			vlan_sync_address(dev, vlandev);
450 		}
451 		break;
452 
453 	case NETDEV_DOWN:
454 		/* Put all VLANs for this dev in the down state too.  */
455 		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
456 			vlandev = vlan_group_get_device(grp, i);
457 			if (!vlandev)
458 				continue;
459 
460 			flgs = vlandev->flags;
461 			if (!(flgs & IFF_UP))
462 				continue;
463 
464 			dev_change_flags(vlandev, flgs & ~IFF_UP);
465 		}
466 		break;
467 
468 	case NETDEV_UP:
469 		/* Put all VLANs for this dev in the up state too.  */
470 		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
471 			vlandev = vlan_group_get_device(grp, i);
472 			if (!vlandev)
473 				continue;
474 
475 			flgs = vlandev->flags;
476 			if (flgs & IFF_UP)
477 				continue;
478 
479 			dev_change_flags(vlandev, flgs | IFF_UP);
480 		}
481 		break;
482 
483 	case NETDEV_UNREGISTER:
484 		/* Delete all VLANs for this dev. */
485 		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
486 			vlandev = vlan_group_get_device(grp, i);
487 			if (!vlandev)
488 				continue;
489 
490 			/* unregistration of last vlan destroys group, abort
491 			 * afterwards */
492 			if (grp->nr_vlans == 1)
493 				i = VLAN_GROUP_ARRAY_LEN;
494 
495 			unregister_vlan_dev(vlandev);
496 		}
497 		break;
498 	}
499 
500 out:
501 	return NOTIFY_DONE;
502 }
503 
504 static struct notifier_block vlan_notifier_block __read_mostly = {
505 	.notifier_call = vlan_device_event,
506 };
507 
508 /*
509  *	VLAN IOCTL handler.
510  *	o execute requested action or pass command to the device driver
511  *   arg is really a struct vlan_ioctl_args __user *.
512  */
513 static int vlan_ioctl_handler(struct net *net, void __user *arg)
514 {
515 	int err;
516 	unsigned short vid = 0;
517 	struct vlan_ioctl_args args;
518 	struct net_device *dev = NULL;
519 
520 	if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args)))
521 		return -EFAULT;
522 
523 	/* Null terminate this sucker, just in case. */
524 	args.device1[23] = 0;
525 	args.u.device2[23] = 0;
526 
527 	rtnl_lock();
528 
529 	switch (args.cmd) {
530 	case SET_VLAN_INGRESS_PRIORITY_CMD:
531 	case SET_VLAN_EGRESS_PRIORITY_CMD:
532 	case SET_VLAN_FLAG_CMD:
533 	case ADD_VLAN_CMD:
534 	case DEL_VLAN_CMD:
535 	case GET_VLAN_REALDEV_NAME_CMD:
536 	case GET_VLAN_VID_CMD:
537 		err = -ENODEV;
538 		dev = __dev_get_by_name(net, args.device1);
539 		if (!dev)
540 			goto out;
541 
542 		err = -EINVAL;
543 		if (args.cmd != ADD_VLAN_CMD &&
544 		    !(dev->priv_flags & IFF_802_1Q_VLAN))
545 			goto out;
546 	}
547 
548 	switch (args.cmd) {
549 	case SET_VLAN_INGRESS_PRIORITY_CMD:
550 		err = -EPERM;
551 		if (!capable(CAP_NET_ADMIN))
552 			break;
553 		vlan_dev_set_ingress_priority(dev,
554 					      args.u.skb_priority,
555 					      args.vlan_qos);
556 		err = 0;
557 		break;
558 
559 	case SET_VLAN_EGRESS_PRIORITY_CMD:
560 		err = -EPERM;
561 		if (!capable(CAP_NET_ADMIN))
562 			break;
563 		err = vlan_dev_set_egress_priority(dev,
564 						   args.u.skb_priority,
565 						   args.vlan_qos);
566 		break;
567 
568 	case SET_VLAN_FLAG_CMD:
569 		err = -EPERM;
570 		if (!capable(CAP_NET_ADMIN))
571 			break;
572 		err = vlan_dev_set_vlan_flag(dev,
573 					     args.u.flag,
574 					     args.vlan_qos);
575 		break;
576 
577 	case SET_VLAN_NAME_TYPE_CMD:
578 		err = -EPERM;
579 		if (!capable(CAP_NET_ADMIN))
580 			break;
581 		if ((args.u.name_type >= 0) &&
582 		    (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
583 			struct vlan_net *vn;
584 
585 			vn = net_generic(net, vlan_net_id);
586 			vn->name_type = args.u.name_type;
587 			err = 0;
588 		} else {
589 			err = -EINVAL;
590 		}
591 		break;
592 
593 	case ADD_VLAN_CMD:
594 		err = -EPERM;
595 		if (!capable(CAP_NET_ADMIN))
596 			break;
597 		err = register_vlan_device(dev, args.u.VID);
598 		break;
599 
600 	case DEL_VLAN_CMD:
601 		err = -EPERM;
602 		if (!capable(CAP_NET_ADMIN))
603 			break;
604 		unregister_vlan_dev(dev);
605 		err = 0;
606 		break;
607 
608 	case GET_VLAN_REALDEV_NAME_CMD:
609 		err = 0;
610 		vlan_dev_get_realdev_name(dev, args.u.device2);
611 		if (copy_to_user(arg, &args,
612 				 sizeof(struct vlan_ioctl_args)))
613 			err = -EFAULT;
614 		break;
615 
616 	case GET_VLAN_VID_CMD:
617 		err = 0;
618 		vlan_dev_get_vid(dev, &vid);
619 		args.u.VID = vid;
620 		if (copy_to_user(arg, &args,
621 				 sizeof(struct vlan_ioctl_args)))
622 		      err = -EFAULT;
623 		break;
624 
625 	default:
626 		err = -EOPNOTSUPP;
627 		break;
628 	}
629 out:
630 	rtnl_unlock();
631 	return err;
632 }
633 
634 static int vlan_init_net(struct net *net)
635 {
636 	int err;
637 	struct vlan_net *vn;
638 
639 	err = -ENOMEM;
640 	vn = kzalloc(sizeof(struct vlan_net), GFP_KERNEL);
641 	if (vn == NULL)
642 		goto err_alloc;
643 
644 	err = net_assign_generic(net, vlan_net_id, vn);
645 	if (err < 0)
646 		goto err_assign;
647 
648 	vn->name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
649 
650 	err = vlan_proc_init(net);
651 	if (err < 0)
652 		goto err_proc;
653 
654 	return 0;
655 
656 err_proc:
657 	/* nothing */
658 err_assign:
659 	kfree(vn);
660 err_alloc:
661 	return err;
662 }
663 
664 static void vlan_exit_net(struct net *net)
665 {
666 	struct vlan_net *vn;
667 
668 	vn = net_generic(net, vlan_net_id);
669 	rtnl_kill_links(net, &vlan_link_ops);
670 	vlan_proc_cleanup(net);
671 	kfree(vn);
672 }
673 
674 static struct pernet_operations vlan_net_ops = {
675 	.init = vlan_init_net,
676 	.exit = vlan_exit_net,
677 };
678 
679 static int __init vlan_proto_init(void)
680 {
681 	int err;
682 
683 	pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright);
684 	pr_info("All bugs added by %s\n", vlan_buggyright);
685 
686 	err = register_pernet_gen_device(&vlan_net_id, &vlan_net_ops);
687 	if (err < 0)
688 		goto err0;
689 
690 	err = register_netdevice_notifier(&vlan_notifier_block);
691 	if (err < 0)
692 		goto err2;
693 
694 	err = vlan_netlink_init();
695 	if (err < 0)
696 		goto err3;
697 
698 	dev_add_pack(&vlan_packet_type);
699 	vlan_ioctl_set(vlan_ioctl_handler);
700 	return 0;
701 
702 err3:
703 	unregister_netdevice_notifier(&vlan_notifier_block);
704 err2:
705 	unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops);
706 err0:
707 	return err;
708 }
709 
710 static void __exit vlan_cleanup_module(void)
711 {
712 	unsigned int i;
713 
714 	vlan_ioctl_set(NULL);
715 	vlan_netlink_fini();
716 
717 	unregister_netdevice_notifier(&vlan_notifier_block);
718 
719 	dev_remove_pack(&vlan_packet_type);
720 
721 	/* This table must be empty if there are no module references left. */
722 	for (i = 0; i < VLAN_GRP_HASH_SIZE; i++)
723 		BUG_ON(!hlist_empty(&vlan_group_hash[i]));
724 
725 	unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops);
726 
727 	synchronize_net();
728 }
729 
730 module_init(vlan_proto_init);
731 module_exit(vlan_cleanup_module);
732 
733 MODULE_LICENSE("GPL");
734 MODULE_VERSION(DRV_VERSION);
735