[deliverable/linux.git] / net / 8021q / vlan.c

/*
 * INET		802.1Q VLAN
 *		Ethernet-type device handling.
 *
 * Authors:	Ben Greear <greearb@candelatech.com>
 *              Please send support related email to: netdev@vger.kernel.org
 *              VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
 *
 * Fixes:
 *              Fix for packet capture - Nick Eggleston <nick@dccinc.com>;
 *		Add HW acceleration hooks - David S. Miller <davem@redhat.com>;
 *		Correct all the locking - David S. Miller <davem@redhat.com>;
 *		Use hash table for VLAN groups - David S. Miller <davem@redhat.com>
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 */

#include <asm/uaccess.h> /* for copy_from_user */
#include <linux/capability.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <net/datalink.h>
#include <linux/mm.h>
#include <linux/in.h>
#include <linux/init.h>
#include <net/p8022.h>
#include <net/arp.h>
#include <linux/rtnetlink.h>
#include <linux/notifier.h>
#include <net/net_namespace.h>

#include <linux/if_vlan.h>
#include "vlan.h"
#include "vlanproc.h"

#define DRV_VERSION "1.8"

/* Global VLAN variables */

/* Our listing of VLAN group(s) */
static struct hlist_head vlan_group_hash[VLAN_GRP_HASH_SIZE];

static char vlan_fullname[] = "802.1Q VLAN Support";
static char vlan_version[] = DRV_VERSION;
static char vlan_copyright[] = "Ben Greear <greearb@candelatech.com>";
static char vlan_buggyright[] = "David S. Miller <davem@redhat.com>";

/* Determines interface naming scheme. */
unsigned short vlan_name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;

static struct packet_type vlan_packet_type = {
	.type = __constant_htons(ETH_P_8021Q),
	.func = vlan_skb_recv, /* VLAN receive method */
};

/* End of global variables definitions. */

static inline unsigned int vlan_grp_hashfn(unsigned int idx)
{
	return ((idx >> VLAN_GRP_HASH_SHIFT) ^ idx) & VLAN_GRP_HASH_MASK;
}

/* Must be invoked with RCU read lock (no preempt) */
static struct vlan_group *__vlan_find_group(int real_dev_ifindex)
{
	struct vlan_group *grp;
	struct hlist_node *n;
	int hash = vlan_grp_hashfn(real_dev_ifindex);

	hlist_for_each_entry_rcu(grp, n, &vlan_group_hash[hash], hlist) {
		if (grp->real_dev_ifindex == real_dev_ifindex)
			return grp;
	}

	return NULL;
}

/*  Find the protocol handler.  Assumes VID < VLAN_VID_MASK.
 *
 * Must be invoked with RCU read lock (no preempt)
 */
struct net_device *__find_vlan_dev(struct net_device *real_dev,
				   unsigned short VID)
{
	struct vlan_group *grp = __vlan_find_group(real_dev->ifindex);

	if (grp)
		return vlan_group_get_device(grp, VID);

	return NULL;
}

static void vlan_group_free(struct vlan_group *grp)
{
	int i;

	for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
		kfree(grp->vlan_devices_arrays[i]);
	kfree(grp);
}

static struct vlan_group *vlan_group_alloc(int ifindex)
{
	struct vlan_group *grp;
	unsigned int size;
	unsigned int i;

	grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL);
	if (!grp)
		return NULL;

	size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN;

	for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++) {
		grp->vlan_devices_arrays[i] = kzalloc(size, GFP_KERNEL);
		if (!grp->vlan_devices_arrays[i])
			goto err;
	}

	grp->real_dev_ifindex = ifindex;
	hlist_add_head_rcu(&grp->hlist,
			   &vlan_group_hash[vlan_grp_hashfn(ifindex)]);
	return grp;

err:
	vlan_group_free(grp);
	return NULL;
}

static void vlan_rcu_free(struct rcu_head *rcu)
{
	vlan_group_free(container_of(rcu, struct vlan_group, rcu));
}

void unregister_vlan_dev(struct net_device *dev)
{
	struct vlan_dev_info *vlan = vlan_dev_info(dev);
	struct net_device *real_dev = vlan->real_dev;
	struct vlan_group *grp;
	unsigned short vlan_id = vlan->vlan_id;

	ASSERT_RTNL();

	grp = __vlan_find_group(real_dev->ifindex);
	BUG_ON(!grp);

	vlan_proc_rem_dev(dev);

	/* Take it out of our own structures, but be sure to interlock with
	 * HW accelerating devices or SW vlan input packet processing.
	 */
	if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
		real_dev->vlan_rx_kill_vid(real_dev, vlan_id);

	vlan_group_set_device(grp, vlan_id, NULL);
	grp->nr_vlans--;

	synchronize_net();

	/* If the group is now empty, kill off the group. */
	if (grp->nr_vlans == 0) {
		if (real_dev->features & NETIF_F_HW_VLAN_RX)
			real_dev->vlan_rx_register(real_dev, NULL);

		hlist_del_rcu(&grp->hlist);

		/* Free the group, after all cpu's are done. */
		call_rcu(&grp->rcu, vlan_rcu_free);
	}

	/* Get rid of the vlan's reference to real_dev */
	dev_put(real_dev);

	unregister_netdevice(dev);
}

