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