[GitHub/mt8127/android_kernel_alcatel_ttab.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 void __vlan_device_event(struct net_device *dev, unsigned long event)
{
	switch (event) {
	case NETDEV_CHANGENAME:
		vlan_proc_rem_dev(dev);
		if (vlan_proc_add_dev(dev) < 0)
			pr_warning("8021q: failed to change proc name for %s\n",
					dev->name);
		break;
	}
}

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

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

	if (is_vlan_dev(dev)) {
		__vlan_device_event(dev, event);
		goto out;
	}

	grp = __vlan_find_group(dev->ifindex);
	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
802fb176 PE	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
2029cc2c PM	389	static int vlan_device_event(struct notifier_block *unused, unsigned long event,
2029cc2c PM	390	void *ptr)
1da177e4 LT	391	{
1da177e4 LT	392	struct net_device *dev = ptr;
802fb176	393	struct vlan_group *grp;
1da177e4 LT	394	int i, flgs;
	395	struct net_device *vlandev;
	396
e9dc8653 EB	397	if (dev->nd_net != &init_net)
	398	return NOTIFY_DONE;
	399
802fb176 PE	400	if (is_vlan_dev(dev)) {
	401	__vlan_device_event(dev, event);
	402	goto out;
	403	}
	404
	405	grp = __vlan_find_group(dev->ifindex);
1da177e4 LT	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 */
1da177e4	416	for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
5c15bdec	417	vlandev = vlan_group_get_device(grp, i);
1da177e4 LT	418	if (!vlandev)
	419	continue;
	420
ddd7bf9f	421	vlan_transfer_operstate(dev, vlandev);
1da177e4 LT	422	}
	423	break;
	424
8c979c26 PM	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
d932e04a PM	432	flgs = vlandev->flags;
	433	if (!(flgs & IFF_UP))
	434	continue;
	435
8c979c26 PM	436	vlan_sync_address(dev, vlandev);
	437	}
	438	break;
	439
1da177e4 LT	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++) {
5c15bdec	443	vlandev = vlan_group_get_device(grp, i);
1da177e4 LT	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++) {
5c15bdec	458	vlandev = vlan_group_get_device(grp, i);
1da177e4 LT	459	if (!vlandev)
1da177e4 LT	460	continue;
122952fc	461
1da177e4 LT	462	flgs = vlandev->flags;
	463	if (flgs & IFF_UP)
	464	continue;
	465
	466	dev_change_flags(vlandev, flgs \| IFF_UP);
	467	}
	468	break;
122952fc	469
1da177e4 LT	470	case NETDEV_UNREGISTER:
	471	/* Delete all VLANs for this dev. */
	472	for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
5c15bdec	473	vlandev = vlan_group_get_device(grp, i);
1da177e4 LT	474	if (!vlandev)
	475	continue;
	476
af301517 PM	477	/* unregistration of last vlan destroys group, abort
	478	* afterwards */
	479	if (grp->nr_vlans == 1)
	480	i = VLAN_GROUP_ARRAY_LEN;
1da177e4	481
af301517	482	unregister_vlan_dev(vlandev);
1da177e4 LT	483	}
1da177e4 LT	484	break;
3ff50b79	485	}
1da177e4 LT	486
	487	out:
	488	return NOTIFY_DONE;
	489	}
	490
69ab4b7d PM	491	static struct notifier_block vlan_notifier_block __read_mostly = {
	492	.notifier_call = vlan_device_event,
	493	};
	494
1da177e4 LT	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	*/
881d966b	500	static int vlan_ioctl_handler(struct net net, void __user arg)
1da177e4	501	{
c17d8874	502	int err;
1da177e4 LT	503	unsigned short vid = 0;
1da177e4 LT	504	struct vlan_ioctl_args args;
c17d8874	505	struct net_device *dev = NULL;
1da177e4 LT	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
c17d8874 PM	514	rtnl_lock();
c17d8874 PM	515
1da177e4 LT	516	switch (args.cmd) {
1da177e4 LT	517	case SET_VLAN_INGRESS_PRIORITY_CMD:
c17d8874 PM	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;
881d966b	525	dev = __dev_get_by_name(&init_net, args.device1);
c17d8874 PM	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;
1da177e4	538	if (!capable(CAP_NET_ADMIN))
c17d8874 PM	539	break;
	540	vlan_dev_set_ingress_priority(dev,
	541	args.u.skb_priority,
	542	args.vlan_qos);
fffe470a	543	err = 0;
1da177e4 LT	544	break;
	545
	546	case SET_VLAN_EGRESS_PRIORITY_CMD:
c17d8874	547	err = -EPERM;
1da177e4	548	if (!capable(CAP_NET_ADMIN))
c17d8874 PM	549	break;
c17d8874 PM	550	err = vlan_dev_set_egress_priority(dev,
1da177e4 LT	551	args.u.skb_priority,
	552	args.vlan_qos);
	553	break;
	554
	555	case SET_VLAN_FLAG_CMD:
c17d8874	556	err = -EPERM;
1da177e4	557	if (!capable(CAP_NET_ADMIN))
c17d8874 PM	558	break;
c17d8874 PM	559	err = vlan_dev_set_vlan_flag(dev,
1da177e4 LT	560	args.u.flag,
	561	args.vlan_qos);
	562	break;
	563
	564	case SET_VLAN_NAME_TYPE_CMD:
c17d8874	565	err = -EPERM;
1da177e4	566	if (!capable(CAP_NET_ADMIN))
e35de026	567	break;
c17d8874 PM	568	if ((args.u.name_type >= 0) &&
c17d8874 PM	569	(args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
1da177e4 LT	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:
c17d8874	578	err = -EPERM;
1da177e4	579	if (!capable(CAP_NET_ADMIN))
c17d8874	580	break;
2ae0bf69	581	err = register_vlan_device(dev, args.u.VID);
1da177e4 LT	582	break;
	583
	584	case DEL_VLAN_CMD:
c17d8874	585	err = -EPERM;
1da177e4	586	if (!capable(CAP_NET_ADMIN))
c17d8874	587	break;
af301517 PM	588	unregister_vlan_dev(dev);
af301517 PM	589	err = 0;
1da177e4 LT	590	break;
1da177e4 LT	591
1da177e4	592	case GET_VLAN_REALDEV_NAME_CMD:
3f5f4346	593	err = 0;
c17d8874	594	vlan_dev_get_realdev_name(dev, args.u.device2);
1da177e4	595	if (copy_to_user(arg, &args,
2029cc2c	596	sizeof(struct vlan_ioctl_args)))
1da177e4	597	err = -EFAULT;
1da177e4 LT	598	break;
	599
	600	case GET_VLAN_VID_CMD:
3f5f4346	601	err = 0;
c17d8874	602	vlan_dev_get_vid(dev, &vid);
1da177e4 LT	603	args.u.VID = vid;
1da177e4 LT	604	if (copy_to_user(arg, &args,
2029cc2c	605	sizeof(struct vlan_ioctl_args)))
122952fc	606	err = -EFAULT;
1da177e4 LT	607	break;
	608
	609	default:
198a291c	610	err = -EOPNOTSUPP;
c17d8874	611	break;
3ff50b79	612	}
7eb1b3d3	613	out:
c17d8874	614	rtnl_unlock();
1da177e4 LT	615	return err;
	616	}
	617
69ab4b7d PM	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
1da177e4 LT	672	MODULE_LICENSE("GPL");
1da177e4 LT	673	MODULE_VERSION(DRV_VERSION);