static void vlan_transfer_operstate(const struct net_device *dev,
				    struct net_device *vlandev)
{
	/* Have to respect userspace enforced dormant state
	 * of real device, also must allow supplicant running
	 * on VLAN device
	 */
	if (dev->operstate == IF_OPER_DORMANT)
		netif_dormant_on(vlandev);
	else
		netif_dormant_off(vlandev);

	if (netif_carrier_ok(dev)) {
		if (!netif_carrier_ok(vlandev))
			netif_carrier_on(vlandev);
	} else {
		if (netif_carrier_ok(vlandev))
			netif_carrier_off(vlandev);
	}
}

int vlan_check_real_dev(struct net_device *real_dev, unsigned short vlan_id)
{
	char *name = real_dev->name;

	if (real_dev->features & NETIF_F_VLAN_CHALLENGED) {
		pr_info("8021q: VLANs not supported on %s\n", name);
		return -EOPNOTSUPP;
	}

	if ((real_dev->features & NETIF_F_HW_VLAN_RX) &&
	    !real_dev->vlan_rx_register) {
		pr_info("8021q: device %s has buggy VLAN hw accel\n", name);
		return -EOPNOTSUPP;
	}

	if ((real_dev->features & NETIF_F_HW_VLAN_FILTER) &&
	    (!real_dev->vlan_rx_add_vid || !real_dev->vlan_rx_kill_vid)) {
		pr_info("8021q: Device %s has buggy VLAN hw accel\n", name);
		return -EOPNOTSUPP;
	}

	/* The real device must be up and operating in order to
	 * assosciate a VLAN device with it.
	 */
	if (!(real_dev->flags & IFF_UP))
		return -ENETDOWN;

	if (__find_vlan_dev(real_dev, vlan_id) != NULL)
		return -EEXIST;

	return 0;
}

int register_vlan_dev(struct net_device *dev)
{
	struct vlan_dev_info *vlan = vlan_dev_info(dev);
	struct net_device *real_dev = vlan->real_dev;
	unsigned short vlan_id = vlan->vlan_id;
	struct vlan_group *grp, *ngrp = NULL;
	int err;

	grp = __vlan_find_group(real_dev->ifindex);
	if (!grp) {
		ngrp = grp = vlan_group_alloc(real_dev->ifindex);
		if (!grp)
			return -ENOBUFS;
	}

	err = register_netdevice(dev);
	if (err < 0)
		goto out_free_group;

	/* Account for reference in struct vlan_dev_info */
	dev_hold(real_dev);

	vlan_transfer_operstate(real_dev, dev);
	linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */

	/* So, got the sucker initialized, now lets place
	 * it into our local structure.
	 */
	vlan_group_set_device(grp, vlan_id, dev);
	grp->nr_vlans++;

	if (ngrp && real_dev->features & NETIF_F_HW_VLAN_RX)
		real_dev->vlan_rx_register(real_dev, ngrp);
	if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
		real_dev->vlan_rx_add_vid(real_dev, vlan_id);

	if (vlan_proc_add_dev(dev) < 0)
		pr_warning("8021q: failed to add proc entry for %s\n",
			   dev->name);
	return 0;

out_free_group:
	if (ngrp)
		vlan_group_free(ngrp);
	return err;
}

/*  Attach a VLAN device to a mac address (ie Ethernet Card).
 *  Returns 0 if the device was created or a negative error code otherwise.
 */
