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