static int register_vlan_device(struct net_device *real_dev,
				unsigned short VLAN_ID)
{
	struct net_device *new_dev;
	char name[IFNAMSIZ];
	int err;

	if (VLAN_ID >= VLAN_VID_MASK)
		return -ERANGE;

	err = vlan_check_real_dev(real_dev, VLAN_ID);
	if (err < 0)
		return err;

	/* Gotta set up the fields for the device. */
	switch (vlan_name_type) {
	case VLAN_NAME_TYPE_RAW_PLUS_VID:
		/* name will look like:	 eth1.0005 */
		snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, VLAN_ID);
		break;
	case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:
		/* Put our vlan.VID in the name.
		 * Name will look like:	 vlan5
		 */
		snprintf(name, IFNAMSIZ, "vlan%i", VLAN_ID);
		break;
	case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:
		/* Put our vlan.VID in the name.
		 * Name will look like:	 eth0.5
		 */
		snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, VLAN_ID);
		break;
	case VLAN_NAME_TYPE_PLUS_VID:
		/* Put our vlan.VID in the name.
		 * Name will look like:	 vlan0005
		 */
	default:
		snprintf(name, IFNAMSIZ, "vlan%.4i", VLAN_ID);
	}

	new_dev = alloc_netdev(sizeof(struct vlan_dev_info), name,
			       vlan_setup);

	if (new_dev == NULL)
		return -ENOBUFS;

	/* need 4 bytes for extra VLAN header info,
	 * hope the underlying device can handle it.
	 */
	new_dev->mtu = real_dev->mtu;

	vlan_dev_info(new_dev)->vlan_id = VLAN_ID; /* 1 through VLAN_VID_MASK */
	vlan_dev_info(new_dev)->real_dev = real_dev;
	vlan_dev_info(new_dev)->dent = NULL;
	vlan_dev_info(new_dev)->flags = VLAN_FLAG_REORDER_HDR;

	new_dev->rtnl_link_ops = &vlan_link_ops;
	err = register_vlan_dev(new_dev);
	if (err < 0)
		goto out_free_newdev;

	return 0;

out_free_newdev:
	free_netdev(new_dev);
	return err;
}

static void vlan_sync_address(struct net_device *dev,
			      struct net_device *vlandev)
{
	struct vlan_dev_info *vlan = vlan_dev_info(vlandev);

	/* May be called without an actual change */
	if (!compare_ether_addr(vlan->real_dev_addr, dev->dev_addr))
		return;

	/* vlan address was different from the old address and is equal to
	 * the new address */
	if (compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
	    !compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
		dev_unicast_delete(dev, vlandev->dev_addr, ETH_ALEN);

	/* vlan address was equal to the old address and is different from
	 * the new address */
	if (!compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
	    compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
		dev_unicast_add(dev, vlandev->dev_addr, ETH_ALEN);

	memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN);
}

static int vlan_device_event(struct notifier_block *unused, unsigned long event,
			     void *ptr)
{
	struct net_device *dev = ptr;
	struct vlan_group *grp = __vlan_find_group(dev->ifindex);
	int i, flgs;
	struct net_device *vlandev;

	if (dev->nd_net != &init_net)
		return NOTIFY_DONE;

	if (!grp)
		goto out;

	/* It is OK that we do not hold the group lock right now,
	 * as we run under the RTNL lock.
	 */

	switch (event) {
	case NETDEV_CHANGE:
		/* Propagate real device state to vlan devices */
		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
			vlandev = vlan_group_get_device(grp, i);
			if (!vlandev)
				continue;

			vlan_transfer_operstate(dev, vlandev);
		}
		break;

	case NETDEV_CHANGEADDR:
		/* Adjust unicast filters on underlying device */
		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
			vlandev = vlan_group_get_device(grp, i);
			if (!vlandev)
				continue;

			flgs = vlandev->flags;
			if (!(flgs & IFF_UP))
				continue;

			vlan_sync_address(dev, vlandev);
		}
		break;

	case NETDEV_DOWN:
		/* Put all VLANs for this dev in the down state too.  */
		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
			vlandev = vlan_group_get_device(grp, i);
			if (!vlandev)
				continue;

			flgs = vlandev->flags;
			if (!(flgs & IFF_UP))
				continue;

			dev_change_flags(vlandev, flgs & ~IFF_UP);
		}
		break;

	case NETDEV_UP:
		/* Put all VLANs for this dev in the up state too.  */
		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
			vlandev = vlan_group_get_device(grp, i);
			if (!vlandev)
				continue;

			flgs = vlandev->flags;
			if (flgs & IFF_UP)
				continue;

			dev_change_flags(vlandev, flgs | IFF_UP);
		}
		break;

	case NETDEV_UNREGISTER:
		/* Delete all VLANs for this dev. */
		for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
			vlandev = vlan_group_get_device(grp, i);
			if (!vlandev)
				continue;

			/* unregistration of last vlan destroys group, abort
			 * afterwards */
			if (grp->nr_vlans == 1)
				i = VLAN_GROUP_ARRAY_LEN;

			unregister_vlan_dev(vlandev);
		}
		break;
	}

out:
	return NOTIFY_DONE;
}

static struct notifier_block vlan_notifier_block __read_mostly = {
	.notifier_call = vlan_device_event,
};

/*
 *	VLAN IOCTL handler.
 *	o execute requested action or pass command to the device driver
 *   arg is really a struct vlan_ioctl_args __user *.
 */
static int vlan_ioctl_handler(struct net *net, void __user *arg)
{
	int err;
	unsigned short vid = 0;
	struct vlan_ioctl_args args;
	struct net_device *dev = NULL;

	if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args)))
		return -EFAULT;

	/* Null terminate this sucker, just in case. */
	args.device1[23] = 0;
	args.u.device2[23] = 0;

	rtnl_lock();

	switch (args.cmd) {
	case SET_VLAN_INGRESS_PRIORITY_CMD:
	case SET_VLAN_EGRESS_PRIORITY_CMD:
	case SET_VLAN_FLAG_CMD:
	case ADD_VLAN_CMD:
	case DEL_VLAN_CMD:
	case GET_VLAN_REALDEV_NAME_CMD:
	case GET_VLAN_VID_CMD:
		err = -ENODEV;
		dev = __dev_get_by_name(&init_net, args.device1);
		if (!dev)
			goto out;

		err = -EINVAL;
		if (args.cmd != ADD_VLAN_CMD &&
		    !(dev->priv_flags & IFF_802_1Q_VLAN))
			goto out;
	}

	switch (args.cmd) {
	case SET_VLAN_INGRESS_PRIORITY_CMD:
		err = -EPERM;
		if (!capable(CAP_NET_ADMIN))
			break;
		vlan_dev_set_ingress_priority(dev,
					      args.u.skb_priority,
					      args.vlan_qos);
		err = 0;
		break;

	case SET_VLAN_EGRESS_PRIORITY_CMD:
		err = -EPERM;
		if (!capable(CAP_NET_ADMIN))
			break;
		err = vlan_dev_set_egress_priority(dev,
						   args.u.skb_priority,
						   args.vlan_qos);
		break;

	case SET_VLAN_FLAG_CMD:
		err = -EPERM;
		if (!capable(CAP_NET_ADMIN))
			break;
		err = vlan_dev_set_vlan_flag(dev,
					     args.u.flag,
					     args.vlan_qos);
		break;

	case SET_VLAN_NAME_TYPE_CMD:
		err = -EPERM;
		if (!capable(CAP_NET_ADMIN))
			break;
		if ((args.u.name_type >= 0) &&
		    (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
			vlan_name_type = args.u.name_type;
			err = 0;
		} else {
			err = -EINVAL;
		}
		break;

	case ADD_VLAN_CMD:
		err = -EPERM;
		if (!capable(CAP_NET_ADMIN))
			break;
		err = register_vlan_device(dev, args.u.VID);
		break;

	case DEL_VLAN_CMD:
		err = -EPERM;
		if (!capable(CAP_NET_ADMIN))
			break;
		unregister_vlan_dev(dev);
		err = 0;
		break;

	case GET_VLAN_REALDEV_NAME_CMD:
		err = 0;
		vlan_dev_get_realdev_name(dev, args.u.device2);
		if (copy_to_user(arg, &args,
				 sizeof(struct vlan_ioctl_args)))
			err = -EFAULT;
		break;

	case GET_VLAN_VID_CMD:
		err = 0;
		vlan_dev_get_vid(dev, &vid);
		args.u.VID = vid;
		if (copy_to_user(arg, &args,
				 sizeof(struct vlan_ioctl_args)))
		      err = -EFAULT;
		break;

	default:
		err = -EOPNOTSUPP;
		break;
	}
out:
	rtnl_unlock();
	return err;
}

static int __init vlan_proto_init(void)
{
	int err;

	pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright);
	pr_info("All bugs added by %s\n", vlan_buggyright);

	err = vlan_proc_init();
	if (err < 0)
		goto err1;

	err = register_netdevice_notifier(&vlan_notifier_block);
	if (err < 0)
		goto err2;

	err = vlan_netlink_init();
	if (err < 0)
		goto err3;

	dev_add_pack(&vlan_packet_type);
	vlan_ioctl_set(vlan_ioctl_handler);
	return 0;

err3:
	unregister_netdevice_notifier(&vlan_notifier_block);
err2:
	vlan_proc_cleanup();
err1:
	return err;
}

static void __exit vlan_cleanup_module(void)
{
	unsigned int i;

	vlan_ioctl_set(NULL);
	vlan_netlink_fini();

	unregister_netdevice_notifier(&vlan_notifier_block);

	dev_remove_pack(&vlan_packet_type);

	/* This table must be empty if there are no module references left. */
	for (i = 0; i < VLAN_GRP_HASH_SIZE; i++)
		BUG_ON(!hlist_empty(&vlan_group_hash[i]));

	vlan_proc_cleanup();

	synchronize_net();
}

module_init(vlan_proto_init);
module_exit(vlan_cleanup_module);

MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* INET 802.1Q VLAN
	3	* Ethernet-type device handling.
	4	*
	5	* Authors: Ben Greear <greearb@candelatech.com>
ad712087	6	* Please send support related email to: netdev@vger.kernel.org
1da177e4	7	* VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
122952fc	8	*
1da177e4 LT	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 */
4fc268d2	22	#include <linux/capability.h>
1da177e4 LT	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>
e9dc8653	34	#include <net/net_namespace.h>
1da177e4 LT	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];
1da177e4 LT	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
1da177e4 LT	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
1da177e4 LT	60	/* End of global variables definitions. */
1da177e4 LT	61
2029cc2c PM	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
1da177e4 LT	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)
5c15bdec	92	return vlan_group_get_device(grp, VID);
1da177e4 LT	93
	94	return NULL;
	95	}
	96
5c15bdec DA	97	static void vlan_group_free(struct vlan_group *grp)
	98	{
	99	int i;
	100
2029cc2c	101	for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
5c15bdec DA	102	kfree(grp->vlan_devices_arrays[i]);
	103	kfree(grp);
	104	}
	105
42429aae PM	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
1da177e4 LT	134	static void vlan_rcu_free(struct rcu_head *rcu)
1da177e4 LT	135	{
5c15bdec	136	vlan_group_free(container_of(rcu, struct vlan_group, rcu));
1da177e4 LT	137	}
1da177e4 LT	138
af301517	139	void unregister_vlan_dev(struct net_device *dev)
1da177e4	140	{
9dfebcc6	141	struct vlan_dev_info *vlan = vlan_dev_info(dev);
af301517	142	struct net_device *real_dev = vlan->real_dev;
1da177e4	143	struct vlan_group *grp;
af301517	144	unsigned short vlan_id = vlan->vlan_id;
1da177e4 LT	145
1da177e4 LT	146	ASSERT_RTNL();
acc5efbc	147
af301517 PM	148	grp = __vlan_find_group(real_dev->ifindex);
af301517 PM	149	BUG_ON(!grp);
acc5efbc PM	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);
1da177e4	158
acc5efbc	159	vlan_group_set_device(grp, vlan_id, NULL);
af301517	160	grp->nr_vlans--;
acc5efbc	161
af301517	162	synchronize_net();
acc5efbc PM	163
acc5efbc PM	164	/* If the group is now empty, kill off the group. */
af301517	165	if (grp->nr_vlans == 0) {
acc5efbc PM	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);
1da177e4	170
acc5efbc PM	171	/* Free the group, after all cpu's are done. */
acc5efbc PM	172	call_rcu(&grp->rcu, vlan_rcu_free);
1da177e4 LT	173	}
1da177e4 LT	174
af301517 PM	175	/* Get rid of the vlan's reference to real_dev */
af301517 PM	176	dev_put(real_dev);
1da177e4	177
c17d8874	178	unregister_netdevice(dev);
1da177e4 LT	179	}
1da177e4 LT	180
2029cc2c PM	181	static void vlan_transfer_operstate(const struct net_device *dev,
2029cc2c PM	182	struct net_device *vlandev)
ddd7bf9f SR	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
07b5b17e	202	int vlan_check_real_dev(struct net_device *real_dev, unsigned short vlan_id)
1da177e4	203	{
40f98e1a PM	204	char *name = real_dev->name;
40f98e1a PM	205
1da177e4	206	if (real_dev->features & NETIF_F_VLAN_CHALLENGED) {
40f98e1a	207	pr_info("8021q: VLANs not supported on %s\n", name);
c1d3ee99	208	return -EOPNOTSUPP;
1da177e4 LT	209	}
	210
	211	if ((real_dev->features & NETIF_F_HW_VLAN_RX) &&
d2d1acdb	212	!real_dev->vlan_rx_register) {
40f98e1a	213	pr_info("8021q: device %s has buggy VLAN hw accel\n", name);
c1d3ee99	214	return -EOPNOTSUPP;
1da177e4 LT	215	}
	216
	217	if ((real_dev->features & NETIF_F_HW_VLAN_FILTER) &&
d2d1acdb	218	(!real_dev->vlan_rx_add_vid \|\| !real_dev->vlan_rx_kill_vid)) {
40f98e1a	219	pr_info("8021q: Device %s has buggy VLAN hw accel\n", name);
c1d3ee99	220	return -EOPNOTSUPP;
1da177e4 LT	221	}
1da177e4 LT	222
1da177e4 LT	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))
c1d3ee99	227	return -ENETDOWN;
1da177e4	228
40f98e1a	229	if (__find_vlan_dev(real_dev, vlan_id) != NULL)
c1d3ee99	230	return -EEXIST;
1da177e4	231
c1d3ee99 PM	232	return 0;
	233	}
	234
07b5b17e	235	int register_vlan_dev(struct net_device *dev)
e89fe42c	236	{
9dfebcc6	237	struct vlan_dev_info *vlan = vlan_dev_info(dev);
e89fe42c PM	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);
af301517 PM	264	grp->nr_vlans++;
af301517 PM	265
e89fe42c PM	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)
40f98e1a PM	272	pr_warning("8021q: failed to add proc entry for %s\n",
40f98e1a PM	273	dev->name);
e89fe42c PM	274	return 0;
	275
	276	out_free_group:
	277	if (ngrp)
	278	vlan_group_free(ngrp);
	279	return err;
	280	}
	281
c1d3ee99	282	/* Attach a VLAN device to a mac address (ie Ethernet Card).
2ae0bf69	283	* Returns 0 if the device was created or a negative error code otherwise.
c1d3ee99	284	*/
2ae0bf69 PM	285	static int register_vlan_device(struct net_device *real_dev,
2ae0bf69 PM	286	unsigned short VLAN_ID)
c1d3ee99	287	{
c1d3ee99 PM	288	struct net_device *new_dev;
c1d3ee99 PM	289	char name[IFNAMSIZ];
2ae0bf69	290	int err;
c1d3ee99	291
c1d3ee99	292	if (VLAN_ID >= VLAN_VID_MASK)
2ae0bf69	293	return -ERANGE;
c1d3ee99	294
2ae0bf69 PM	295	err = vlan_check_real_dev(real_dev, VLAN_ID);
	296	if (err < 0)
	297	return err;
c1d3ee99	298
1da177e4	299	/* Gotta set up the fields for the device. */
1da177e4 LT	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);
3ff50b79	323	}
122952fc	324
1da177e4 LT	325	new_dev = alloc_netdev(sizeof(struct vlan_dev_info), name,
1da177e4 LT	326	vlan_setup);
5dd8d1e9	327
1da177e4	328	if (new_dev == NULL)
2ae0bf69	329	return -ENOBUFS;
1da177e4	330
1da177e4 LT	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
9dfebcc6 PM	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;
1da177e4	340
07b5b17e	341	new_dev->rtnl_link_ops = &vlan_link_ops;
2ae0bf69 PM	342	err = register_vlan_dev(new_dev);
2ae0bf69 PM	343	if (err < 0)
e89fe42c	344	goto out_free_newdev;
1da177e4	345
2ae0bf69	346	return 0;
1da177e4	347
1da177e4 LT	348	out_free_newdev:
1da177e4 LT	349	free_netdev(new_dev);
2ae0bf69	350	return err;
1da177e4 LT	351	}
1da177e4 LT	352
8c979c26 PM	353	static void vlan_sync_address(struct net_device *dev,
	354	struct net_device *vlandev)
	355	{
9dfebcc6	356	struct vlan_dev_info *vlan = vlan_dev_info(vlandev);
8c979c26 PM	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
2029cc2c PM	377	static int vlan_device_event(struct notifier_block *unused, unsigned long event,
2029cc2c PM	378	void *ptr)
1da177e4 LT	379	{
	380	struct net_device *dev = ptr;
	381	struct vlan_group *grp = __vlan_find_group(dev->ifindex);
	382	int i, flgs;
	383	struct net_device *vlandev;
	384
e9dc8653 EB	385	if (dev->nd_net != &init_net)
	386	return NOTIFY_DONE;
	387
1da177e4 LT	388	if (!grp)
	389	goto out;
	390
	391	/* It is OK that we do not hold the group lock right now,
	392	* as we run under the RTNL lock.
	393	*/
	394
	395	switch (event) {
	396	case NETDEV_CHANGE:
	397	/* Propagate real device state to vlan devices */
1da177e4	398	for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
5c15bdec	399	vlandev = vlan_group_get_device(grp, i);
1da177e4 LT	400	if (!vlandev)
	401	continue;
	402
ddd7bf9f	403	vlan_transfer_operstate(dev, vlandev);
1da177e4 LT	404	}
	405	break;
	406
8c979c26 PM	407	case NETDEV_CHANGEADDR:
	408	/* Adjust unicast filters on underlying device */
	409	for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
	410	vlandev = vlan_group_get_device(grp, i);
	411	if (!vlandev)
	412	continue;
	413
d932e04a PM	414	flgs = vlandev->flags;
	415	if (!(flgs & IFF_UP))
	416	continue;
	417
8c979c26 PM	418	vlan_sync_address(dev, vlandev);
	419	}
	420	break;
	421
1da177e4 LT	422	case NETDEV_DOWN:
	423	/* Put all VLANs for this dev in the down state too. */
	424	for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
5c15bdec	425	vlandev = vlan_group_get_device(grp, i);
1da177e4 LT	426	if (!vlandev)
	427	continue;
	428
	429	flgs = vlandev->flags;
	430	if (!(flgs & IFF_UP))
	431	continue;
	432
	433	dev_change_flags(vlandev, flgs & ~IFF_UP);
	434	}
	435	break;
	436
	437	case NETDEV_UP:
	438	/* Put all VLANs for this dev in the up state too. */
	439	for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
5c15bdec	440	vlandev = vlan_group_get_device(grp, i);
1da177e4 LT	441	if (!vlandev)
1da177e4 LT	442	continue;
122952fc	443
1da177e4 LT	444	flgs = vlandev->flags;
	445	if (flgs & IFF_UP)
	446	continue;
	447
	448	dev_change_flags(vlandev, flgs \| IFF_UP);
	449	}
	450	break;
122952fc	451
1da177e4 LT	452	case NETDEV_UNREGISTER:
	453	/* Delete all VLANs for this dev. */
	454	for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
5c15bdec	455	vlandev = vlan_group_get_device(grp, i);
1da177e4 LT	456	if (!vlandev)
	457	continue;
	458
af301517 PM	459	/* unregistration of last vlan destroys group, abort
	460	* afterwards */
	461	if (grp->nr_vlans == 1)
	462	i = VLAN_GROUP_ARRAY_LEN;
1da177e4	463
af301517	464	unregister_vlan_dev(vlandev);
1da177e4 LT	465	}
1da177e4 LT	466	break;
3ff50b79	467	}
1da177e4 LT	468
	469	out:
	470	return NOTIFY_DONE;
	471	}
	472
69ab4b7d PM	473	static struct notifier_block vlan_notifier_block __read_mostly = {
	474	.notifier_call = vlan_device_event,
	475	};
	476
1da177e4 LT	477	/*
	478	* VLAN IOCTL handler.
	479	* o execute requested action or pass command to the device driver
	480	* arg is really a struct vlan_ioctl_args __user *.
	481	*/
881d966b	482	static int vlan_ioctl_handler(struct net net, void __user arg)
1da177e4	483	{
c17d8874	484	int err;
1da177e4 LT	485	unsigned short vid = 0;
1da177e4 LT	486	struct vlan_ioctl_args args;
c17d8874	487	struct net_device *dev = NULL;
1da177e4 LT	488
	489	if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args)))
	490	return -EFAULT;
	491
	492	/* Null terminate this sucker, just in case. */
	493	args.device1[23] = 0;
	494	args.u.device2[23] = 0;
	495
c17d8874 PM	496	rtnl_lock();
c17d8874 PM	497
1da177e4 LT	498	switch (args.cmd) {
1da177e4 LT	499	case SET_VLAN_INGRESS_PRIORITY_CMD:
c17d8874 PM	500	case SET_VLAN_EGRESS_PRIORITY_CMD:
	501	case SET_VLAN_FLAG_CMD:
	502	case ADD_VLAN_CMD:
	503	case DEL_VLAN_CMD:
	504	case GET_VLAN_REALDEV_NAME_CMD:
	505	case GET_VLAN_VID_CMD:
	506	err = -ENODEV;
881d966b	507	dev = __dev_get_by_name(&init_net, args.device1);
c17d8874 PM	508	if (!dev)
	509	goto out;
	510
	511	err = -EINVAL;
	512	if (args.cmd != ADD_VLAN_CMD &&
	513	!(dev->priv_flags & IFF_802_1Q_VLAN))
	514	goto out;
	515	}
	516
	517	switch (args.cmd) {
	518	case SET_VLAN_INGRESS_PRIORITY_CMD:
	519	err = -EPERM;
1da177e4	520	if (!capable(CAP_NET_ADMIN))
c17d8874 PM	521	break;
	522	vlan_dev_set_ingress_priority(dev,
	523	args.u.skb_priority,
	524	args.vlan_qos);
fffe470a	525	err = 0;
1da177e4 LT	526	break;
	527
	528	case SET_VLAN_EGRESS_PRIORITY_CMD:
c17d8874	529	err = -EPERM;
1da177e4	530	if (!capable(CAP_NET_ADMIN))
c17d8874 PM	531	break;
c17d8874 PM	532	err = vlan_dev_set_egress_priority(dev,
1da177e4 LT	533	args.u.skb_priority,
	534	args.vlan_qos);
	535	break;
	536
	537	case SET_VLAN_FLAG_CMD:
c17d8874	538	err = -EPERM;
1da177e4	539	if (!capable(CAP_NET_ADMIN))
c17d8874 PM	540	break;
c17d8874 PM	541	err = vlan_dev_set_vlan_flag(dev,
1da177e4 LT	542	args.u.flag,
	543	args.vlan_qos);
	544	break;
	545
	546	case SET_VLAN_NAME_TYPE_CMD:
c17d8874	547	err = -EPERM;
1da177e4	548	if (!capable(CAP_NET_ADMIN))
e35de026	549	break;
c17d8874 PM	550	if ((args.u.name_type >= 0) &&
c17d8874 PM	551	(args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
1da177e4 LT	552	vlan_name_type = args.u.name_type;
	553	err = 0;
	554	} else {
	555	err = -EINVAL;
	556	}
	557	break;
	558
	559	case ADD_VLAN_CMD:
c17d8874	560	err = -EPERM;
1da177e4	561	if (!capable(CAP_NET_ADMIN))
c17d8874	562	break;
2ae0bf69	563	err = register_vlan_device(dev, args.u.VID);
1da177e4 LT	564	break;
	565
	566	case DEL_VLAN_CMD:
c17d8874	567	err = -EPERM;
1da177e4	568	if (!capable(CAP_NET_ADMIN))
c17d8874	569	break;
af301517 PM	570	unregister_vlan_dev(dev);
af301517 PM	571	err = 0;
1da177e4 LT	572	break;
1da177e4 LT	573
1da177e4	574	case GET_VLAN_REALDEV_NAME_CMD:
3f5f4346	575	err = 0;
c17d8874	576	vlan_dev_get_realdev_name(dev, args.u.device2);
1da177e4	577	if (copy_to_user(arg, &args,
2029cc2c	578	sizeof(struct vlan_ioctl_args)))
1da177e4	579	err = -EFAULT;
1da177e4 LT	580	break;
	581
	582	case GET_VLAN_VID_CMD:
3f5f4346	583	err = 0;
c17d8874	584	vlan_dev_get_vid(dev, &vid);
1da177e4 LT	585	args.u.VID = vid;
1da177e4 LT	586	if (copy_to_user(arg, &args,
2029cc2c	587	sizeof(struct vlan_ioctl_args)))
122952fc	588	err = -EFAULT;
1da177e4 LT	589	break;
	590
	591	default:
198a291c	592	err = -EOPNOTSUPP;
c17d8874	593	break;
3ff50b79	594	}
7eb1b3d3	595	out:
c17d8874	596	rtnl_unlock();
1da177e4 LT	597	return err;
	598	}
	599
69ab4b7d PM	600	static int __init vlan_proto_init(void)
	601	{
	602	int err;
	603
	604	pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright);
	605	pr_info("All bugs added by %s\n", vlan_buggyright);
	606
	607	err = vlan_proc_init();
	608	if (err < 0)
	609	goto err1;
	610
	611	err = register_netdevice_notifier(&vlan_notifier_block);
	612	if (err < 0)
	613	goto err2;
	614
	615	err = vlan_netlink_init();
	616	if (err < 0)
	617	goto err3;
	618
	619	dev_add_pack(&vlan_packet_type);
	620	vlan_ioctl_set(vlan_ioctl_handler);
	621	return 0;
	622
	623	err3:
	624	unregister_netdevice_notifier(&vlan_notifier_block);
	625	err2:
	626	vlan_proc_cleanup();
	627	err1:
	628	return err;
	629	}
	630
	631	static void __exit vlan_cleanup_module(void)
	632	{
	633	unsigned int i;
	634
	635	vlan_ioctl_set(NULL);
	636	vlan_netlink_fini();
	637
	638	unregister_netdevice_notifier(&vlan_notifier_block);
	639
	640	dev_remove_pack(&vlan_packet_type);
	641
	642	/* This table must be empty if there are no module references left. */
	643	for (i = 0; i < VLAN_GRP_HASH_SIZE; i++)
	644	BUG_ON(!hlist_empty(&vlan_group_hash[i]));
	645
	646	vlan_proc_cleanup();
	647
	648	synchronize_net();
	649	}
	650
	651	module_init(vlan_proto_init);
	652	module_exit(vlan_cleanup_module);
	653
1da177e4 LT	654	MODULE_LICENSE("GPL");
1da177e4 LT	655	MODULE_VERSION(DRV_VERSION);